@codingame/monaco-vscode-debug-service-override 7.1.0 → 8.0.0

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

@@ -1,5 +1,5 @@
 import { ExtensionsRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { localize } from 'vscode/vscode/vs/nls';
 import { launchSchemaId } from 'vscode/vscode/vs/workbench/services/configuration/common/configuration';
 import { inputsSchema } from 'vscode/vscode/vs/workbench/services/configurationResolver/common/configurationResolverSchema';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
@@ -7,12 +7,11 @@ import { Extensions } from 'vscode/vscode/vs/workbench/services/extensionManagem
 import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
 
-const _moduleId = "vs/workbench/contrib/debug/common/debugSchemas";
 const debuggersExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'debuggers',
     defaultExtensionKind: ['workspace'],
     jsonSchema: {
-        description: ( localizeWithPath(_moduleId, 0, 'Contributes debug adapters.')),
+        description: ( localize(10158, 'Contributes debug adapters.')),
         type: 'array',
         defaultSnippets: [{ body: [{ type: '' }] }],
         items: {
@@ -21,138 +20,119 @@ const debuggersExtPoint = ExtensionsRegistry.registerExtensionPoint({
             defaultSnippets: [{ body: { type: '', program: '', runtime: '' } }],
             properties: {
                 type: {
-                    description: ( localizeWithPath(_moduleId, 1, "Unique identifier for this debug adapter.")),
+                    description: ( localize(10159, "Unique identifier for this debug adapter.")),
                     type: 'string'
                 },
                 label: {
-                    description: ( localizeWithPath(_moduleId, 2, "Display name for this debug adapter.")),
+                    description: ( localize(10160, "Display name for this debug adapter.")),
                     type: 'string'
                 },
                 program: {
-                    description: ( localizeWithPath(
-                        _moduleId,
-                        3,
+                    description: ( localize(
+                        10161,
                         "Path to the debug adapter program. Path is either absolute or relative to the extension folder."
                     )),
                     type: 'string'
                 },
                 args: {
-                    description: ( localizeWithPath(_moduleId, 4, "Optional arguments to pass to the adapter.")),
+                    description: ( localize(10162, "Optional arguments to pass to the adapter.")),
                     type: 'array'
                 },
                 runtime: {
-                    description: ( localizeWithPath(
-                        _moduleId,
-                        5,
+                    description: ( localize(
+                        10163,
                         "Optional runtime in case the program attribute is not an executable but requires a runtime."
                     )),
                     type: 'string'
                 },
                 runtimeArgs: {
-                    description: ( localizeWithPath(_moduleId, 6, "Optional runtime arguments.")),
+                    description: ( localize(10164, "Optional runtime arguments.")),
                     type: 'array'
                 },
                 variables: {
-                    description: ( localizeWithPath(
-                        _moduleId,
-                        7,
+                    description: ( localize(
+                        10165,
                         "Mapping from interactive variables (e.g. ${action.pickProcess}) in `launch.json` to a command."
                     )),
                     type: 'object'
                 },
                 initialConfigurations: {
-                    description: ( localizeWithPath(_moduleId, 8, "Configurations for generating the initial \'launch.json\'.")),
+                    description: ( localize(10166, "Configurations for generating the initial \'launch.json\'.")),
                     type: ['array', 'string'],
                 },
                 languages: {
-                    description: ( localizeWithPath(
-                        _moduleId,
-                        9,
+                    description: ( localize(
+                        10167,
                         "List of languages for which the debug extension could be considered the \"default debugger\"."
                     )),
                     type: 'array'
                 },
                 configurationSnippets: {
-                    description: ( localizeWithPath(
-                        _moduleId,
-                        10,
-                        "Snippets for adding new configurations in \'launch.json\'."
-                    )),
+                    description: ( localize(10168, "Snippets for adding new configurations in \'launch.json\'.")),
                     type: 'array'
                 },
                 configurationAttributes: {
-                    description: ( localizeWithPath(
-                        _moduleId,
-                        11,
-                        "JSON schema configurations for validating \'launch.json\'."
-                    )),
+                    description: ( localize(10169, "JSON schema configurations for validating \'launch.json\'.")),
                     type: 'object'
                 },
                 when: {
-                    description: ( localizeWithPath(
-                        _moduleId,
-                        12,
+                    description: ( localize(
+                        10170,
                         "Condition which must be true to enable this type of debugger. Consider using 'shellExecutionSupported', 'virtualWorkspace', 'resourceScheme' or an extension-defined context key as appropriate for this."
                     )),
                     type: 'string',
                     default: ''
                 },
                 hiddenWhen: {
-                    description: ( localizeWithPath(
-                        _moduleId,
-                        13,
+                    description: ( localize(
+                        10171,
                         "When this condition is true, this debugger type is hidden from the debugger list, but is still enabled."
                     )),
                     type: 'string',
                     default: ''
                 },
                 deprecated: {
-                    description: ( localizeWithPath(
-                        _moduleId,
-                        14,
-                        "Optional message to mark this debug type as being deprecated."
-                    )),
+                    description: ( localize(10172, "Optional message to mark this debug type as being deprecated.")),
                     type: 'string',
                     default: ''
                 },
                 windows: {
-                    description: ( localizeWithPath(_moduleId, 15, "Windows specific settings.")),
+                    description: ( localize(10173, "Windows specific settings.")),
                     type: 'object',
                     properties: {
                         runtime: {
-                            description: ( localizeWithPath(_moduleId, 16, "Runtime used for Windows.")),
+                            description: ( localize(10174, "Runtime used for Windows.")),
                             type: 'string'
                         }
                     }
                 },
                 osx: {
-                    description: ( localizeWithPath(_moduleId, 17, "macOS specific settings.")),
+                    description: ( localize(10175, "macOS specific settings.")),
                     type: 'object',
                     properties: {
                         runtime: {
-                            description: ( localizeWithPath(_moduleId, 18, "Runtime used for macOS.")),
+                            description: ( localize(10176, "Runtime used for macOS.")),
                             type: 'string'
                         }
                     }
                 },
                 linux: {
-                    description: ( localizeWithPath(_moduleId, 19, "Linux specific settings.")),
+                    description: ( localize(10177, "Linux specific settings.")),
                     type: 'object',
                     properties: {
                         runtime: {
-                            description: ( localizeWithPath(_moduleId, 20, "Runtime used for Linux.")),
+                            description: ( localize(10178, "Runtime used for Linux.")),
                             type: 'string'
                         }
                     }
                 },
                 strings: {
-                    description: ( localizeWithPath(_moduleId, 21, "UI strings contributed by this debug adapter.")),
+                    description: ( localize(10179, "UI strings contributed by this debug adapter.")),
                     type: 'object',
                     properties: {
                         unverifiedBreakpoints: {
-                            description: ( localizeWithPath(
-                                _moduleId,
-                                22,
+                            description: ( localize(
+                                10180,
                                 "When there are unverified breakpoints in a language supported by this debug adapter, this message will appear on the breakpoint hover and in the breakpoints view. Markdown and command links are supported."
                             )),
                             type: 'string'
@@ -166,7 +146,7 @@ const debuggersExtPoint = ExtensionsRegistry.registerExtensionPoint({
 const breakpointsExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'breakpoints',
     jsonSchema: {
-        description: ( localizeWithPath(_moduleId, 23, 'Contributes breakpoints.')),
+        description: ( localize(10181, 'Contributes breakpoints.')),
         type: 'array',
         defaultSnippets: [{ body: [{ language: '' }] }],
         items: {
@@ -175,13 +155,12 @@ const breakpointsExtPoint = ExtensionsRegistry.registerExtensionPoint({
             defaultSnippets: [{ body: { language: '' } }],
             properties: {
                 language: {
-                    description: ( localizeWithPath(_moduleId, 24, "Allow breakpoints for this language.")),
+                    description: ( localize(10182, "Allow breakpoints for this language.")),
                     type: 'string'
                 },
                 when: {
-                    description: ( localizeWithPath(
-                        _moduleId,
-                        25,
+                    description: ( localize(
+                        10183,
                         "Condition which must be true to enable breakpoints in this language. Consider matching this to the debugger when clause as appropriate."
                     )),
                     type: 'string',
@@ -193,36 +172,32 @@ const breakpointsExtPoint = ExtensionsRegistry.registerExtensionPoint({
 });
 const presentationSchema = {
     type: 'object',
-    description: ( localizeWithPath(
-        _moduleId,
-        26,
+    description: ( localize(
+        10184,
         "Presentation options on how to show this configuration in the debug configuration dropdown and the command palette."
     )),
     properties: {
         hidden: {
             type: 'boolean',
             default: false,
-            description: ( localizeWithPath(
-                _moduleId,
-                27,
+            description: ( localize(
+                10185,
                 "Controls if this configuration should be shown in the configuration dropdown and the command palette."
             ))
         },
         group: {
             type: 'string',
             default: '',
-            description: ( localizeWithPath(
-                _moduleId,
-                28,
+            description: ( localize(
+                10186,
                 "Group that this configuration belongs to. Used for grouping and sorting in the configuration dropdown and the command palette."
             ))
         },
         order: {
             type: 'number',
             default: 1,
-            description: ( localizeWithPath(
-                _moduleId,
-                29,
+            description: ( localize(
+                10187,
                 "Order of this configuration within a group. Used for grouping and sorting in the configuration dropdown and the command palette."
             ))
         }
@@ -237,7 +212,7 @@ const defaultCompound = { name: 'Compound', configurations: [] };
 const launchSchema = {
     id: launchSchemaId,
     type: 'object',
-    title: ( localizeWithPath(_moduleId, 30, "Launch")),
+    title: ( localize(10188, "Launch")),
     allowTrailingCommas: true,
     allowComments: true,
     required: [],
@@ -245,14 +220,13 @@ const launchSchema = {
     properties: {
         version: {
             type: 'string',
-            description: ( localizeWithPath(_moduleId, 31, "Version of this file format.")),
+            description: ( localize(10189, "Version of this file format.")),
             default: '0.2.0'
         },
         configurations: {
             type: 'array',
-            description: ( localizeWithPath(
-                _moduleId,
-                32,
+            description: ( localize(
+                10190,
                 "List of configurations. Add new configurations or edit existing ones by using IntelliSense."
             )),
             items: {
@@ -263,9 +237,8 @@ const launchSchema = {
         },
         compounds: {
             type: 'array',
-            description: ( localizeWithPath(
-                _moduleId,
-                33,
+            description: ( localize(
+                10191,
                 "List of compounds. Each compound references multiple configurations which will get launched together."
             )),
             items: {
@@ -274,9 +247,8 @@ const launchSchema = {
                 properties: {
                     name: {
                         type: 'string',
-                        description: ( localizeWithPath(
-                            _moduleId,
-                            34,
+                        description: ( localize(
+                            10192,
                             "Name of compound. Appears in the launch configuration drop down menu."
                         ))
                     },
@@ -287,49 +259,42 @@ const launchSchema = {
                         items: {
                             oneOf: [{
                                     enum: [],
-                                    description: ( localizeWithPath(_moduleId, 35, "Please use unique configuration names."))
+                                    description: ( localize(10193, "Please use unique configuration names."))
                                 }, {
                                     type: 'object',
                                     required: ['name'],
                                     properties: {
                                         name: {
                                             enum: [],
-                                            description: ( localizeWithPath(
-                                                _moduleId,
-                                                34,
+                                            description: ( localize(
+                                                10193,
                                                 "Name of compound. Appears in the launch configuration drop down menu."
                                             ))
                                         },
                                         folder: {
                                             enum: [],
-                                            description: ( localizeWithPath(_moduleId, 36, "Name of folder in which the compound is located."))
+                                            description: ( localize(10194, "Name of folder in which the compound is located."))
                                         }
                                     }
                                 }]
                         },
-                        description: ( localizeWithPath(
-                            _moduleId,
-                            37,
+                        description: ( localize(
+                            10195,
                             "Names of configurations that will be started as part of this compound."
                         ))
                     },
                     stopAll: {
                         type: 'boolean',
                         default: false,
-                        description: ( localizeWithPath(
-                            _moduleId,
-                            38,
+                        description: ( localize(
+                            10196,
                             "Controls whether manually terminating one session will stop all of the compound sessions."
                         ))
                     },
                     preLaunchTask: {
                         type: 'string',
                         default: '',
-                        description: ( localizeWithPath(
-                            _moduleId,
-                            39,
-                            "Task to run before any of the compound configurations start."
-                        ))
+                        description: ( localize(10197, "Task to run before any of the compound configurations start."))
                     }
                 },
                 default: defaultCompound
@@ -355,8 +320,8 @@ class DebuggersDataRenderer extends Disposable {
             return { data: { headers: [], rows: [] }, dispose: () => { } };
         }
         const headers = [
-            ( localizeWithPath(_moduleId, 40, "Name")),
-            ( localizeWithPath(_moduleId, 41, "Type")),
+            ( localize(10198, "Name")),
+            ( localize(10199, "Type")),
         ];
         const rows = ( (contrib.map(d => {
             return [
@@ -375,7 +340,7 @@ class DebuggersDataRenderer extends Disposable {
 }
 ( (Registry.as(Extensions.ExtensionFeaturesRegistry))).registerExtensionFeature({
     id: 'debuggers',
-    label: ( localizeWithPath(_moduleId, 42, "Debuggers")),
+    label: ( localize(10200, "Debuggers")),
     access: {
         canToggle: false
     },

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

@@ -1,5 +1,5 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { localize } from 'vscode/vscode/vs/nls';
 import { isObject } from 'vscode/vscode/vs/base/common/types';
 import { DebugConfigurationProviderTriggerKind, debuggerDisabledMessage } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
 import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug.service';
@@ -16,7 +16,6 @@ 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;
@@ -79,9 +78,7 @@ let Debugger = class Debugger {
         if (da) {
             return Promise.resolve(da);
         }
-        throw ( (new Error(
-            localizeWithPath(_moduleId, 0, "Cannot find debug adapter for type '{0}'.", this.type)
-        )));
+        throw ( (new Error(localize(10147, "Cannot find debug adapter for type '{0}'.", this.type))));
     }
     async substituteVariables(folder, config) {
         const substitutedConfig = await this.adapterManager.substituteVariables(this.type, folder, config);
@@ -142,11 +139,10 @@ let Debugger = class Debugger {
         }
         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(
-            _moduleId,
-            3,
+        const comment1 = ( localize(10148, "Use IntelliSense to learn about possible attributes."));
+        const comment2 = ( localize(10149, "Hover to view descriptions of existing attributes."));
+        const comment3 = ( localize(
+            10150,
             "For more information, visit: {0}",
             'https://go.microsoft.com/fwlink/?linkid=830387'
         ));
@@ -200,28 +196,22 @@ let Debugger = class Debugger {
                 properties['type'] = {
                     enum: [this.type],
                     enumDescriptions: [this.label],
-                    description: ( localizeWithPath(_moduleId, 4, "Type of configuration.")),
+                    description: ( localize(10151, "Type of configuration.")),
                     pattern: '^(?!node2)',
                     deprecationMessage: this.debuggerContribution.deprecated || (this.enabled ? undefined : debuggerDisabledMessage(this.type)),
                     doNotSuggest: !!this.debuggerContribution.deprecated,
-                    errorMessage: ( localizeWithPath(
-                        _moduleId,
-                        5,
+                    errorMessage: ( localize(
+                        10152,
                         "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,
+                    patternErrorMessage: ( localize(
+                        10153,
                         "\"node2\" is no longer supported, use \"node\" instead and set the \"protocol\" attribute to \"inspector\"."
                     ))
                 };
                 properties['request'] = {
                     enum: [request],
-                    description: ( localizeWithPath(
-                        _moduleId,
-                        7,
-                        "Request type of configuration. Can be \"launch\" or \"attach\"."
-                    )),
+                    description: ( localize(10154, "Request type of configuration. Can be \"launch\" or \"attach\".")),
                 };
                 for (const prop in definitions['common'].properties) {
                     properties[prop] = {
@@ -243,15 +233,15 @@ let Debugger = class Debugger {
                     ...{
                         windows: {
                             $ref: `#/definitions/${platformSpecificDefinitionId}`,
-                            description: ( localizeWithPath(_moduleId, 8, "Windows specific launch configuration attributes.")),
+                            description: ( localize(10155, "Windows specific launch configuration attributes.")),
                         },
                         osx: {
                             $ref: `#/definitions/${platformSpecificDefinitionId}`,
-                            description: ( localizeWithPath(_moduleId, 9, "OS X specific launch configuration attributes.")),
+                            description: ( localize(10156, "OS X specific launch configuration attributes.")),
                         },
                         linux: {
                             $ref: `#/definitions/${platformSpecificDefinitionId}`,
-                            description: ( localizeWithPath(_moduleId, 10, "Linux specific launch configuration attributes.")),
+                            description: ( localize(10157, "Linux specific launch configuration attributes.")),
                         }
                     }
                 };

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

@@ -0,0 +1,33 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IAccessibilityService } from 'vscode/vscode/vs/platform/accessibility/common/accessibility.service';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug.service';
+
+let ReplAccessibilityAnnouncer = class ReplAccessibilityAnnouncer extends Disposable {
+    static { this.ID = 'debug.replAccessibilityAnnouncer'; }
+    constructor(debugService, accessibilityService, logService) {
+        super();
+        const viewModel = debugService.getViewModel();
+        this._register(viewModel.onDidFocusSession((session) => {
+            if (!session) {
+                return;
+            }
+            this._register(session.onDidChangeReplElements((element) => {
+                if (!element || !('originalExpression' in element)) {
+                    return;
+                }
+                const value = ( element.toString());
+                accessibilityService.status(value);
+                logService.trace('ReplAccessibilityAnnouncer#onDidChangeReplElements', element.originalExpression + ': ' + value);
+            }));
+        }));
+    }
+};
+ReplAccessibilityAnnouncer = ( __decorate([
+    ( __param(0, IDebugService)),
+    ( __param(1, IAccessibilityService)),
+    ( __param(2, ILogService))
+], ReplAccessibilityAnnouncer));
+
+export { ReplAccessibilityAnnouncer };

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

@@ -1,14 +1,13 @@
 import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { localize } from 'vscode/vscode/vs/nls';
 import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
 import { IClipboardService } from 'vscode/vscode/vs/platform/clipboard/common/clipboardService.service';
 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(_moduleId, 0, "Copy Value"));
+const COPY_NOTEBOOK_VARIABLE_VALUE_LABEL = ( localize(6077, "Copy Value"));
 registerAction2(class extends Action2 {
     constructor() {
         super({
@@ -28,7 +27,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: '_executeNotebookVariableProvider',
-            title: ( localizeWithPath(_moduleId, 1, "Execute Notebook Variable Provider")),
+            title: ( localize(6078, "Execute Notebook Variable Provider")),
             f1: false,
         });
     }