@theia/monaco 1.77.0-next.49 → 1.77.0-next.57

package/src/browser/monaco-keybinding.spec.ts

@@ -0,0 +1,117 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource 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.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+let disableJSDOM = enableJSDOM();
+
+import { expect } from 'chai';
+import { Key, KeybindingRegistry, KeyCode } from '@theia/core/lib/browser';
+import * as os from '@theia/core/lib/common/os';
+import * as monaco from '@theia/monaco-editor-core';
+import * as MonacoPlatform from '@theia/monaco-editor-core/esm/vs/base/common/platform';
+import { KeyCode as MonacoKeyCode } from '@theia/monaco-editor-core/esm/vs/base/common/keyCodes';
+import { KeyCodeChord } from '@theia/monaco-editor-core/esm/vs/base/common/keybindings';
+import { USLayoutResolvedKeybinding } from '@theia/monaco-editor-core/esm/vs/platform/keybinding/common/usLayoutResolvedKeybinding';
+import * as sinon from 'sinon';
+import { MonacoKeybindingContribution } from './monaco-keybinding';
+import { MonacoResolvedKeybinding } from './monaco-resolved-keybinding';
+
+class TestMonacoKeybindingContribution extends MonacoKeybindingContribution {
+    encode(code: KeyCode): number {
+        return this.toSingleMonacoKeybindingNumber(code);
+    }
+
+    representable(codes: KeyCode[]): boolean {
+        return this.isMonacoRepresentable(codes);
+    }
+}
+
+disableJSDOM();
+
+describe('Monaco keybinding adapter', () => {
+    let contribution: TestMonacoKeybindingContribution;
+
+    before(() => disableJSDOM = enableJSDOM());
+    after(() => disableJSDOM());
+
+    beforeEach(() => contribution = new TestMonacoKeybindingContribution());
+
+    afterEach(() => sinon.restore());
+
+    it('encodes non-macOS Ctrl as Monaco CtrlCmd', () => {
+        sinon.stub(os, 'isOSX').value(false);
+
+        const encoded = contribution.encode(new KeyCode({ key: Key.KEY_A, ctrl: true }));
+
+        expect(encoded & monaco.KeyMod.CtrlCmd).to.equal(monaco.KeyMod.CtrlCmd);
+        expect(encoded & monaco.KeyMod.WinCtrl).to.equal(0);
+    });
+
+    it('preserves macOS Ctrl and Command encoding', () => {
+        sinon.stub(os, 'isOSX').value(true);
+
+        const encoded = contribution.encode(new KeyCode({ key: Key.KEY_A, ctrl: true, meta: true }));
+
+        expect(encoded & monaco.KeyMod.WinCtrl).to.equal(monaco.KeyMod.WinCtrl);
+        expect(encoded & monaco.KeyMod.CtrlCmd).to.equal(monaco.KeyMod.CtrlCmd);
+    });
+
+    it('accepts layout Shift but rejects layout AltGraph and unmapped keys', () => {
+        expect(contribution.representable([
+            new KeyCode({ key: Key.DIGIT7, layoutModifiers: 'shift' })
+        ])).to.be.true;
+        expect(contribution.representable([
+            new KeyCode({ key: Key.DIGIT8, layoutModifiers: 'altGraph' })
+        ])).to.be.false;
+        expect(contribution.representable([new KeyCode({ key: Key.F20 })])).to.be.false;
+    });
+
+    it('uses formatted logical characters in resolved labels', () => {
+        const registry = Object.create(KeybindingRegistry.prototype) as KeybindingRegistry;
+        const bracket = new MonacoResolvedKeybinding([
+            new KeyCode({ key: Key.DIGIT8, ctrl: true, character: '[', layoutModifiers: 'altGraph' })
+        ], registry);
+        const letter = new MonacoResolvedKeybinding([
+            new KeyCode({ key: Key.KEY_P, ctrl: true, character: 'p' })
+        ], registry);
+
+        const controlLabel = MonacoPlatform.OS === MonacoPlatform.OperatingSystem.Macintosh ? '⌃' : 'Ctrl+';
+        expect(bracket.getLabel()).to.equal(`${controlLabel}[`);
+        expect(letter.getLabel()).to.equal(`${controlLabel}P`);
+    });
+
+    it('includes layout Shift in dispatch chords but not in labels', () => {
+        const registry = Object.create(KeybindingRegistry.prototype) as KeybindingRegistry;
+        const resolved = new MonacoResolvedKeybinding([
+            new KeyCode({ key: Key.DIGIT7, ctrl: true, character: '/', layoutModifiers: 'shift' })
+        ], registry);
+        const expectedDispatch = USLayoutResolvedKeybinding.getDispatchStr(
+            new KeyCodeChord(true, true, false, false, MonacoKeyCode.Digit7)
+        );
+        const controlLabel = MonacoPlatform.OS === MonacoPlatform.OperatingSystem.Macintosh ? '⌃' : 'Ctrl+';
+
+        expect(resolved.getDispatchChords()).to.deep.equal([expectedDispatch]);
+        expect(resolved.getLabel()).to.equal(`${controlLabel}/`);
+    });
+
+    it('shows layout Shift in labels when it produces an uppercase letter', () => {
+        const registry = Object.create(KeybindingRegistry.prototype) as KeybindingRegistry;
+        const resolved = new MonacoResolvedKeybinding([
+            new KeyCode({ key: Key.KEY_P, ctrl: true, character: 'P', layoutModifiers: 'shift' })
+        ], registry);
+        const expectedDispatch = USLayoutResolvedKeybinding.getDispatchStr(
+            new KeyCodeChord(true, true, false, false, MonacoKeyCode.KeyP)
+        );
+        const isMac = MonacoPlatform.OS === MonacoPlatform.OperatingSystem.Macintosh;
+
+        expect(resolved.getDispatchChords()).to.deep.equal([expectedDispatch]);
+        expect(resolved.getLabel()).to.equal(isMac ? '⌃⇧P' : 'Ctrl+Shift+P');
+    });
+});

