@theia/debug 1.77.0-next.47 → 1.77.0-next.56

package/src/browser/console/debug-copy-value.spec.ts

@@ -0,0 +1,144 @@
+// *****************************************************************************
+// Copyright (C) 2026 Karthik Harikrishnan and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// http://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+const disableJSDOM = enableJSDOM();
+FrontendApplicationConfigProvider.set({});
+
+import { expect } from 'chai';
+import { DebugProtocol } from '@vscode/debugprotocol';
+import { DebugSession } from '../debug-session';
+import { DebugWatchExpression } from '../view/debug-watch-expression';
+import { DebugVariable, ExpressionContainer } from './debug-console-items';
+
+disableJSDOM();
+
+interface TestSession extends Pick<DebugSession, 'capabilities' | 'evaluate'> { }
+
+class TestDebugWatchExpression extends DebugWatchExpression {
+
+    setValue(value: string): void {
+        this._value = value;
+    }
+}
+
+function createVariable(session: TestSession, overrides: Partial<DebugProtocol.Variable> = { evaluateName: 'object.value' }): DebugVariable {
+    const sessionProvider = () => session as DebugSession;
+    const parent = new ExpressionContainer({ session: sessionProvider, id: 'parent' });
+    const variable: DebugProtocol.Variable = {
+        name: 'value',
+        value: 'truncated',
+        variablesReference: 0,
+        ...overrides
+    };
+    return new DebugVariable(sessionProvider, variable, parent);
+}
+
+function createWatchExpression(session: TestSession): TestDebugWatchExpression {
+    const watchExpression = new TestDebugWatchExpression({
+        id: 1,
+        expression: 'object.value',
+        session: () => session as DebugSession,
+        remove: () => undefined,
+        onDidChange: () => undefined
+    });
+    watchExpression.setValue('truncated');
+    return watchExpression;
+}
+
+describe('Debugger Copy Value', () => {
+
+    it('evaluates a variable using the clipboard context when supported', async () => {
+        const evaluations: Array<{ expression: string; context?: string }> = [];
+        const session: TestSession = {
+            capabilities: { supportsClipboardContext: true },
+            evaluate: async (expression, context) => {
+                evaluations.push({ expression, context });
+                return { result: 'full value', variablesReference: 0 };
+            }
+        };
+        const value = await createVariable(session).getValueToCopy();
+
+        expect(evaluations).to.deep.equal([{ expression: 'object.value', context: 'clipboard' }]);
+        expect(value).to.equal('full value');
+    });
+
+    it('uses the variables context when the clipboard context is unsupported', async () => {
+        const evaluations: Array<{ expression: string; context?: string }> = [];
+        const session: TestSession = {
+            capabilities: {},
+            evaluate: async (expression, context) => {
+                evaluations.push({ expression, context });
+                return { result: 'full value', variablesReference: 0 };
+            }
+        };
+        const value = await createVariable(session).getValueToCopy();
+
+        expect(evaluations).to.deep.equal([{ expression: 'object.value', context: 'variables' }]);
+        expect(value).to.equal('full value');
+    });
+
+    it('copies the rendered variable value when evaluateName is unavailable', async () => {
+        let evaluated = false;
+        const session: TestSession = {
+            capabilities: { supportsClipboardContext: true },
+            evaluate: async () => {
+                evaluated = true;
+                return { result: 'full value', variablesReference: 0 };
+            }
+        };
+        const value = await createVariable(session, { evaluateName: undefined }).getValueToCopy();
+
+        expect(evaluated).to.be.false;
+        expect(value).to.equal('truncated');
+    });
+
+    it('copies the rendered variable value when evaluation fails', async () => {
+        const session: TestSession = {
+            capabilities: { supportsClipboardContext: true },
+            evaluate: async () => { throw new Error('evaluation failed'); }
+        };
+        const value = await createVariable(session).getValueToCopy();
+
+        expect(value).to.equal('truncated');
+    });
+
+    it('evaluates a watch expression using the watch context', async () => {
+        const evaluations: Array<{ expression: string; context?: string }> = [];
+        const session: TestSession = {
+            capabilities: {},
+            evaluate: async (expression, context) => {
+                evaluations.push({ expression, context });
+                return { result: 'full value', variablesReference: 0 };
+            }
+        };
+        const value = await createWatchExpression(session).getValueToCopy();
+
+        expect(evaluations).to.deep.equal([{ expression: 'object.value', context: 'watch' }]);
+        expect(value).to.equal('full value');
+    });
+
+    it('copies the rendered watch value when evaluation fails', async () => {
+        const session: TestSession = {
+            capabilities: { supportsClipboardContext: true },
+            evaluate: async () => { throw new Error('evaluation failed'); }
+        };
+        const value = await createWatchExpression(session).getValueToCopy();
+
+        expect(value).to.equal('truncated');
+    });
+});

