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

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

@@ -26,14 +26,43 @@ import { CONTEXT_DEBUGGERS_AVAILABLE, CONTEXT_DEBUG_EXTENSION_AVAILABLE } from '
 import { IDebugService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/debug/common/debug.service';
 import { DEBUG_START_COMMAND_ID, DEBUG_CONFIGURE_COMMAND_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/debug/browser/debugCommands';
 
-const debugStartLanguageKey = 'debugStartLanguage';
+const debugStartLanguageKey = "debugStartLanguage";
 const CONTEXT_DEBUG_START_LANGUAGE = ( new RawContextKey(debugStartLanguageKey, undefined));
-const CONTEXT_DEBUGGER_INTERESTED_IN_ACTIVE_EDITOR = ( new RawContextKey('debuggerInterestedInActiveEditor', false));
+const CONTEXT_DEBUGGER_INTERESTED_IN_ACTIVE_EDITOR = ( new RawContextKey("debuggerInterestedInActiveEditor", false));
 let WelcomeView = class WelcomeView extends ViewPane {
-    static { this.ID = 'workbench.debug.welcome'; }
-    static { this.LABEL = ( localize2(7032, "Run")); }
-    constructor(options, themeService, keybindingService, contextMenuService, configurationService, contextKeyService, debugService, editorService, instantiationService, viewDescriptorService, openerService, storageSevice, hoverService) {
-        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, hoverService);
+    static {
+        this.ID = "workbench.debug.welcome";
+    }
+    static {
+        this.LABEL = ( localize2(7343, "Run"));
+    }
+    constructor(
+        options,
+        themeService,
+        keybindingService,
+        contextMenuService,
+        configurationService,
+        contextKeyService,
+        debugService,
+        editorService,
+        instantiationService,
+        viewDescriptorService,
+        openerService,
+        storageSevice,
+        hoverService
+    ) {
+        super(
+            options,
+            keybindingService,
+            contextMenuService,
+            configurationService,
+            contextKeyService,
+            viewDescriptorService,
+            instantiationService,
+            openerService,
+            themeService,
+            hoverService
+        );
         this.debugService = debugService;
         this.editorService = editorService;
         this.debugStartLanguageContext = CONTEXT_DEBUG_START_LANGUAGE.bindTo(contextKeyService);
@@ -51,7 +80,12 @@ let WelcomeView = class WelcomeView extends ViewPane {
                 if (language && this.debugService.getAdapterManager().someDebuggerInterestedInLanguage(language)) {
                     this.debugStartLanguageContext.set(language);
                     this.debuggerInterestedContext.set(true);
-                    storageSevice.store(debugStartLanguageKey, language, StorageScope.WORKSPACE, StorageTarget.MACHINE);
+                    storageSevice.store(
+                        debugStartLanguageKey,
+                        language,
+                        StorageScope.WORKSPACE,
+                        StorageTarget.MACHINE
+                    );
                     return;
                 }
             }
@@ -77,65 +111,53 @@ let WelcomeView = class WelcomeView extends ViewPane {
             }
         }));
         setContextKey();
-        const debugKeybinding = this.keybindingService.lookupKeybinding(DEBUG_START_COMMAND_ID);
-        debugKeybindingLabel = debugKeybinding ? ` (${debugKeybinding.getLabel()})` : '';
+        debugKeybindingLabel = this.keybindingService.appendKeybinding("", DEBUG_START_COMMAND_ID);
     }
     shouldShowWelcome() {
         return true;
     }
 };
-WelcomeView = ( __decorate([
-    ( __param(1, IThemeService)),
-    ( __param(2, IKeybindingService)),
-    ( __param(3, IContextMenuService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IContextKeyService)),
-    ( __param(6, IDebugService)),
-    ( __param(7, IEditorService)),
-    ( __param(8, IInstantiationService)),
-    ( __param(9, IViewDescriptorService)),
-    ( __param(10, IOpenerService)),
-    ( __param(11, IStorageService)),
-    ( __param(12, IHoverService))
-], WelcomeView));
+WelcomeView = ( __decorate([( __param(1, IThemeService)), ( __param(2, IKeybindingService)), ( __param(3, IContextMenuService)), ( __param(4, IConfigurationService)), ( __param(5, IContextKeyService)), ( __param(6, IDebugService)), ( __param(7, IEditorService)), ( __param(8, IInstantiationService)), ( __param(9, IViewDescriptorService)), ( __param(10, IOpenerService)), ( __param(11, IStorageService)), ( __param(12, IHoverService))], WelcomeView));
 const viewsRegistry = ( Registry.as(Extensions.ViewsRegistry));
 viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
     content: ( localize(
-        7033,
+        7344,
         "[Open a file](command:{0}) which can be debugged or run.",
         OpenFileAction.ID
     )),
     when: ( ContextKeyExpr.and(CONTEXT_DEBUGGERS_AVAILABLE, ( CONTEXT_DEBUGGER_INTERESTED_IN_ACTIVE_EDITOR.toNegated()))),
