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

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

@@ -23,15 +23,15 @@ import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/obse
 import { ObservablePromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/promise';
 
 var PickerMode;
-(function (PickerMode) {
+(function(PickerMode) {
     PickerMode["Main"] = "main";
     PickerMode["Expression"] = "expression";
 })(PickerMode || (PickerMode = {}));
 let DebugSessionContextPick = class DebugSessionContextPick {
     constructor(debugService) {
         this.debugService = debugService;
-        this.type = 'pickerPick';
-        this.label = ( localize(6714, 'Debug Session...'));
+        this.type = "pickerPick";
+        this.label = ( localize(7024, "Debug Session..."));
         this.icon = Codicon.debug;
         this.ordinal = -200;
     }
@@ -42,11 +42,11 @@ let DebugSessionContextPick = class DebugSessionContextPick {
     }
     asPicker(_widget) {
         const store = ( new DisposableStore());
-        const mode = observableValue('debugPicker.mode', PickerMode.Main);
-        const query = observableValue('debugPicker.query', '');
+        const mode = observableValue("debugPicker.mode", PickerMode.Main);
+        const query = observableValue("debugPicker.query", "");
         const picksObservable = this.createPicksObservable(mode, query, store);
         return {
-            placeholder: ( localize(6715, 'Select debug data to attach')),
+            placeholder: ( localize(7025, "Select debug data to attach")),
             picks: (_queryObs, token) => {
                 store.add(autorun(reader => {
                     query.set(_queryObs.read(reader), undefined);
@@ -62,7 +62,7 @@ let DebugSessionContextPick = class DebugSessionContextPick {
                 }
                 return false;
             },
-            dispose: () => store.dispose(),
+            dispose: () => store.dispose()
         };
     }
     createPicksObservable(mode, query, store) {
@@ -71,8 +71,7 @@ let DebugSessionContextPick = class DebugSessionContextPick {
             const currentMode = mode.read(reader);
             if (currentMode === PickerMode.Expression) {
                 return this.getExpressionPicks(debouncedQuery, store);
-            }
-            else {
+            } else {
                 return this.getMainPicks(mode);
             }
         }).flatten();
@@ -83,7 +82,10 @@ let DebugSessionContextPick = class DebugSessionContextPick {
         });
         return ( promise.map((value, reader) => {
             const result = value.promiseResult.read(reader);
-            return { picks: result?.data || [], busy: result === undefined };
+            return {
+                picks: result?.data || [],
+                busy: result === undefined
+            };
         }));
     }
     async buildMainPicks(mode) {
@@ -95,43 +97,47 @@ let DebugSessionContextPick = class DebugSessionContextPick {
             return picks;
         }
         picks.push({
-            label: ( localize(6716, 'Expression Value...')),
+            label: ( localize(7026, "Expression Value...")),
             iconClass: ThemeIcon.asClassName(Codicon.symbolVariable),
             asAttachment: () => {
                 mode.set(PickerMode.Expression, undefined);
-                return 'noop';
-            },
+                return "noop";
+            }
         });
         const watches = this.debugService.getModel().getWatchExpressions();
         if (watches.length > 0) {
-            picks.push({ type: 'separator', label: ( localize(6717, 'Watch Expressions')) });
+            picks.push({
+                type: "separator",
+                label: ( localize(7027, "Watch Expressions"))
+            });
             for (const watch of watches) {
                 picks.push({
                     label: watch.name,
                     description: watch.value,
                     iconClass: ThemeIcon.asClassName(Codicon.eye),
-                    asAttachment: () => createDebugAttachments(stackFrame, createDebugVariableEntry(watch)),
+                    asAttachment: () => createDebugAttachments(stackFrame, createDebugVariableEntry(watch))
                 });
             }
         }
         let scopes = [];
         try {
             scopes = await stackFrame.getScopes();
-        }
-        catch {
-        }
+        } catch {}
         for (const scope of scopes) {
             if (scope.expensive && !scope.childrenHaveBeenLoaded) {
                 continue;
             }
-            picks.push({ type: 'separator', label: scope.name });
+            picks.push({
+                type: "separator",
+                label: scope.name
+            });
             try {
                 const variables = await scope.getChildren();
                 if (variables.length > 1) {
                     picks.push({
-                        label: ( localize(6718, 'All variables in {0}', scope.name)),
+                        label: ( localize(7028, "All variables in {0}", scope.name)),
                         iconClass: ThemeIcon.asClassName(Codicon.symbolNamespace),
-                        asAttachment: () => createDebugAttachments(stackFrame, createScopeEntry(scope, variables)),
+                        asAttachment: () => createDebugAttachments(stackFrame, createScopeEntry(scope, variables))
                     });
                 }
                 for (const variable of variables) {
@@ -139,17 +145,15 @@ let DebugSessionContextPick = class DebugSessionContextPick {
                         label: variable.name,
                         description: formatVariableDescription(variable),
                         iconClass: ThemeIcon.asClassName(Codicon.symbolVariable),
-                        asAttachment: () => createDebugAttachments(stackFrame, createDebugVariableEntry(variable)),
+                        asAttachment: () => createDebugAttachments(stackFrame, createDebugVariableEntry(variable))
                     });
                 }
-            }
-            catch {
-            }
+            } catch {}
         }
         return picks;
     }
     getExpressionPicks(query, _store) {
-        const promise = derived((reader) => {
+        const promise = derived(reader => {
             const queryValue = query.read(reader);
             const cts = ( new CancellationTokenSource());
             reader.store.add(toDisposable(() => cts.dispose(true)));
@@ -157,29 +161,32 @@ let DebugSessionContextPick = class DebugSessionContextPick {
         });
         return ( promise.map((value, r) => {
             const result = value.promiseResult.read(r);
-            return { picks: result?.data || [], busy: result === undefined };
+            return {
+                picks: result?.data || [],
+                busy: result === undefined
+            };
         }));
     }
     async evaluateExpression(expression, token) {
         if (!expression.trim()) {
             return [{
-                    label: ( localize(6719, 'Type an expression to evaluate...')),
-                    disabled: true,
-                    asAttachment: () => 'noop',
-                }];
+                label: ( localize(7029, "Type an expression to evaluate...")),
+                disabled: true,
+                asAttachment: () => "noop"
+            }];
         }
         const viewModel = this.debugService.getViewModel();
         const session = viewModel.focusedSession;
         const stackFrame = viewModel.focusedStackFrame;
         if (!session || !stackFrame) {
             return [{
-                    label: ( localize(6720, 'No active debug session')),
-                    disabled: true,
-                    asAttachment: () => 'noop',
-                }];
+                label: ( localize(7030, "No active debug session")),
+                disabled: true,
+                asAttachment: () => "noop"
+            }];
         }
         try {
-            const response = await session.evaluate(expression, stackFrame.frameId, 'watch');
+            const response = await session.evaluate(expression, stackFrame.frameId, "watch");
             if (token.isCancellationRequested) {
                 return [];
             }
@@ -187,47 +194,43 @@ let DebugSessionContextPick = class DebugSessionContextPick {
                 const resultValue = response.body.result;
                 const resultType = response.body.type;
                 return [{
-                        label: expression,
-                        description: formatExpressionResult(resultValue, resultType),
-                        iconClass: ThemeIcon.asClassName(Codicon.symbolVariable),
-                        asAttachment: () => createDebugAttachments(stackFrame, {
-                            kind: 'debugVariable',
-                            id: `debug-expression:${expression}`,
-                            name: expression,
-                            fullName: expression,
-                            icon: Codicon.debug,
-                            value: resultValue,
-                            expression: expression,
-                            type: resultType,
-                            modelDescription: formatModelDescription(expression, resultValue, resultType),
-                        }),
-                    }];
-            }
-            else {
+                    label: expression,
+                    description: formatExpressionResult(resultValue, resultType),
+                    iconClass: ThemeIcon.asClassName(Codicon.symbolVariable),
+                    asAttachment: () => createDebugAttachments(stackFrame, {
+                        kind: "debugVariable",
+                        id: `debug-expression:${expression}`,
+                        name: expression,
+                        fullName: expression,
+                        icon: Codicon.debug,
+                        value: resultValue,
+                        expression: expression,
+                        type: resultType,
+                        modelDescription: formatModelDescription(expression, resultValue, resultType)
+                    })
+                }];
+            } else {
                 return [{
-                        label: expression,
-                        description: ( localize(6721, 'No result')),
-                        disabled: true,
-                        asAttachment: () => 'noop',
-                    }];
-            }
-        }
-        catch (err) {
-            return [{
                     label: expression,
-                    description: err instanceof Error ? err.message : ( localize(6722, 'Evaluation error')),
+                    description: ( localize(7031, "No result")),
                     disabled: true,
-                    asAttachment: () => 'noop',
+                    asAttachment: () => "noop"
                 }];
+            }
+        } catch (err) {
+            return [{
+                label: expression,
+                description: err instanceof Error ? err.message : ( localize(7032, "Evaluation error")),
+                disabled: true,
+                asAttachment: () => "noop"
+            }];
         }
     }
 };