package/src/browser/monaco-keybinding.ts

@@ -15,7 +15,9 @@
 // *****************************************************************************
 
 import { injectable, inject, postConstruct, named } from '@theia/core/shared/inversify';
-import { KeybindingContribution, KeybindingRegistry, KeybindingScope, KeyCode } from '@theia/core/lib/browser';
+import {
+    KeybindingContribution, KeybindingRegistry, KeybindingScope, KeyCode, layoutModifiersIncludeAltGraph, layoutModifiersIncludeShift
+} from '@theia/core/lib/browser';
 import { MonacoCommands } from './monaco-command';
 import { MonacoCommandRegistry } from './monaco-command-registry';
 import { CommandRegistry, DisposableCollection, environment, isOSX, ILogger } from '@theia/core';
@@ -68,6 +70,9 @@ export class MonacoKeybindingContribution implements KeybindingContribution {
             this.toDisposeOnKeybindingChange.dispose();
             for (const binding of this.keybindings.getKeybindingsByScope(KeybindingScope.USER).concat(this.keybindings.getKeybindingsByScope(KeybindingScope.WORKSPACE))) {
                 const resolved = this.keybindings.resolveKeybinding(binding);
+                if (this.keybindings.isKeybindingInactive(binding) || !this.isMonacoRepresentable(resolved)) {
+                    continue;
+                }
                 const command = binding.command;
                 const when = binding.when
                     ? this.contextKeyService.parse(binding.when)
@@ -84,6 +89,11 @@ export class MonacoKeybindingContribution implements KeybindingContribution {
         }
     }
 
+    protected isMonacoRepresentable(codes: KeyCode[]): boolean {
+        return codes.length <= 2 && codes.every(code => code.key && KEY_CODE_MAP[code.key.keyCode] !== undefined
+            && !layoutModifiersIncludeAltGraph(code.layoutModifiers));
+    }
+
     protected toMonacoKeybindingNumber(codes: KeyCode[]): number {
         const [firstPart, secondPart] = codes;
         if (codes.length > 2) {
@@ -100,11 +110,11 @@ export class MonacoKeybindingContribution implements KeybindingContribution {
         if (code.alt) {
             encoded |= monaco.KeyMod.Alt;
         }
-        if (code.shift) {
+        if (code.shift || layoutModifiersIncludeShift(code.layoutModifiers)) {
             encoded |= monaco.KeyMod.Shift;
         }
         if (code.ctrl) {
-            encoded |= monaco.KeyMod.WinCtrl;
+            encoded |= isOSX ? monaco.KeyMod.WinCtrl : monaco.KeyMod.CtrlCmd;
         }
         if (code.meta && isOSX) {
             encoded |= monaco.KeyMod.CtrlCmd;

package/src/browser/monaco-outline-contribution.ts

@@ -301,6 +301,7 @@ export class MonacoOutlineContribution implements FrontendApplicationContributio
             iconClass: monaco.languages.SymbolKind[symbol.kind].toString().toLowerCase(),
             name: this.getName(symbol),
             detail: this.getDetail(symbol),
+            deprecated: this.isDeprecated(symbol),
             parent,
             uri,
             range: this.getNameRange(symbol),
@@ -324,6 +325,10 @@ export class MonacoOutlineContribution implements FrontendApplicationContributio
         return symbol.detail;
     }
 
+    protected isDeprecated(symbol: monaco.languages.DocumentSymbol): boolean {
+        return !!symbol.tags?.includes(monaco.languages.SymbolTag.Deprecated);
+    }
+
     protected createId(name: string, ids: Map<string, number>): string {
         const counter = ids.get(name);
         const index = typeof counter === 'number' ? counter + 1 : 0;
@@ -370,6 +375,8 @@ export interface MonacoOutlineSymbolInformationNode extends OutlineSymbolInforma
     range: Range;
     fullRange: Range;
     detail?: string;
+    /** Whether the symbol is tagged as deprecated. */
+    deprecated?: boolean;
     parent: MonacoOutlineSymbolInformationNode | undefined;
     children: MonacoOutlineSymbolInformationNode[];
 }

package/src/browser/monaco-outline-decorator.spec.ts

@@ -0,0 +1,96 @@
+// *****************************************************************************
+// Copyright (C) 2026 Vinay Kaushal 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
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+import { expect } from 'chai';
+import URI from '@theia/core/lib/common/uri';
+import type { CompositeTreeNode, Tree } from '@theia/core/lib/browser/tree';
+import type { TreeDecoration } from '@theia/core/lib/browser/tree/tree-decorator';
+import type * as monaco from '@theia/monaco-editor-core';
+import type { MonacoOutlineSymbolInformationNode } from './monaco-outline-contribution';
+
+describe('MonacoOutlineDecorator', () => {
+
+    // The outline code uses the full monaco API at runtime. Load it only once this suite runs: loading it while
+    // the spec files are collected registers monaco's editor contributions before monaco-init.spec initializes
+    // the standalone services, which then need browser APIs that JSDOM does not provide.
+    let monacoApi: typeof monaco;
+    let outline: typeof import('./monaco-outline-contribution');
+    let decorator: typeof import('./monaco-outline-decorator');
+    let disableJSDOM: () => void;
+
+    before(async () => {
+        disableJSDOM = enableJSDOM();
+        // @lumino/dragdrop (pulled in transitively) extends the DragEvent DOM global at
+        // module load, which JSDOM does not provide; stub it so the import succeeds.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (!(global as any).DragEvent) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (global as any).DragEvent = class DragEvent extends (global as any).Event { };
+        }
+        monacoApi = await import('@theia/monaco-editor-core');
+        outline = await import('./monaco-outline-contribution');
+        decorator = await import('./monaco-outline-decorator');
+    });
+    after(() => disableJSDOM());
+
+    const range: monaco.IRange = { startLineNumber: 1, startColumn: 1, endLineNumber: 1, endColumn: 10 };
+
+    function symbol(name: string, detail: string, deprecated = false): monaco.languages.DocumentSymbol {
+        const tags = deprecated ? [monacoApi.languages.SymbolTag.Deprecated] : [];
+        return { name, detail, kind: monacoApi.languages.SymbolKind.Method, tags, range, selectionRange: range };
+    }
+
+    function createNode(documentSymbol: monaco.languages.DocumentSymbol): MonacoOutlineSymbolInformationNode {
+        return new outline.MonacoOutlineContribution()['createNode'](new URI('file:///test.ts'), documentSymbol, new Map());
+    }
+
+    function decorate(...nodes: MonacoOutlineSymbolInformationNode[]): Promise<Map<string, TreeDecoration.Data>> {
+        const root: CompositeTreeNode = { id: 'root', name: 'root', parent: undefined, children: nodes };
+        return new decorator.MonacoOutlineDecorator().decorations({ root } as unknown as Tree);
+    }
+
+    it('marks a symbol tagged as deprecated', () => {
+        expect(createNode(symbol('old', '', true)).deprecated).to.equal(true);
+        expect(createNode(symbol('current', '')).deprecated).to.equal(false);
+    });
+
+    it('strikes through a deprecated symbol', async () => {
+        const node = createNode(symbol('old', '', true));
+
+        const decorations = await decorate(node);
+
+        expect(decorations.get(node.id)?.fontData).to.deep.equal({ style: 'line-through' });
+        expect(decorations.get(node.id)?.captionSuffixes).to.equal(undefined);
+    });
+
+    it('keeps the detail suffix of a deprecated symbol', async () => {
+        const node = createNode(symbol('old', '(): void', true));
+
+        const decorations = await decorate(node);
+
+        expect(decorations.get(node.id)?.fontData).to.deep.equal({ style: 'line-through' });
+        expect(decorations.get(node.id)?.captionSuffixes?.map(suffix => suffix.data)).to.deep.equal(['(): void']);
+    });
+
+    it('does not decorate a symbol that is neither deprecated nor has a detail', async () => {
+        const node = createNode(symbol('current', ''));
+
+        const decorations = await decorate(node);
+
+        expect(decorations.has(node.id)).to.equal(false);
+    });
+});

package/src/browser/monaco-outline-decorator.ts

@@ -43,7 +43,7 @@ export class MonacoOutlineDecorator implements TreeDecorator {
         }
 
         for (const treeNode of new DepthFirstTreeIterator(tree.root)) {
-            if (MonacoOutlineSymbolInformationNode.is(treeNode) && treeNode.detail) {
+            if (MonacoOutlineSymbolInformationNode.is(treeNode) && (treeNode.detail || treeNode.deprecated)) {
                 result.set(treeNode.id, this.toDecoration(treeNode));
             }
         }
@@ -52,15 +52,18 @@ export class MonacoOutlineDecorator implements TreeDecorator {
     }
 
     protected toDecoration(node: MonacoOutlineSymbolInformationNode): TreeDecoration.Data {
-        const captionSuffixes: TreeDecoration.CaptionAffix[] = [{
-            data: (node.detail || ''),
+        const captionSuffixes: TreeDecoration.CaptionAffix[] | undefined = node.detail ? [{
+            data: node.detail,
             fontData: {
                 color: 'var(--theia-descriptionForeground)',
             }
-        }];
+        }] : undefined;
+        // Like VS Code, strike through the names of deprecated symbols.
+        const fontData: TreeDecoration.FontData | undefined = node.deprecated ? { style: 'line-through' } : undefined;
 
         return {
-            captionSuffixes
+            captionSuffixes,
+            fontData
         };
     }
 }

package/src/browser/monaco-quick-input-service.ts

@@ -114,6 +114,11 @@ export class MonacoQuickInputImplementation implements IQuickInputService {
 
     protected container: HTMLElement;
 
+    /**
+     * The element that had focus when the quick input was shown. Cleared when the quick input is hidden.
+     */
+    previousFocusElement: HTMLElement | undefined;
+
     protected inQuickOpen: IContextKey<boolean>;
 
     /**
@@ -144,11 +149,17 @@ export class MonacoQuickInputImplementation implements IQuickInputService {
         this.scopedInQuickOpen = this.scopedContextKeyService.createKey<boolean>('inQuickOpen', false);
 
         this.controller.onShow(() => {
+            // `onShow` fires before focus moves into the quick input, and again whenever it switches to another picker.
+            const activeElement = document.activeElement;
+            if (activeElement instanceof HTMLElement && !this.container.contains(activeElement)) {
+                this.previousFocusElement = activeElement;
+            }
             this.container.style.top = this.shell.mainPanel.node.getBoundingClientRect().top + 'px';
             this.inQuickOpen.set(true);
             this.scopedInQuickOpen.set(true);
         });
         this.controller.onHide(() => {
+            this.previousFocusElement = undefined;
             this.inQuickOpen.set(false);
             this.scopedInQuickOpen.set(false);
         });
@@ -407,6 +418,7 @@ export class MonacoQuickInputService implements QuickInputService {
 
     get onShow(): Event<void> { return this.monacoService.onShow; }
     get onHide(): Event<void> { return this.monacoService.onHide; }
+    get previousFocusElement(): HTMLElement | undefined { return this.monacoService.previousFocusElement; }
 
     open(filter: string): void {
         this.monacoService.open(filter);

package/src/browser/monaco-resolved-keybinding.ts

@@ -23,6 +23,7 @@ import { USLayoutResolvedKeybinding } from '@theia/monaco-editor-core/esm/vs/pla
 import * as MonacoPlatform from '@theia/monaco-editor-core/esm/vs/base/common/platform';
 import { KeybindingRegistry } from '@theia/core/lib/browser/keybinding';
 import { KeyCode, KeySequence, Keystroke, Key, KeyModifier } from '@theia/core/lib/browser/keys';
+import { layoutModifiersIncludeShift } from '@theia/core/lib/common/keys';
 import { isOSX } from '@theia/core/lib/common/os';
 import { KEY_CODE_MAP } from './monaco-keycode-map';
 
@@ -33,12 +34,14 @@ export class MonacoResolvedKeybinding extends ResolvedKeybinding {
     constructor(protected readonly keySequence: KeySequence, keybindingService: KeybindingRegistry) {
         super();
         this.chords = keySequence.map(keyCode => {
+            const components = keybindingService.componentsForKeyCode(keyCode);
             // eslint-disable-next-line no-null/no-null
-            const keyLabel = keyCode.key ? keybindingService.acceleratorForKey(keyCode.key) : null;
+            const keyLabel = keyCode.key ? components[components.length - 1] : null;
             const keyAriaLabel = keyLabel;
+            // The label uses the logical character, so layout Shift only appears when it produced an uppercase letter.
             return new ResolvedChord(
                 keyCode.ctrl,
-                keyCode.shift,
+                keybindingService.displaysShift(keyCode),
                 keyCode.alt,
                 keyCode.meta,
                 keyLabel,
@@ -106,7 +109,7 @@ export class MonacoResolvedKeybinding extends ResolvedKeybinding {
     private toKeybinding(keyCode: KeyCode): KeyCodeChord {
         return new KeyCodeChord(
             keyCode.ctrl,
-            keyCode.shift,
+            keyCode.shift || layoutModifiersIncludeShift(keyCode.layoutModifiers),
             keyCode.alt,
             keyCode.meta,
             KEY_CODE_MAP[keyCode.key!.keyCode]