-    group: ViewContentGroups.Open,
+    group: ViewContentGroups.Open
 });
-let debugKeybindingLabel = '';
+let debugKeybindingLabel = "";
 viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
-    content: `[${( localize(7034, "Run and Debug"))}${debugKeybindingLabel}](command:${DEBUG_START_COMMAND_ID})`,
+    content: `[${( localize(7345, "Run and Debug"))}${debugKeybindingLabel}](command:${DEBUG_START_COMMAND_ID})`,
     when: CONTEXT_DEBUGGERS_AVAILABLE,
     group: ViewContentGroups.Debug,
     order: 1
 });
 viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
     content: ( localize(
-        7035,
+        7346,
         "To customize Run and Debug [create a launch.json file]({0}).",
-        `${( createCommandUri(DEBUG_CONFIGURE_COMMAND_ID, { addNew: true }).toString())}`
+        `${( createCommandUri(DEBUG_CONFIGURE_COMMAND_ID, {
+        addNew: true
+    }).toString())}`
     )),
-    when: ( ContextKeyExpr.and(CONTEXT_DEBUGGERS_AVAILABLE, ( WorkbenchStateContext.notEqualsTo('empty')))),
+    when: ( ContextKeyExpr.and(CONTEXT_DEBUGGERS_AVAILABLE, ( WorkbenchStateContext.notEqualsTo("empty")))),
     group: ViewContentGroups.Debug
 });
 viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
     content: ( localize(
-        7036,
+        7347,
         "To customize Run and Debug, [open a folder]({0}) and create a launch.json file.",
         (createCommandUri(OpenFolderAction.ID).toString())
     )),
-    when: ( ContextKeyExpr.and(CONTEXT_DEBUGGERS_AVAILABLE, ( WorkbenchStateContext.isEqualTo('empty')))),
+    when: ( ContextKeyExpr.and(CONTEXT_DEBUGGERS_AVAILABLE, ( WorkbenchStateContext.isEqualTo("empty")))),
     group: ViewContentGroups.Debug
 });
 viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
     content: ( localize(
-        7037,
+        7348,
         "All debug extensions are disabled. Enable a debug extension or install a new one from the Marketplace."
     )),
     when: ( CONTEXT_DEBUG_EXTENSION_AVAILABLE.toNegated()),

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