-DebugSessionContextPick = ( __decorate([
-    ( __param(0, IDebugService))
-], DebugSessionContextPick));
+DebugSessionContextPick = ( __decorate([( __param(0, IDebugService))], DebugSessionContextPick));
 function createDebugVariableEntry(expression) {
     return {
-        kind: 'debugVariable',
+        kind: "debugVariable",
         id: `debug-variable:${expression.getId()}`,
         name: expression.name,
         fullName: expression.name,
@@ -235,7 +238,7 @@ function createDebugVariableEntry(expression) {
         value: expression.value,
         expression: expression.name,
         type: expression.type,
-        modelDescription: formatModelDescription(expression.name, expression.value, expression.type),
+        modelDescription: formatModelDescription(expression.name, expression.value, expression.type)
     };
 }
 function createPausedLocationEntry(stackFrame) {
@@ -245,31 +248,31 @@ function createPausedLocationEntry(stackFrame) {
         range = range.setEndPosition(range.startLineNumber + 1, 1);
     }
     return {
-        kind: 'file',
-        value: { uri, range },
+        kind: "file",
+        value: {
+            uri,
+            range
+        },
         id: `debug-paused-location:${( uri.toString())}:${range.startLineNumber}`,
         name: basename(uri),
-        modelDescription: 'The debugger is currently paused at this location',
+        modelDescription: "The debugger is currently paused at this location"
     };
 }
 function createDebugAttachments(stackFrame, variableEntry) {
-    return [
-        createPausedLocationEntry(stackFrame),
-        variableEntry,
-    ];
+    return [createPausedLocationEntry(stackFrame), variableEntry];
 }
 function createScopeEntry(scope, variables) {
-    const variablesSummary = ( variables.map(v => `${v.name}: ${v.value}`)).join('\n');
+    const variablesSummary = ( variables.map(v => `${v.name}: ${v.value}`)).join("\n");
     return {
-        kind: 'debugVariable',
+        kind: "debugVariable",
         id: `debug-scope:${scope.name}`,
         name: `Scope: ${scope.name}`,
         fullName: `Scope: ${scope.name}`,
         icon: Codicon.debug,
         value: variablesSummary,
         expression: scope.name,
-        type: 'scope',
-        modelDescription: `Debug scope "${scope.name}" with ${variables.length} variables:\n${variablesSummary}`,
+        type: "scope",
+        modelDescription: `Debug scope "${scope.name}" with ${variables.length} variables:\n${variablesSummary}`
     };
 }
 function formatVariableDescription(expression) {
@@ -278,13 +281,13 @@ function formatVariableDescription(expression) {
     if (type && value) {
         return `${type}: ${value}`;
     }
-    return value || type || '';
+    return value || type || "";
 }
 function formatExpressionResult(value, type) {
     if (type && value) {
         return `${type}: ${value}`;
     }
-    return value || type || '';
+    return value || type || "";
 }
 function formatModelDescription(name, value, type) {
     let description = `Debug variable "${name}"`;
@@ -295,25 +298,26 @@ function formatModelDescription(name, value, type) {
     return description;
 }
 let DebugChatContextContribution = class DebugChatContextContribution extends Disposable {
-    static { this.ID = 'workbench.contrib.chat.debugChatContextContribution'; }
+    static {
+        this.ID = "workbench.contrib.chat.debugChatContextContribution";
+    }
     constructor(contextPickService, instantiationService) {
         super();
-        this._register(contextPickService.registerChatContextItem(instantiationService.createInstance(DebugSessionContextPick)));
+        this._register(
+            contextPickService.registerChatContextItem(instantiationService.createInstance(DebugSessionContextPick))
+        );
     }
 };
-DebugChatContextContribution = ( __decorate([
-    ( __param(0, IChatContextPickService)),
-    ( __param(1, IInstantiationService))
-], DebugChatContextContribution));
+DebugChatContextContribution = ( __decorate([( __param(0, IChatContextPickService)), ( __param(1, IInstantiationService))], DebugChatContextContribution));
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: 'workbench.debug.action.addVariableToChat',
-            title: ( localize(6723, 'Add to Chat')),
+            id: "workbench.debug.action.addVariableToChat",
+            title: ( localize(7033, "Add to Chat")),
             f1: false,
             menu: {
                 id: MenuId.DebugVariablesContext,
-                group: 'z_commands',
+                group: "z_commands",
                 order: 110,
                 when: ChatContextKeys.enabled
             }
@@ -339,12 +343,12 @@ registerAction2(class extends Action2 {
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: 'workbench.debug.action.addWatchExpressionToChat',
-            title: ( localize(6723, 'Add to Chat')),
+            id: "workbench.debug.action.addWatchExpressionToChat",
+            title: ( localize(7033, "Add to Chat")),
             f1: false,
             menu: {
                 id: MenuId.DebugWatchContext,
-                group: 'z_commands',
+                group: "z_commands",
                 order: 110,
                 when: ChatContextKeys.enabled
             }
@@ -367,12 +371,12 @@ registerAction2(class extends Action2 {
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: 'workbench.debug.action.addScopeToChat',
-            title: ( localize(6723, 'Add to Chat')),
+            id: "workbench.debug.action.addScopeToChat",
+            title: ( localize(7033, "Add to Chat")),
             f1: false,
             menu: {
                 id: MenuId.DebugScopesContext,
-                group: 'z_commands',
+                group: "z_commands",
                 order: 1,
                 when: ChatContextKeys.enabled
             }
@@ -398,13 +402,11 @@ registerAction2(class extends Action2 {
                 widget.attachmentModel.addContext(createPausedLocationEntry(stackFrame));
                 widget.attachmentModel.addContext(createScopeEntry(scope, variables));
             }
-        }
-        catch {
-        }
+        } catch {}
     }
 });
 function isVariablesContext(context) {
-    return typeof context === 'object' && context !== null && 'variable' in context && 'sessionId' in context;
+    return typeof context === "object" && context !== null && "variable" in context && "sessionId" in context;
 }
 function createDebugVariableEntryFromContext(context) {
     if (context instanceof Variable) {
@@ -413,7 +415,7 @@ function createDebugVariableEntryFromContext(context) {
     if (isVariablesContext(context)) {
         const variable = context.variable;
         return {
-            kind: 'debugVariable',
+            kind: "debugVariable",
             id: `debug-variable:${variable.name}`,
             name: variable.name,
             fullName: variable.evaluateName ?? variable.name,
@@ -421,7 +423,7 @@ function createDebugVariableEntryFromContext(context) {
             value: variable.value,
             expression: variable.evaluateName ?? variable.name,
             type: variable.type,
-            modelDescription: formatModelDescription(variable.evaluateName || variable.name, variable.value, variable.type),
+            modelDescription: formatModelDescription(variable.evaluateName || variable.name, variable.value, variable.type)
         };
     }
     return undefined;