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

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

@@ -19,7 +19,18 @@ import { filter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objec
 import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
 
 let Debugger = class Debugger {
-    constructor(adapterManager, dbgContribution, extensionDescription, configurationService, resourcePropertiesService, configurationResolverService, environmentService, debugService, contextKeyService, productService) {
+    constructor(
+        adapterManager,
+        dbgContribution,
+        extensionDescription,
+        configurationService,
+        resourcePropertiesService,
+        configurationResolverService,
+        environmentService,
+        debugService,
+        contextKeyService,
+        productService
+    ) {
         this.adapterManager = adapterManager;
         this.configurationService = configurationService;
         this.resourcePropertiesService = resourcePropertiesService;
@@ -29,10 +40,12 @@ let Debugger = class Debugger {
         this.contextKeyService = contextKeyService;
         this.productService = productService;
         this.mergedExtensionDescriptions = [];
-        this.debuggerContribution = { type: dbgContribution.type };
+        this.debuggerContribution = {
+            type: dbgContribution.type
+        };
         this.merge(dbgContribution, extensionDescription);
-        this.debuggerWhen = typeof this.debuggerContribution.when === 'string' ? ContextKeyExpr.deserialize(this.debuggerContribution.when) : undefined;
-        this.debuggerHiddenWhen = typeof this.debuggerContribution.hiddenWhen === 'string' ? ContextKeyExpr.deserialize(this.debuggerContribution.hiddenWhen) : undefined;
+        this.debuggerWhen = typeof this.debuggerContribution.when === "string" ? ContextKeyExpr.deserialize(this.debuggerContribution.when) : undefined;
+        this.debuggerHiddenWhen = typeof this.debuggerContribution.hiddenWhen === "string" ? ContextKeyExpr.deserialize(this.debuggerContribution.hiddenWhen) : undefined;
     }
     merge(otherDebuggerContribution, extensionDescription) {
         function mixin(destination, source, overwrite, level = 0) {
@@ -41,20 +54,18 @@ let Debugger = class Debugger {
             }
             if (isObject(source)) {
                 ( Object.keys(source)).forEach(key => {
-                    if (key !== '__proto__') {
+                    if (key !== "__proto__") {
                         if (isObject(destination[key]) && isObject(source[key])) {
                             mixin(destination[key], source[key], overwrite, level + 1);
-                        }
-                        else {
+                        } else {
                             if (key in destination) {
                                 if (overwrite) {
-                                    if (level === 0 && key === 'type') ;
-                                    else {
+                                    if (level === 0 && key === "type")
+                                        ; else {
                                         destination[key] = source[key];
                                     }
                                 }
-                            }
-                            else {
+                            } else {
                                 destination[key] = source[key];
                             }
                         }
@@ -65,7 +76,11 @@ let Debugger = class Debugger {
         }
         if (this.mergedExtensionDescriptions.indexOf(extensionDescription) < 0) {
             this.mergedExtensionDescriptions.push(extensionDescription);
-            mixin(this.debuggerContribution, otherDebuggerContribution, extensionDescription.isBuiltin);
+            mixin(
+                this.debuggerContribution,
+                otherDebuggerContribution,
+                extensionDescription.isBuiltin
+            );
             if (isDebuggerMainContribution(otherDebuggerContribution)) {
                 this.mainExtensionDescription = extensionDescription;
             }
@@ -73,19 +88,27 @@ let Debugger = class Debugger {
     }
     async startDebugging(configuration, parentSessionId) {
         const parentSession = this.debugService.getModel().getSession(parentSessionId);
-        return await this.debugService.startDebugging(undefined, configuration, { parentSession }, undefined);
+        return await this.debugService.startDebugging(undefined, configuration, {
+            parentSession
+        }, undefined);
     }
     async createDebugAdapter(session) {
-        await this.adapterManager.activateDebuggers('onDebugAdapterProtocolTracker', this.type);
+        await this.adapterManager.activateDebuggers("onDebugAdapterProtocolTracker", this.type);
         const da = this.adapterManager.createDebugAdapter(session);
         if (da) {
             return Promise.resolve(da);
         }
-        throw ( new Error(( localize(7161, "Cannot find debug adapter for type '{0}'.", this.type))));
+        throw ( new Error(( localize(7472, "Cannot find debug adapter for type '{0}'.", this.type))));
     }
     async substituteVariables(folder, config) {
         const substitutedConfig = await this.adapterManager.substituteVariables(this.type, folder, config);
-        return await this.configurationResolverService.resolveWithInteractionReplace(folder, substitutedConfig, 'launch', this.variables, substitutedConfig.__configurationTarget);
+        return await this.configurationResolverService.resolveWithInteractionReplace(
+            folder,
+            substitutedConfig,
+            "launch",
+            this.variables,
+            substitutedConfig.__configurationTarget
+        );
     }
     runInTerminal(args, sessionId) {
         return this.adapterManager.runInTerminal(this.type, args, sessionId);
@@ -140,27 +163,30 @@ 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 = ( localize(7162, "Use IntelliSense to learn about possible attributes."));
-        const comment2 = ( localize(7163, "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 = ( localize(7473, "Use IntelliSense to learn about possible attributes."));
+        const comment2 = ( localize(7474, "Hover to view descriptions of existing attributes."));
         const comment3 = ( localize(
-            7164,
+            7475,
             "For more information, visit: {0}",
-            'https://go.microsoft.com/fwlink/?linkid=830387'
+            "https://go.microsoft.com/fwlink/?linkid=830387"
         ));
         let content = [
-            '{',
+            "{",
             `\t// ${comment1}`,
             `\t// ${comment2}`,
             `\t// ${comment3}`,
             `\t"version": "0.2.0",`,
             `\t"configurations": ${configs}`,
-            '}'
+            "}"
         ].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);
     }
@@ -172,7 +198,7 @@ let Debugger = class Debugger {
         if (!aiKey) {
             return undefined;
         }
-        const sendErrorTelemtry = cleanRemoteAuthority(this.environmentService.remoteAuthority, this.productService) !== 'other';
+        const sendErrorTelemtry = cleanRemoteAuthority(this.environmentService.remoteAuthority, this.productService) !== "other";
         return {
             id: `${this.getMainExtensionDescriptor().publisher}.${this.type}`,
             aiKey,
@@ -186,35 +212,35 @@ let Debugger = class Debugger {
         return (Object.entries(this.debuggerContribution.configurationAttributes).map(([request, attributes]) => {
             const definitionId = `${this.type}:${request}`;
             const platformSpecificDefinitionId = `${this.type}:${request}:platform`;
-            const defaultRequired = ['name', 'type', 'request'];
+            const defaultRequired = ["name", "type", "request"];
             attributes.required = attributes.required && attributes.required.length ? defaultRequired.concat(attributes.required) : defaultRequired;
             attributes.additionalProperties = false;
-            attributes.type = 'object';
+            attributes.type = "object";
             if (!attributes.properties) {
                 attributes.properties = {};
             }
             const properties = attributes.properties;
-            properties['type'] = {
+            properties["type"] = {
                 enum: [this.type],
                 enumDescriptions: [this.label],
-                description: ( localize(7165, "Type of configuration.")),
-                pattern: '^(?!node2)',
+                description: ( localize(7476, "Type of configuration.")),
+                pattern: "^(?!node2)",
                 deprecationMessage: this.debuggerContribution.deprecated || (this.enabled ? undefined : debuggerDisabledMessage(this.type)),
                 doNotSuggest: !!this.debuggerContribution.deprecated,
                 errorMessage: ( localize(
-                    7166,
+                    7477,
                     "The debug type is not recognized. Make sure that you have a corresponding debug extension installed and that it is enabled."
                 )),
                 patternErrorMessage: ( localize(
-                    7167,
+                    7478,
                     "\"node2\" is no longer supported, use \"node\" instead and set the \"protocol\" attribute to \"inspector\"."
                 ))
             };
-            properties['request'] = {
+            properties["request"] = {
                 enum: [request],
-                description: ( localize(7168, "Request type of configuration. Can be \"launch\" or \"attach\".")),
+                description: ( localize(7479, "Request type of configuration. Can be \"launch\" or \"attach\"."))
             };
-            for (const prop in definitions['common'].properties) {
+            for (const prop in definitions["common"].properties) {
                 properties[prop] = {
                     $ref: `#/definitions/common/properties/${prop}`
                 };
@@ -222,27 +248,31 @@ let Debugger = class Debugger {
             ( Object.keys(properties)).forEach(name => {
                 applyDeprecatedVariableMessage(properties[name]);
             });
-            definitions[definitionId] = { ...attributes };
+            definitions[definitionId] = {
+                ...attributes
+            };
             definitions[platformSpecificDefinitionId] = {
-                type: 'object',
+                type: "object",
                 additionalProperties: false,
-                properties: filter(properties, key => key !== 'type' && key !== 'request' && key !== 'name')
+                properties: filter(properties, key => key !== "type" && key !== "request" && key !== "name")
+            };
+            const attributesCopy = {
+                ...attributes
             };
-            const attributesCopy = { ...attributes };
             attributesCopy.properties = {
                 ...properties,
                 ...{
                     windows: {
                         $ref: `#/definitions/${platformSpecificDefinitionId}`,
-                        description: ( localize(7169, "Windows specific launch configuration attributes.")),
+                        description: ( localize(7480, "Windows specific launch configuration attributes."))
                     },
                     osx: {
                         $ref: `#/definitions/${platformSpecificDefinitionId}`,
-                        description: ( localize(7170, "OS X specific launch configuration attributes.")),
+                        description: ( localize(7481, "OS X specific launch configuration attributes."))
                     },
                     linux: {
                         $ref: `#/definitions/${platformSpecificDefinitionId}`,
-                        description: ( localize(7171, "Linux specific launch configuration attributes.")),
+                        description: ( localize(7482, "Linux specific launch configuration attributes."))
                     }
                 }
             };
@@ -250,14 +280,6 @@ let Debugger = class Debugger {
         }));
     }
 };
-Debugger = ( __decorate([
-    ( __param(3, IConfigurationService)),
-    ( __param(4, ITextResourcePropertiesService)),
-    ( __param(5, IConfigurationResolverService)),
-    ( __param(6, IWorkbenchEnvironmentService)),
-    ( __param(7, IDebugService)),
-    ( __param(8, IContextKeyService)),
-    ( __param(9, IProductService))
-], Debugger));
+Debugger = ( __decorate([( __param(3, IConfigurationService)), ( __param(4, ITextResourcePropertiesService)), ( __param(5, IConfigurationResolverService)), ( __param(6, IWorkbenchEnvironmentService)), ( __param(7, IDebugService)), ( __param(8, IContextKeyService)), ( __param(9, IProductService))], Debugger));
 
 export { Debugger };

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

@@ -6,31 +6,32 @@ import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log
 import { IDebugService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/debug/common/debug.service';
 
 let ReplAccessibilityAnnouncer = class ReplAccessibilityAnnouncer extends Disposable {
-    static { this.ID = 'debug.replAccessibilityAnnouncer'; }
+    static {
+        this.ID = "debug.replAccessibilityAnnouncer";
+    }
     constructor(debugService, accessibilityService, logService) {
         super();
         const viewModel = debugService.getViewModel();
         const mutableDispoable = this._register(( new MutableDisposable()));
-        this._register(viewModel.onDidFocusSession((session) => {
+        this._register(viewModel.onDidFocusSession(session => {
             mutableDispoable.clear();
             if (!session) {
                 return;
             }
-            mutableDispoable.value = session.onDidChangeReplElements((element) => {
-                if (!element || !('originalExpression' in element)) {
+            mutableDispoable.value = session.onDidChangeReplElements(element => {
+                if (!element || !("originalExpression" in element)) {
                     return;
                 }
                 const value = ( element.toString());
                 accessibilityService.status(value);
-                logService.trace('ReplAccessibilityAnnouncer#onDidChangeReplElements', element.originalExpression + ': ' + value);
+                logService.trace(
+                    "ReplAccessibilityAnnouncer#onDidChangeReplElements",
+                    element.originalExpression + ": " + value
+                );
             });
         }));
     }
 };
-ReplAccessibilityAnnouncer = ( __decorate([
-    ( __param(0, IDebugService)),
-    ( __param(1, IAccessibilityService)),
-    ( __param(2, ILogService))
-], ReplAccessibilityAnnouncer));
+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

@@ -7,14 +7,14 @@ import { IClipboardService } from '@codingame/monaco-vscode-api/vscode/vs/platfo
 import { INotebookKernelService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookKernelService.service';
 import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
 
-const COPY_NOTEBOOK_VARIABLE_VALUE_ID = 'workbench.debug.viewlet.action.copyWorkspaceVariableValue';
-const COPY_NOTEBOOK_VARIABLE_VALUE_LABEL = ( localize(9318, "Copy Value"));
+const COPY_NOTEBOOK_VARIABLE_VALUE_ID = "workbench.debug.viewlet.action.copyWorkspaceVariableValue";
+const COPY_NOTEBOOK_VARIABLE_VALUE_LABEL = ( localize(9638, "Copy Value"));
 registerAction2(class extends Action2 {
     constructor() {
         super({
             id: COPY_NOTEBOOK_VARIABLE_VALUE_ID,
             title: COPY_NOTEBOOK_VARIABLE_VALUE_LABEL,
-            f1: false,
+            f1: false
         });
     }
     run(accessor, context) {
@@ -27,9 +27,9 @@ registerAction2(class extends Action2 {
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: '_executeNotebookVariableProvider',
-            title: ( localize(9319, "Execute Notebook Variable Provider")),
-            f1: false,
+            id: "_executeNotebookVariableProvider",
+            title: ( localize(9639, "Execute Notebook Variable Provider")),
+            f1: false
         });
     }
     async run(accessor, resource) {
@@ -45,7 +45,7 @@ registerAction2(class extends Action2 {
         }
         const selectedKernel = notebookKernelService.getMatchingKernel(notebookTextModel).selected;
         if (selectedKernel && selectedKernel.hasVariableProvider) {
-            const variableIterable = selectedKernel.provideVariables(notebookTextModel.uri, undefined, 'named', 0, CancellationToken.None);
+            const variableIterable = selectedKernel.provideVariables(notebookTextModel.uri, undefined, "named", 0, CancellationToken.None);
             const collected = [];
             for await (const variable of variableIterable) {
                 collected.push(variable);