@theia/core 1.77.0-next.56 → 1.77.0-next.57

package/src/browser/keyboard/keys.spec.ts

@@ -17,7 +17,7 @@
 import { enableJSDOM } from '../../browser/test/jsdom';
 let disableJSDOM = enableJSDOM();
 
-import { KeyCode, Key, KeyModifier, KeySequence } from './keys';
+import { KeyCode, Key, KeyModifier, KeySequence, NormalizedKeyboardInput, normalizeKeyboardInput, readAltGraph } from './keys';
 import * as os from '../../common/os';
 import * as chai from 'chai';
 import * as sinon from 'sinon';
@@ -117,6 +117,139 @@ describe('keys api', () => {
         expect(equalKeyCode(parsedKeyCode, keyCode)).to.be.true;
     });
 
+    it('should keep dispatch strings equivalent to serialized strings', () => {
+        const keyCodes = [
+            ...Array.from({ length: 16 }, (_, modifiers) => new KeyCode({
+                key: Key.KEY_A,
+                ctrl: !!(modifiers & 1),
+                shift: !!(modifiers & 2),
+                alt: !!(modifiers & 4),
+                meta: !!(modifiers & 8)
+            })),
+            new KeyCode({}),
+            KeyCode.parse('ctrl+['),
+            KeyCode.parse('shift+/'),
+            ...KeySequence.parse('ctrlcmd+k ctrlcmd+c')
+        ];
+        for (const keyCode of keyCodes) {
+            expect(keyCode.dispatchString()).to.equal(keyCode.toString());
+        }
+    });
+
+    it('should distinguish layout modifiers in dispatch identity without changing serialization', () => {
+        const command = new KeyCode({ key: Key.DIGIT8, ctrl: true, alt: true });
+        const layout = new KeyCode({ key: Key.DIGIT8, ctrl: true, layoutModifiers: 'altGraph', character: '[' });
+        const shiftedLayout = new KeyCode({ key: Key.SLASH, layoutModifiers: 'shift', character: '/' });
+
+        expect(command.toString()).to.equal('alt+ctrl+8');
+        expect(layout.toString()).to.equal('ctrl+8');
+        expect(layout.dispatchString()).to.equal('ctrl+8@altgraph');
+        expect(shiftedLayout.toString()).to.equal('/');
+        expect(shiftedLayout.dispatchString()).to.equal('/@shift');
+        expect(command.equals(layout)).to.be.false;
+    });
+
+    it('should keep equality and dispatch identity equivalent for layout modifiers', () => {
+        const layers = ['none', 'shift', 'altGraph', 'shiftAltGraph'] as const;
+        const keyCodes = Array.from({ length: 64 }, (_, modifiers) => new KeyCode({
+            key: Key.KEY_A,
+            ctrl: !!(modifiers & 1),
+            shift: !!(modifiers & 2),
+            alt: !!(modifiers & 4),
+            meta: !!(modifiers & 8),
+            layoutModifiers: layers[modifiers >> 4]
+        }));
+        for (const left of keyCodes) {
+            for (const right of keyCodes) {
+                expect(left.equals(right)).to.equal(left.dispatchString() === right.dispatchString());
+            }
+        }
+    });
+
+    it('should keep interpretation provenance outside dispatch identity', () => {
+        const command = new KeyCode({ key: Key.DIGIT8, ctrl: true, interpretation: 'commandModifiers' });
+        const layout = new KeyCode({ key: Key.DIGIT8, ctrl: true, interpretation: 'layoutModifiers' });
+
+        expect(command.dispatchString()).to.equal(layout.dispatchString());
+        expect(command.equals(layout)).to.be.true;
+        expect(command.interpretation).to.equal('commandModifiers');
+        expect(layout.interpretation).to.equal('layoutModifiers');
+    });
+
+    it('should normalize explicit and native AltGraph state', () => {
+        expect(readAltGraph({ altGraph: false, getModifierState: () => true })).to.be.false;
+        expect(readAltGraph({ getModifierState: modifier => modifier === 'AltGraph' })).to.be.true;
+        expect(readAltGraph({ code: 'Digit8' })).to.be.false;
+
+        expect(normalizeKeyboardInput({
+            key: '[',
+            code: 'Digit8',
+            keyCode: 56,
+            ctrlKey: true,
+            altGraph: true,
+            location: 0
+        })).to.deep.equal({
+            key: '[',
+            code: 'Digit8',
+            keyCode: 56,
+            charCode: undefined,
+            ctrlKey: true,
+            shiftKey: undefined,
+            altKey: undefined,
+            metaKey: undefined,
+            altGraph: true,
+            repeat: undefined,
+            isComposing: undefined,
+            location: 0,
+            timeStamp: undefined,
+            keyIdentifier: undefined,
+            getModifierState: undefined
+        });
+    });
+
+    it('should preserve every normalized keyboard input field', () => {
+        const getModifierState = (modifier: string) => modifier === 'AltGraph';
+        const input: Required<NormalizedKeyboardInput> = {
+            key: '[',
+            code: 'Digit8',
+            keyCode: 56,
+            charCode: 91,
+            ctrlKey: true,
+            shiftKey: true,
+            altKey: false,
+            metaKey: true,
+            altGraph: true,
+            repeat: true,
+            isComposing: false,
+            location: 2,
+            timeStamp: 42,
+            keyIdentifier: 'U+005B',
+            getModifierState
+        };
+
+        const normalized = normalizeKeyboardInput(input);
+
+        expect({ ...normalized, getModifierState: undefined }).to.deep.equal({ ...input, getModifierState: undefined });
+        expect(normalized.getModifierState?.('AltGraph')).to.be.true;
+    });
+
+    it('should create key codes from normalized plain data', () => {
+        const keyCode = KeyCode.createKeyCode({
+            key: '[',
+            code: 'Digit8',
+            keyCode: 56,
+            ctrlKey: true
+        });
+        expect(keyCode.key).to.equal(Key.DIGIT8);
+        expect(keyCode.ctrl).to.be.true;
+        expect(keyCode.character).to.equal('[');
+    });
+
+    it('should preserve legacy key identifier fallback in normalized data', () => {
+        const input = normalizeKeyboardInput({ keyIdentifier: Key.F1.code });
+        expect(KeyCode.createKeyCode(input).key).to.equal(Key.F1);
+    });
+
     it('the order of the modifiers should not matter when parsing the key code', () => {
         const left = KeySequence.parse('shift+alt+a');
         const right = KeySequence.parse('alt+shift+a');
@@ -231,6 +364,78 @@ describe('keys api', () => {
         expect(second.key).is.equal(Key.KEY_B);
     });
 
+    it('should parse physical scan codes and preserve them when serializing', () => {
+        const keycode = KeyCode.parse('ctrl+[BracketLeft]');
+        expect(keycode.ctrl).to.be.true;
+        expect(keycode.key).to.equal(Key.BRACKET_LEFT);
+        expect(keycode.physical).to.be.true;
+        expect(keycode.toString()).to.equal('ctrl+[BracketLeft]');
+        expect(() => KeyCode.parse('[UnknownPhysicalKey]')).to.throw(/Unknown scan code/);
+    });
+
+    it('should parse bare and escaped logical characters', () => {
+        for (const character of ['^', '§', '²', 'ä']) {
+            const keycode = KeyCode.parse(`ctrl+${character}`);
+            expect(keycode.character).to.equal(character);
+            expect(keycode.toString()).to.equal(`ctrl+${character}`);
+        }
+        expect(KeyCode.parse('ctrl+[char:0x2B]').character).to.equal('+');
+        expect(KeyCode.parse('ctrl+[char:0x20]').character).to.equal(' ');
+        expect(KeyCode.parse('ctrl+[char:0x5D]').character).to.equal(']');
+        expect(KeyCode.parse('ctrl+[char:§]').character).to.equal('§');
+        expect(KeyCode.parse('ctrl+[char:0x2B]').toString()).to.equal('ctrl+[char:0x2B]');
+    });
+
+    it('should keep bracketed separators and whitespace within one key token', () => {
+        expect(KeySequence.parse('ctrl+[char:0x20] ctrl+[BracketLeft]')).to.have.length(2);
+        expect(KeySequence.parse('ctrl+[ ctrl+]')).to.have.length(2);
+        expect(KeySequence.parse('ctrl+] ctrl+[')).to.have.length(2);
+        expect(KeyCode.parse('ctrl+[char:0x2B]').character).to.equal('+');
+        expect(KeyCode.parse('ctrl+[char:0x2D]').character).to.equal('-');
+    });
+
+    it('should reject invalid and multi-code-point logical characters', () => {
+        expect(() => KeyCode.parse('[char:0x110000]')).to.throw(/Invalid Unicode/);
+        expect(() => KeyCode.parse('[char:0xD800]')).to.throw(/Invalid Unicode/);
+        expect(() => KeyCode.parse('[char:ab]')).to.throw(/Invalid Unicode/);
+        expect(() => KeyCode.parse('👨‍👩‍👧‍👦')).to.throw(/Unrecognized key/);
+    });
+
+    it('should serialize recorder strokes as logical characters, named keys, or physical scan codes', () => {
+        expect(new KeyCode({ key: Key.DIGIT8, ctrl: true, character: '[' }).toAuthoredKeybindingString()).to.equal('ctrl+[');
+        expect(new KeyCode({ key: Key.EQUAL, ctrl: true, character: '+' }).toAuthoredKeybindingString()).to.equal('ctrl+[char:0x2B]');
+
+        const namedKeys: Array<[Key, string]> = [
+            [Key.F1, 'f1'],
+            [Key.DELETE, 'delete'],
+            [Key.BACKSPACE, 'backspace'],
+            [Key.ENTER, 'enter'],
+            [Key.ARROW_LEFT, 'left'],
+            [Key.SPACE, 'space'],
+            [Key.ESCAPE, 'escape']
+        ];
+        for (const [key, name] of namedKeys) {
+            const serialized = new KeyCode({ key, ctrl: true }).toAuthoredKeybindingString();
+            expect(serialized).to.equal(`ctrl+${name}`);
+            expect(KeyCode.parse(serialized).key).to.equal(key);
+        }
+
+        const physicalPrintable = new KeyCode({ key: Key.DIGIT8, ctrl: true }).toAuthoredKeybindingString();
+        expect(physicalPrintable).to.equal('ctrl+[Digit8]');
+        expect(KeyCode.parse(physicalPrintable).key).to.equal(Key.DIGIT8);
+
+        const shiftedLetter = new KeyCode({ key: Key.KEY_P, ctrl: true, shift: true, character: 'P' });
+        expect(shiftedLetter.toAuthoredKeybindingString()).to.equal('shift+ctrl+p');
+        expect(KeyCode.parse(shiftedLetter.toAuthoredKeybindingString()).dispatchString()).to.equal('shift+ctrl+p');
+    });
+
+    it('should serialize recorder strokes for Space and numpad keys by name', () => {
+        expect(new KeyCode({ key: Key.SPACE, meta: true, shift: true, character: ' ' }).toAuthoredKeybindingString()).to.equal('meta+shift+space');
+        expect(new KeyCode({ key: Key.ADD, ctrl: true, character: '+' }).toAuthoredKeybindingString()).to.equal('ctrl+add');
+        expect(new KeyCode({ key: Key.DECIMAL, ctrl: true, character: '.' }).toAuthoredKeybindingString()).to.equal('ctrl+decimal');
+        expect(new KeyCode({ key: Key.DIGIT1, ctrl: true, character: '1' }).toAuthoredKeybindingString()).to.equal('ctrl+1');
+    });
+
     it('should parse minus as key', () => {
         const keycode = KeyCode.parse('ctrl+-');
         expect(keycode.ctrl).to.be.true;

package/src/browser/menu/action-menu-node.spec.ts

@@ -0,0 +1,60 @@
+// *****************************************************************************
+// 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.
+//
+// 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 { expect } from 'chai';
+import { Key, KeyCode } from '../keyboard/keys';
+import { KeybindingRegistry } from '../keybinding';
+import { ActionMenuNode } from './action-menu-node';
+
+describe('ActionMenuNode accelerators', () => {
+    it('selects logical and physical accelerator forms explicitly', () => {
+        const binding = { command: 'test.command', keybinding: 'ctrl+[' };
+        const state = { inactive: false };
+        const keybindingRegistry = Object.create(KeybindingRegistry.prototype) as KeybindingRegistry;
+        keybindingRegistry.getKeybindingsForCommand = () => [{ ...binding, scope: 0 }];
+        keybindingRegistry.isEnabledInScope = () => true;
+        keybindingRegistry.isKeybindingInactive = () => state.inactive;
+        keybindingRegistry.resolveKeybinding = () => [new KeyCode({
+            key: Key.DIGIT8,
+            ctrl: true,
+            character: '[',
+            layoutModifiers: 'altGraph'
+        })];
+        Object.defineProperty(keybindingRegistry, 'keyboardLayoutService', {
+            value: { getKeyboardCharacter: (key: Key) => key.easyString }
+        });
+        const commands = {
+            getAllHandlers: () => [],
+            getCommand: () => ({ id: 'test.command' })
+        };
+        const contextKeyService = {
+            parseKeys: () => undefined
+        };
+        const node = new ActionMenuNode(
+            { commandId: 'test.command' },
+            commands as never,
+            keybindingRegistry,
+            contextKeyService as never
+        );
+
+        expect(node.getAccelerator(undefined, 'logical')).to.deep.equal(['Ctrl+[']);
+        expect(node.getAccelerator(undefined, 'physical')).to.deep.equal(['Ctrl+AltGr+8']);
+
+        state.inactive = true;
+        expect(node.getAccelerator(undefined, 'logical')).to.deep.equal(['Ctrl+[']);
+        expect(node.getAccelerator(undefined, 'physical')).to.deep.equal([]);
+    });
+});

package/src/browser/menu/action-menu-node.ts

@@ -14,13 +14,16 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { KeybindingRegistry } from '../keybinding';
+import { AcceleratorForm, KeybindingRegistry } from '../keybinding';
 import { ContextKeyService } from '../context-key-service';
-import { DisposableCollection, isObject, CommandRegistry, Emitter, environment } from '../../common';
+import { DisposableCollection, isObject, CommandRegistry, Emitter } from '../../common';
 import { CommandMenu, ContextExpressionMatcher, MenuAction, MenuPath } from '../../common/menu/menu-types';
 
+export { AcceleratorForm } from '../keybinding';
+
 export interface AcceleratorSource {
-    getAccelerator(context: HTMLElement | undefined): string[];
+    /** Return the accelerator rendered in the explicitly requested logical or physical form. */
+    getAccelerator(context: HTMLElement | undefined, form: AcceleratorForm): string[];
 }
 
 export namespace AcceleratorSource {
@@ -80,17 +83,8 @@ export class ActionMenuNode implements CommandMenu {
         return true;
     }
 
-    getAccelerator(context: HTMLElement | undefined): string[] {
-        const bindings = this.keybindingRegistry.getKeybindingsForCommand(this.action.commandId);
-        // Only consider the first active keybinding.
-        if (bindings.length) {
-            const binding = bindings.find(b => this.keybindingRegistry.isEnabledInScope(b, context));
-            if (binding) {
-                const asciiOnly = environment.electron.is();
-                return this.keybindingRegistry.acceleratorFor(binding, '+', asciiOnly);
-            }
-        }
-        return [];
+    getAccelerator(context: HTMLElement | undefined, form: AcceleratorForm): string[] {
+        return this.keybindingRegistry.acceleratorForCommand(this.action.commandId, context, form);
     }
 
     isEnabled(effeciveMenuPath: MenuPath, ...args: unknown[]): boolean {

package/src/browser/menu/browser-menu-plugin.ts

@@ -368,7 +368,7 @@ export class DynamicMenuWidget extends MenuWidget {
                         iconClass: node.icon,
                     });
 
-                    const accelerator = (AcceleratorSource.is(node) ? node.getAccelerator(this.options.context) : []);
+                    const accelerator = (AcceleratorSource.is(node) ? node.getAccelerator(this.options.context, 'logical') : []);
                     if (accelerator.length > 0) {
                         phCommandRegistry.addKeyBinding({
                             command: id,

package/src/browser/test/jsdom.ts

@@ -58,6 +58,17 @@ export function enableJSDOM(): () => void {
         }
     });
     (dom.window.document as any)['queryCommandSupported'] = function (): void { };
+    dom.window.matchMedia = () => ({
+        matches: false,
+        media: '',
+        // eslint-disable-next-line no-null/no-null
+        onchange: null,
+        addListener: () => undefined,
+        removeListener: () => undefined,
+        addEventListener: () => undefined,
+        removeEventListener: () => undefined,
+        dispatchEvent: () => false
+    });
 
     const disableJSDOM = (global as any)['_disableJSDOM'] = () => {
         let property: string | undefined;

package/src/common/keyboard/keyboard-layout-provider.ts

@@ -21,8 +21,11 @@ export const keyboardPath = '/services/keyboard';
 
 export const KeyboardLayoutProvider = Symbol('KeyboardLayoutProvider');
 
+export type KeyboardLayoutSource = 'navigator.keyboard' | 'user-choice' | 'pressed-keys' | 'native-keymap';
+
 export interface KeyboardLayoutProvider {
     getNativeLayout(): Promise<NativeKeyboardLayout>;
+    readonly layoutSource?: KeyboardLayoutSource;
 }
 
 export const KeyboardLayoutChangeNotifier = Symbol('KeyboardLayoutChangeNotifier');
@@ -37,6 +40,11 @@ export interface KeyValidationInput {
     shiftKey?: boolean;
     ctrlKey?: boolean;
     altKey?: boolean;
+    /**
+     * Whether the AltGr layer is active for the platform (Linux: AltGraph, macOS: Option, Windows: AltGraph or Ctrl+Alt),
+     * not the raw `AltGraph` modifier state.
+     */
+    altGraph?: boolean;
 }
 
 export const KeyValidator = Symbol('KeyValidator');