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

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

@@ -9,134 +9,144 @@ import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/
 import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
 
 const debuggersExtPoint = ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'debuggers',
-    defaultExtensionKind: ['workspace'],
+    extensionPoint: "debuggers",
+    defaultExtensionKind: ["workspace"],
     jsonSchema: {
-        description: ( localize(7117, 'Contributes debug adapters.')),
-        type: 'array',
-        defaultSnippets: [{ body: [{ type: '' }] }],
+        description: ( localize(7428, "Contributes debug adapters.")),
+        type: "array",
+        defaultSnippets: [{
+            body: [{
+                type: ""
+            }]
+        }],
         items: {
             additionalProperties: false,
-            type: 'object',
-            defaultSnippets: [{ body: { type: '', program: '', runtime: '' } }],
+            type: "object",
+            defaultSnippets: [{
+                body: {
+                    type: "",
+                    program: "",
+                    runtime: ""
+                }
+            }],
             properties: {
                 type: {
-                    description: ( localize(7118, "Unique identifier for this debug adapter.")),
-                    type: 'string'
+                    description: ( localize(7429, "Unique identifier for this debug adapter.")),
+                    type: "string"
                 },
                 label: {
-                    description: ( localize(7119, "Display name for this debug adapter.")),
-                    type: 'string'
+                    description: ( localize(7430, "Display name for this debug adapter.")),
+                    type: "string"
                 },
                 program: {
                     description: ( localize(
-                        7120,
+                        7431,
                         "Path to the debug adapter program. Path is either absolute or relative to the extension folder."
                     )),
-                    type: 'string'
+                    type: "string"
                 },
                 args: {
-                    description: ( localize(7121, "Optional arguments to pass to the adapter.")),
-                    type: 'array'
+                    description: ( localize(7432, "Optional arguments to pass to the adapter.")),
+                    type: "array"
                 },
                 runtime: {
                     description: ( localize(
-                        7122,
+                        7433,
                         "Optional runtime in case the program attribute is not an executable but requires a runtime."
                     )),
-                    type: 'string'
+                    type: "string"
                 },
                 runtimeArgs: {
-                    description: ( localize(7123, "Optional runtime arguments.")),
-                    type: 'array'
+                    description: ( localize(7434, "Optional runtime arguments.")),
+                    type: "array"
                 },
                 variables: {
                     description: ( localize(
-                        7124,
+                        7435,
                         "Mapping from interactive variables (e.g. ${action.pickProcess}) in `launch.json` to a command."
                     )),
-                    type: 'object'
+                    type: "object"
                 },
                 initialConfigurations: {
-                    description: ( localize(7125, "Configurations for generating the initial \'launch.json\'.")),
-                    type: ['array', 'string'],
+                    description: ( localize(7436, "Configurations for generating the initial 'launch.json'.")),
+                    type: ["array", "string"]
                 },
                 languages: {
                     description: ( localize(
-                        7126,
+                        7437,
                         "List of languages for which the debug extension could be considered the \"default debugger\"."
                     )),
-                    type: 'array'
+                    type: "array"
                 },
                 configurationSnippets: {
-                    description: ( localize(7127, "Snippets for adding new configurations in \'launch.json\'.")),
-                    type: 'array'
+                    description: ( localize(7438, "Snippets for adding new configurations in 'launch.json'.")),
+                    type: "array"
                 },
                 configurationAttributes: {
-                    description: ( localize(7128, "JSON schema configurations for validating \'launch.json\'.")),
-                    type: 'object'
+                    description: ( localize(7439, "JSON schema configurations for validating 'launch.json'.")),
+                    type: "object"
                 },
                 when: {
                     description: ( localize(
-                        7129,
+                        7440,
                         "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: ''
+                    type: "string",
+                    default: ""
                 },
                 hiddenWhen: {
                     description: ( localize(
-                        7130,
+                        7441,
                         "When this condition is true, this debugger type is hidden from the debugger list, but is still enabled."
                     )),
-                    type: 'string',
-                    default: ''
+                    type: "string",
+                    default: ""
                 },
                 deprecated: {
-                    description: ( localize(7131, "Optional message to mark this debug type as being deprecated.")),
-                    type: 'string',
-                    default: ''
+                    description: ( localize(7442, "Optional message to mark this debug type as being deprecated.")),
+                    type: "string",
+                    default: ""
                 },
                 windows: {
-                    description: ( localize(7132, "Windows specific settings.")),
-                    type: 'object',
+                    description: ( localize(7443, "Windows specific settings.")),
+                    type: "object",
                     properties: {
                         runtime: {
-                            description: ( localize(7133, "Runtime used for Windows.")),
-                            type: 'string'
+                            description: ( localize(7444, "Runtime used for Windows.")),
+                            type: "string"
                         }
                     }
                 },
                 osx: {
-                    description: ( localize(7134, "macOS specific settings.")),
-                    type: 'object',
+                    description: ( localize(7445, "macOS specific settings.")),
+                    type: "object",
                     properties: {
                         runtime: {
-                            description: ( localize(7135, "Runtime used for macOS.")),
-                            type: 'string'
+                            description: ( localize(7446, "Runtime used for macOS.")),
+                            type: "string"
                         }
                     }
                 },
                 linux: {
-                    description: ( localize(7136, "Linux specific settings.")),
-                    type: 'object',
+                    description: ( localize(7447, "Linux specific settings.")),
+                    type: "object",
                     properties: {
                         runtime: {
-                            description: ( localize(7137, "Runtime used for Linux.")),
-                            type: 'string'
+                            description: ( localize(7448, "Runtime used for Linux.")),
+                            type: "string"
                         }
                     }
                 },
                 strings: {
-                    description: ( localize(7138, "UI strings contributed by this debug adapter.")),
-                    type: 'object',
+                    description: ( localize(7449, "UI strings contributed by this debug adapter.")),
+                    type: "object",
                     properties: {
                         unverifiedBreakpoints: {
                             description: ( localize(
-                                7139,
+                                7450,
                                 "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'
+                            type: "string"
                         }
                     }
                 }
@@ -145,164 +155,177 @@ const debuggersExtPoint = ExtensionsRegistry.registerExtensionPoint({
     }
 });
 const breakpointsExtPoint = ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'breakpoints',
+    extensionPoint: "breakpoints",
     jsonSchema: {
-        description: ( localize(7140, 'Contributes breakpoints.')),
-        type: 'array',
-        defaultSnippets: [{ body: [{ language: '' }] }],
+        description: ( localize(7451, "Contributes breakpoints.")),
+        type: "array",
+        defaultSnippets: [{
+            body: [{
+                language: ""
+            }]
+        }],
         items: {
-            type: 'object',
+            type: "object",
             additionalProperties: false,
-            defaultSnippets: [{ body: { language: '' } }],
+            defaultSnippets: [{
+                body: {
+                    language: ""
+                }
+            }],
             properties: {
                 language: {
-                    description: ( localize(7141, "Allow breakpoints for this language.")),
-                    type: 'string'
+                    description: ( localize(7452, "Allow breakpoints for this language.")),
+                    type: "string"
                 },
                 when: {
                     description: ( localize(
-                        7142,
+                        7453,
                         "Condition which must be true to enable breakpoints in this language. Consider matching this to the debugger when clause as appropriate."
                     )),
-                    type: 'string',
-                    default: ''
+                    type: "string",
+                    default: ""
                 }
             }
         }
     }
 });
 const presentationSchema = {
-    type: 'object',
+    type: "object",
     description: ( localize(
-        7143,
+        7454,
         "Presentation options on how to show this configuration in the debug configuration dropdown and the command palette."
     )),
     properties: {
         hidden: {
-            type: 'boolean',
+            type: "boolean",
             default: false,
             description: ( localize(
-                7144,
+                7455,
                 "Controls if this configuration should be shown in the configuration dropdown and the command palette."
             ))
         },
         group: {
-            type: 'string',
-            default: '',
+            type: "string",
+            default: "",
             description: ( localize(
-                7145,
+                7456,
                 "Group that this configuration belongs to. Used for grouping and sorting in the configuration dropdown and the command palette."
             ))
         },
         order: {
-            type: 'number',
+            type: "number",
             default: 1,
             description: ( localize(
-                7146,
+                7457,
                 "Order of this configuration within a group. Used for grouping and sorting in the configuration dropdown and the command palette."
             ))
         }
     },
     default: {
         hidden: false,
-        group: '',
+        group: "",
         order: 1
     }
 };
-const defaultCompound = { name: 'Compound', configurations: [] };
+const defaultCompound = {
+    name: "Compound",
+    configurations: []
+};
 const launchSchema = {
     id: launchSchemaId,
-    type: 'object',
-    title: ( localize(7147, "Launch")),
+    type: "object",
+    title: ( localize(7458, "Launch")),
     allowTrailingCommas: true,
     allowComments: true,
     required: [],
-    default: { version: '0.2.0', configurations: [], compounds: [] },
+    default: {
+        version: "0.2.0",
+        configurations: [],
+        compounds: []
+    },
     properties: {
         version: {
-            type: 'string',
-            description: ( localize(7148, "Version of this file format.")),
-            default: '0.2.0'
+            type: "string",
+            description: ( localize(7459, "Version of this file format.")),
+            default: "0.2.0"
         },
         configurations: {
-            type: 'array',
+            type: "array",
             description: ( localize(
-                7149,
+                7460,
                 "List of configurations. Add new configurations or edit existing ones by using IntelliSense."
             )),
             items: {
                 defaultSnippets: [],
-                'type': 'object',
+                "type": "object",
                 oneOf: []
             }
         },
         compounds: {
-            type: 'array',
+            type: "array",
             description: ( localize(
-                7150,
+                7461,
                 "List of compounds. Each compound references multiple configurations which will get launched together."
             )),
             items: {
-                type: 'object',
-                required: ['name', 'configurations'],
+                type: "object",
+                required: ["name", "configurations"],
                 properties: {
                     name: {
-                        type: 'string',
+                        type: "string",
                         description: ( localize(
-                            7151,
+                            7462,
                             "Name of compound. Appears in the launch configuration drop down menu."
                         ))
                     },
                     presentation: presentationSchema,
                     configurations: {
-                        type: 'array',
+                        type: "array",
                         default: [],
                         items: {
                             oneOf: [{
-                                    enum: [],
-                                    description: ( localize(7152, "Please use unique configuration names."))
-                                }, {
-                                    type: 'object',
-                                    required: ['name'],
-                                    properties: {
-                                        name: {
-                                            enum: [],
-                                            description: ( localize(
-                                                7151,
-                                                "Name of compound. Appears in the launch configuration drop down menu."
-                                            ))
-                                        },
-                                        folder: {
-                                            enum: [],
-                                            description: ( localize(7153, "Name of folder in which the compound is located."))
-                                        }
+                                enum: [],
+                                description: ( localize(7463, "Please use unique configuration names."))
+                            }, {
+                                type: "object",
+                                required: ["name"],
+                                properties: {
+                                    name: {
+                                        enum: [],
+                                        description: ( localize(
+                                            7462,
+                                            "Name of compound. Appears in the launch configuration drop down menu."
+                                        ))
+                                    },
+                                    folder: {
+                                        enum: [],
+                                        description: ( localize(7464, "Name of folder in which the compound is located."))
                                     }
-                                }]
+                                }
+                            }]
                         },
                         description: ( localize(
-                            7154,
+                            7465,
                             "Names of configurations that will be started as part of this compound."
                         ))
                     },
                     stopAll: {
-                        type: 'boolean',
+                        type: "boolean",
                         default: false,
                         description: ( localize(
-                            7155,
+                            7466,
                             "Controls whether manually terminating one session will stop all of the compound sessions."
                         ))
                     },
                     preLaunchTask: {
-                        type: 'string',
-                        default: '',
-                        description: ( localize(7156, "Task to run before any of the compound configurations start."))
+                        type: "string",
+                        default: "",
+                        description: ( localize(7467, "Task to run before any of the compound configurations start."))
                     }
                 },
                 default: defaultCompound
             },
-            default: [
-                defaultCompound
-            ]
+            default: [defaultCompound]
         },
         inputs: inputsSchema.definitions.inputs
     }
@@ -310,7 +333,7 @@ const launchSchema = {
 class DebuggersDataRenderer extends Disposable {
     constructor() {
         super(...arguments);
-        this.type = 'table';
+        this.type = "table";
     }
     shouldRender(manifest) {
         return !!manifest.contributes?.debuggers;
@@ -318,34 +341,34 @@ class DebuggersDataRenderer extends Disposable {
     render(manifest) {
         const contrib = manifest.contributes?.debuggers || [];
         if (!contrib.length) {
-            return { data: { headers: [], rows: [] }, dispose: () => { } };
+            return {
+                data: {
+                    headers: [],
+                    rows: []
+                },
+                dispose: () => {}
+            };
         }
-        const headers = [
-            ( localize(7157, "Name")),
-            ( localize(7158, "Type")),
-        ];
+        const headers = [( localize(7468, "Name")), ( localize(7469, "Type"))];
         const rows = ( contrib.map(d => {
-            return [
-                d.label ?? '',
-                d.type
-            ];
+            return [d.label ?? "", d.type];
         }));
         return {
             data: {
                 headers,
                 rows
             },
-            dispose: () => { }
+            dispose: () => {}
         };
     }
 }
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
-    id: 'debuggers',
-    label: ( localize(7159, "Debuggers")),
+    id: "debuggers",
+    label: ( localize(7470, "Debuggers")),
     access: {
         canToggle: false
     },
-    renderer: ( new SyncDescriptor(DebuggersDataRenderer)),
+    renderer: ( new SyncDescriptor(DebuggersDataRenderer))
 });
 
 export { breakpointsExtPoint, debuggersExtPoint, launchSchema, presentationSchema };