package/src/browser/debug-frontend-application-contribution.ts

@@ -69,6 +69,7 @@ import {
     DebugEditorContextCommands, DebugBreakpointWidgetCommands, nlsEnableBreakpoint, nlsDisableBreakpoint
 } from './debug-commands';
 import { ILogger } from '@theia/core';
+import { ClipboardService } from '@theia/core/lib/browser/clipboard-service';
 
 @injectable()
 export class DebugFrontendApplicationContribution extends AbstractViewContribution<DebugWidget>
@@ -119,6 +120,9 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
     @inject(ILogger) @named('debug:DebugFrontendApplicationContribution')
     protected readonly logger: ILogger;
 
+    @inject(ClipboardService)
+    protected readonly clipboardService: ClipboardService;
+
     constructor() {
         super({
             widgetId: DebugWidget.ID,
@@ -697,7 +701,7 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
             isVisible: () => !!this.selectedVariable && this.selectedVariable.supportSetVariable
         });
         registry.registerCommand(DebugCommands.COPY_VARIABLE_VALUE, {
-            execute: () => this.selectedVariable && this.selectedVariable.copyValue(),
+            execute: () => this.copyValue(this.selectedVariable),
             isEnabled: () => !!this.selectedVariable && this.selectedVariable.supportCopyValue,
             isVisible: () => !!this.selectedVariable && this.selectedVariable.supportCopyValue
         });
@@ -826,7 +830,7 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
             isVisible: () => !!this.watchExpression
         });
         registry.registerCommand(DebugCommands.COPY_WATCH_EXPRESSION_VALUE, {
-            execute: () => this.watchExpression && this.watchExpression.copyValue(),
+            execute: () => this.copyValue(this.watchExpression),
             isEnabled: () => !!this.watchExpression && this.watchExpression.supportCopyValue,
             isVisible: () => !!this.watchExpression && this.watchExpression.supportCopyValue
         });
@@ -865,6 +869,12 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
         });
     }
 
+    protected async copyValue(item: { getValueToCopy(): Promise<string> } | undefined): Promise<void> {
+        if (item) {
+            await this.clipboardService.writeText(await item.getValueToCopy());
+        }
+    }
+
     override registerKeybindings(keybindings: KeybindingRegistry): void {
         super.registerKeybindings(keybindings);
         keybindings.registerKeybinding({

package/src/browser/debug-session-options.ts

@@ -113,7 +113,7 @@ export namespace InternalDebugSessionOptions {
     }
 
     /** @deprecated Please use `JSON.parse` to restore previously serialized debug session options. */
-    // eslint-disable-next-line deprecation/deprecation
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
     export function parseValue(value: string): DebugSessionOptionsData {
         const split = value.split(SEPARATOR);
         if (split.length === 5) {

package/src/browser/view/debug-watch-expression.tsx

@@ -63,7 +63,7 @@ export class DebugWatchExpression extends ExpressionItem {
         return <div className='theia-debug-console-variable theia-debug-watch-expression'>
             <div className={TREE_NODE_SEGMENT_GROW_CLASS}>
                 <span title={this.type || this._expression} className='name'>{this._expression}:</span>
-                <span title={this._value} ref={this.setValueRef} className={valueClass}>{this._value}</span>
+                <span title={this._value} className={valueClass}>{this._value}</span>
             </div>
             <div className={codicon('close', true)} title={nls.localizeByDefault('Remove Expression')} onClick={this.options.remove} />
         </div>;
@@ -93,16 +93,10 @@ export class DebugWatchExpression extends ExpressionItem {
     }
 
     get supportCopyValue(): boolean {
-        return !!this.valueRef && document.queryCommandSupported('copy');
+        return this.available;
     }
-    copyValue(): void {
-        const selection = document.getSelection();
-        if (this.valueRef && selection) {
-            selection.selectAllChildren(this.valueRef);
-            document.execCommand('copy');
-        }
+    async getValueToCopy(): Promise<string> {
+        return this.evaluateForClipboard(this.expression, 'watch', this.value);
     }
-    protected valueRef: HTMLSpanElement | undefined;
-    protected setValueRef = (valueRef: HTMLSpanElement | null): void => { this.valueRef = valueRef || undefined; };
 
 }