@@ -7,7 +7,7 @@ let Breakpoints = class Breakpoints {
     constructor(breakpointContribution, contextKeyService) {
         this.breakpointContribution = breakpointContribution;
         this.contextKeyService = contextKeyService;
-        this.breakpointsWhen = typeof breakpointContribution.when === 'string' ? ContextKeyExpr.deserialize(breakpointContribution.when) : undefined;
+        this.breakpointsWhen = typeof breakpointContribution.when === "string" ? ContextKeyExpr.deserialize(breakpointContribution.when) : undefined;
     }
     get language() {
         return this.breakpointContribution.language;
@@ -16,8 +16,6 @@ let Breakpoints = class Breakpoints {
         return !this.breakpointsWhen || this.contextKeyService.contextMatchesRules(this.breakpointsWhen);
     }
 };
-Breakpoints = ( __decorate([
-    ( __param(1, IContextKeyService))
-], Breakpoints));
+Breakpoints = ( __decorate([( __param(1, IContextKeyService))], Breakpoints));
 
 export { Breakpoints };

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

@@ -8,7 +8,9 @@ import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/pl
 import { Expression } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/debug/common/debugModel';
 
 let DebugWatchAccessibilityAnnouncer = class DebugWatchAccessibilityAnnouncer extends Disposable {
-    static { this.ID = 'workbench.contrib.debugWatchAccessibilityAnnouncer'; }
+    static {
+        this.ID = "workbench.contrib.debugWatchAccessibilityAnnouncer";
+    }
     constructor(_debugService, _logService, _accessibilityService, _configurationService) {
         super();
         this._debugService = _debugService;
@@ -18,32 +20,26 @@ let DebugWatchAccessibilityAnnouncer = class DebugWatchAccessibilityAnnouncer ex
         this._listener = this._register(( new MutableDisposable()));
         this._setListener();
         this._register(_configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration('accessibility.debugWatchVariableAnnouncements')) {
+            if (e.affectsConfiguration("accessibility.debugWatchVariableAnnouncements")) {
                 this._setListener();
             }
         }));
     }
     _setListener() {
-        const value = this._configurationService.getValue('accessibility.debugWatchVariableAnnouncements');
+        const value = this._configurationService.getValue("accessibility.debugWatchVariableAnnouncements");
         if (value && !this._listener.value) {
-            this._listener.value = this._debugService.getModel().onDidChangeWatchExpressionValue((e) => {
+            this._listener.value = this._debugService.getModel().onDidChangeWatchExpressionValue(e => {
                 if (!e || e.value === Expression.DEFAULT_VALUE) {
                     return;
                 }
                 this._accessibilityService.alert(`${e.name} = ${e.value}`);
                 this._logService.trace(`debugAccessibilityAnnouncerValueChanged ${e.name} ${e.value}`);
             });
-        }
-        else {
+        } else {
             this._listener.clear();
         }
     }
 };
-DebugWatchAccessibilityAnnouncer = ( __decorate([
-    ( __param(0, IDebugService)),
-    ( __param(1, ILogService)),
-    ( __param(2, IAccessibilityService)),
-    ( __param(3, IConfigurationService))
-], DebugWatchAccessibilityAnnouncer));
+DebugWatchAccessibilityAnnouncer = ( __decorate([( __param(0, IDebugService)), ( __param(1, ILogService)), ( __param(2, IAccessibilityService)), ( __param(3, IConfigurationService))], DebugWatchAccessibilityAnnouncer));
 
 export { DebugWatchAccessibilityAnnouncer };

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

@@ -18,15 +18,25 @@ import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/l
 
 var DebugContentProvider_1;
 let DebugContentProvider = class DebugContentProvider extends Disposable {
-    static { DebugContentProvider_1 = this; }
-    constructor(textModelResolverService, debugService, modelService, languageService, editorWorkerService) {
+    static {
+        DebugContentProvider_1 = this;
+    }
+    constructor(
+        textModelResolverService,
+        debugService,
+        modelService,
+        languageService,
+        editorWorkerService
+    ) {
         super();
         this.debugService = debugService;
         this.modelService = modelService;
         this.languageService = languageService;
         this.editorWorkerService = editorWorkerService;
         this.pendingUpdates = ( new Map());
-        this._store.add(textModelResolverService.registerTextModelContentProvider(DEBUG_SCHEME, this));
+        this._store.add(
+            textModelResolverService.registerTextModelContentProvider(DEBUG_SCHEME, this)
+        );
         DebugContentProvider_1.INSTANCE = this;
     }
     dispose() {
@@ -53,14 +63,12 @@ let DebugContentProvider = class DebugContentProvider extends Disposable {
             session = this.debugService.getViewModel().focusedSession;
         }
         if (!session) {
-            return Promise.reject(( new ErrorNoTelemetry(( localize(7104, "Unable to resolve the resource without a debug session")))));
+            return Promise.reject(( new ErrorNoTelemetry(( localize(7415, "Unable to resolve the resource without a debug session")))));
         }
-        const createErrModel = (errMsg) => {
+        const createErrModel = errMsg => {
             this.debugService.sourceIsNotAvailable(resource);
             const languageSelection = this.languageService.createById(PLAINTEXT_LANGUAGE_ID);
-            const message = errMsg
-                ? ( localize(7105, "Could not load source '{0}': {1}.", resource.path, errMsg))
-                : ( localize(7106, "Could not load source '{0}'.", resource.path));
+            const message = errMsg ? ( localize(7416, "Could not load source '{0}': {1}.", resource.path, errMsg)) : ( localize(7417, "Could not load source '{0}'.", resource.path));
             return this.modelService.createModel(message, languageSelection, resource);
         };
         return session.loadSource(resource).then(response => {
@@ -71,30 +79,26 @@ let DebugContentProvider = class DebugContentProvider extends Disposable {
                     cancellationSource?.cancel();
                     const myToken = ( new CancellationTokenSource());
                     this.pendingUpdates.set(model.id, myToken);
-                    return this.editorWorkerService.computeMoreMinimalEdits(model.uri, [{ text: newContent, range: model.getFullModelRange() }]).then(edits => {
+                    return this.editorWorkerService.computeMoreMinimalEdits(model.uri, [{
+                        text: newContent,
+                        range: model.getFullModelRange()
+                    }]).then(edits => {
                         this.pendingUpdates.delete(model.id);
                         if (!myToken.token.isCancellationRequested && edits && edits.length > 0) {
                             model.applyEdits(( edits.map(edit => EditOperation.replace(Range.lift(edit.range), edit.text))));
                         }
                         return model;
                     });
-                }
-                else {
+                } else {
                     const mime = response.body.mimeType || getMimeTypes(resource)[0];
                     const languageSelection = this.languageService.createByMimeType(mime);
                     return this.modelService.createModel(response.body.content, languageSelection, resource);
                 }
             }
             return createErrModel();
-        }, (err) => createErrModel(err.message));
+        }, err => createErrModel(err.message));
     }
 };
-DebugContentProvider = DebugContentProvider_1 = ( __decorate([
-    ( __param(0, ITextModelService)),
-    ( __param(1, IDebugService)),
-    ( __param(2, IModelService)),
-    ( __param(3, ILanguageService)),
-    ( __param(4, IEditorWorkerService))
-], DebugContentProvider));
+DebugContentProvider = DebugContentProvider_1 = ( __decorate([( __param(0, ITextModelService)), ( __param(1, IDebugService)), ( __param(2, IModelService)), ( __param(3, ILanguageService)), ( __param(4, IEditorWorkerService))], DebugContentProvider));
 
 export { DebugContentProvider };

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

@@ -11,15 +11,15 @@ let DebugLifecycle = class DebugLifecycle {
         this.debugService = debugService;
         this.configurationService = configurationService;
         this.dialogService = dialogService;
-        this.disposable = lifecycleService.onBeforeShutdown(async (e) => e.veto(this.shouldVetoShutdown(e.reason), 'veto.debug'));
+        this.disposable = lifecycleService.onBeforeShutdown(async e => e.veto(this.shouldVetoShutdown(e.reason), "veto.debug"));
     }
     shouldVetoShutdown(_reason) {
         const rootSessions = this.debugService.getModel().getSessions().filter(s => s.parentSession === undefined);
         if (rootSessions.length === 0) {
             return false;
         }
-        const shouldConfirmOnExit = this.configurationService.getValue('debug').confirmOnExit;
-        if (shouldConfirmOnExit === 'never') {
+        const shouldConfirmOnExit = this.configurationService.getValue("debug").confirmOnExit;
+        if (shouldConfirmOnExit === "never") {
             return false;
         }
         return this.showWindowCloseConfirmation(rootSessions.length);
@@ -31,29 +31,23 @@ let DebugLifecycle = class DebugLifecycle {
         let message;
         if (numSessions === 1) {
             message = ( localize(
-                7107,
+                7418,
                 "There is an active debug session, are you sure you want to stop it?"
             ));
-        }
-        else {
+        } else {
             message = ( localize(
-                7108,
+                7419,
                 "There are active debug sessions, are you sure you want to stop them?"
             ));
         }
         const res = await this.dialogService.confirm({
             message,
-            type: 'warning',
-            primaryButton: ( localize(7109, "&&Stop Debugging"))
+            type: "warning",
+            primaryButton: ( localize(7420, "&&Stop Debugging"))
         });
         return !res.confirmed;
     }
 };
-DebugLifecycle = ( __decorate([
-    ( __param(0, ILifecycleService)),
-    ( __param(1, IDebugService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IDialogService))
-], DebugLifecycle));
+DebugLifecycle = ( __decorate([( __param(0, ILifecycleService)), ( __param(1, IDebugService)), ( __param(2, IConfigurationService)), ( __param(3, IDialogService))], DebugLifecycle));
 
 export { DebugLifecycle };