@theia/core 1.77.0-next.49 → 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/label-provider.ts

@@ -15,7 +15,9 @@
 // *****************************************************************************
 
 import { inject, injectable, named, postConstruct } from 'inversify';
-import * as fileIcons from 'file-icons-js';
+// The default import returns the exported FileIcons instance itself; a namespace import would be an interop copy of its own
+// properties only, and getClass/getClassWithColor live on the prototype.
+import fileIcons from 'file-icons-js';
 import URI from '../common/uri';
 import { ContributionProvider } from '../common/contribution-provider';
 import { Event, Emitter, Disposable, isObject, Path, Prioritizeable } from '../common';

package/src/browser/markdown-rendering/markdown-renderer.ts

@@ -16,7 +16,7 @@
 
 import * as DOMPurify from 'dompurify';
 import { injectable, inject, postConstruct } from 'inversify';
-import * as markdownit from 'markdown-it';
+import markdownit from 'markdown-it';
 import * as markdownitemoji from 'markdown-it-emoji';
 import { MarkdownString } from '../../common/markdown-rendering/markdown-string';
 import { Disposable, DisposableGroup } from '../../common';

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/preferences/preference-validation-service.spec.ts

@@ -16,7 +16,7 @@
 
 import { Container } from 'inversify';
 import { PreferenceValidationService } from './preference-validation-service';
-import * as assert from 'assert';
+import assert from 'assert';
 import { JSONValue } from '@lumino/coreutils';
 import { IJSONSchema, JsonType } from '../../common/json-schema';
 import {

package/src/browser/quick-input/quick-command-service.spec.ts

@@ -0,0 +1,159 @@
+// *****************************************************************************
+// 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 { enableJSDOM } from '../test/jsdom';
+let disableJSDOM = enableJSDOM();
+
+import { FrontendApplicationConfigProvider } from '../frontend-application-config-provider';
+FrontendApplicationConfigProvider.set({});
+
+import * as chai from 'chai';
+import { Container } from 'inversify';
+import { CancellationToken, CommandRegistry, Emitter } from '../../common';
+import { CorePreferences } from '../../common/core-preferences';
+import { ContextKeyService, ContextKeyServiceDummyImpl } from '../context-key-service';
+import { KeybindingRegistry } from '../keybinding';
+import { QuickAccessRegistry } from './quick-access';
+import { QuickCommandService } from './quick-command-service';
+import { QuickInputService, QuickPickItem } from './quick-input-service';
+
+disableJSDOM();
+
+const expect = chai.expect;
+
+class RecordingContextKeyService extends ContextKeyServiceDummyImpl {
+    activeContext: unknown;
+
+    override withContext<T>(context: unknown, callback: () => T): T {
+        const previous = this.activeContext;
+        this.activeContext = context;
+        try {
+            return callback();
+        } finally {
+            this.activeContext = previous;
+        }
+    }
+}
+
+describe('quick-command-service', () => {
+
+    let editor: HTMLElement;
+    let quickInput: HTMLInputElement;
+    let contextKeyService: RecordingContextKeyService;
+    let commandRegistry: CommandRegistry;
+    let onHideEmitter: Emitter<void>;
+    let quickInputService: { previousFocusElement?: HTMLElement, onHide: Emitter<void>['event'] };
+    let service: QuickCommandService;
+
+    before(() => {
+        disableJSDOM = enableJSDOM();
+    });
+
+    after(() => {
+        disableJSDOM();
+    });
+
+    beforeEach(() => {
+        editor = document.createElement('div');
+        editor.tabIndex = 0;
+        quickInput = document.createElement('input');
+        document.body.append(editor, quickInput);
+        // Focus has moved to the quick input, as it does while the palette is open.
+        quickInput.focus();
+
+        contextKeyService = new RecordingContextKeyService();
+        commandRegistry = new CommandRegistry({ getContributions: () => [] });
+        onHideEmitter = new Emitter<void>();
+        quickInputService = { previousFocusElement: editor, onHide: onHideEmitter.event };
+
+        const container = new Container();
+        container.bind(ContextKeyService).toConstantValue(contextKeyService);
+        container.bind(CommandRegistry).toConstantValue(commandRegistry);
+        container.bind(CorePreferences).toConstantValue(<CorePreferences>{ 'workbench.commandPalette.history': 50 });
+        container.bind(QuickAccessRegistry).toConstantValue(<QuickAccessRegistry>{});
+        container.bind(KeybindingRegistry).toConstantValue(<KeybindingRegistry><unknown>{ getKeybindingsForCommand: () => [] });
+        container.bind(QuickInputService).toConstantValue(<QuickInputService><unknown>quickInputService);
+        container.bind(QuickCommandService).toSelf();
+        service = container.get(QuickCommandService);
+    });
+
+    afterEach(() => {
+        editor.remove();
+        quickInput.remove();
+        onHideEmitter.dispose();
+    });
+
+    function inEditorContext(): boolean {
+        return contextKeyService.activeContext === editor;
+    }
+
+    function picks(): QuickPickItem[] {
+        return service.getPicks('', CancellationToken.None).filter((pick): pick is QuickPickItem => pick.type !== 'separator');
+    }
+
+    it('evaluates command enablement against the element focused before the quick input opened', () => {
+        commandRegistry.registerCommand({ id: 'test.editorOnly', label: 'Editor Only' }, { execute: () => { }, isEnabled: inEditorContext });
+
+        expect(picks().map(pick => pick.label)).to.deep.equal(['Editor Only']);
+    });
+
+    it('evaluates item state against the element focused before the quick input opened', () => {
+        commandRegistry.registerCommand({ id: 'test.toggle', label: 'Toggle' }, { execute: () => { }, isEnabled: inEditorContext, isToggled: inEditorContext });
+
+        const [item] = picks();
+        expect(item.alwaysShow).to.be.true;
+        expect(item.iconClasses).to.not.be.undefined;
+    });
+
+    it('evaluates pushed command contexts against the element focused before the quick input opened', () => {
+        contextKeyService.match = () => inEditorContext();
+        commandRegistry.registerCommand({ id: 'test.when', label: 'When' }, { execute: () => { } });
+        service.pushCommandContext('test.when', 'editorFocus');
+
+        expect(picks().map(pick => pick.label)).to.deep.equal(['When']);
+    });
+
+    it('restores focus to the element focused before the quick input opened on execute', () => {
+        commandRegistry.registerCommand({ id: 'test.command', label: 'Command' }, { execute: () => { } });
+
+        picks()[0].execute!();
+
+        expect(document.activeElement).to.equal(editor);
+    });
+
+    it('falls back to the active element when items are created without a reset', () => {
+        commandRegistry.registerCommand({ id: 'test.command', label: 'Command' }, { execute: () => { } });
+        const item = service.toItem({ id: 'test.command', label: 'Command' });
+        editor.focus();
+
+        item.execute!();
+
+        expect(document.activeElement).to.equal(quickInput);
+    });
+
+    it('forgets the context element when the quick input is hidden', () => {
+        commandRegistry.registerCommand({ id: 'test.command', label: 'Command' }, { execute: () => { } });
+        service.reset();
+        onHideEmitter.fire();
+
+        const item = service.toItem({ id: 'test.command', label: 'Command' });
+        editor.focus();
+        item.execute!();
+
+        expect(document.activeElement).to.equal(quickInput);
+    });
+
+});

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

@@ -14,13 +14,13 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { inject, injectable } from 'inversify';
+import { inject, injectable, optional, postConstruct } from 'inversify';
 import { KeybindingRegistry } from '../keybinding';
 import { Disposable, Command, CommandRegistry, CancellationToken, nls } from '../../common';
 import { ContextKeyService } from '../context-key-service';
 import { CorePreferences } from '../../common/core-preferences';
 import { QuickAccessContribution, QuickAccessProvider, QuickAccessRegistry } from './quick-access';
-import { filterItems, QuickPickItem, QuickPicks } from './quick-input-service';
+import { filterItems, QuickInputService, QuickPickItem, QuickPicks } from './quick-input-service';
 import { KeySequence } from '../keys';
 import { codiconArray } from '../widgets';
 
@@ -56,6 +56,9 @@ export class QuickCommandService implements QuickAccessContribution, QuickAccess
     @inject(KeybindingRegistry)
     protected readonly keybindingRegistry: KeybindingRegistry;
 
+    @inject(QuickInputService) @optional()
+    protected readonly quickInputService: QuickInputService | undefined;
+
     // The list of exempted commands not to be displayed in the recently used list.
     readonly exemptedCommands: Command[] = [
         CLEAR_COMMAND_HISTORY,
@@ -64,6 +67,17 @@ export class QuickCommandService implements QuickAccessContribution, QuickAccess
     private recentItems: QuickPickItem[] = [];
     private otherItems: QuickPickItem[] = [];
 
+    /**
+     * The element that was focused when the quick input was opened.
+     * Commands are evaluated against its context, since focus moves to the quick input while the palette is open.
+     */
+    protected commandContextElement: HTMLElement | undefined;
+
+    @postConstruct()
+    protected init(): void {
+        this.quickInputService?.onHide(() => this.commandContextElement = undefined);
+    }
+
     registerQuickAccessProvider(): void {
         this.quickAccessRegistry.registerQuickAccessProvider({
             getInstance: () => this,
@@ -74,11 +88,12 @@ export class QuickCommandService implements QuickAccessContribution, QuickAccess
     }
 
     reset(): void {
-        const { recent, other } = this.getCommands();
-        this.recentItems = [];
-        this.otherItems = [];
-        this.recentItems.push(...recent.map(command => this.toItem(command)));
-        this.otherItems.push(...other.map(command => this.toItem(command)));
+        this.updateCommandContextElement();
+        this.withCommandContext(() => {
+            const { recent, other } = this.getCommands();
+            this.recentItems = recent.map(command => this.toItem(command));
+            this.otherItems = other.map(command => this.toItem(command));
+        });
     }
 
     getPicks(filter: string, token: CancellationToken): QuickPicks {
@@ -105,7 +120,8 @@ export class QuickCommandService implements QuickAccessContribution, QuickAccess
     toItem(command: Command): QuickPickItem {
         const label = (command.category) ? `${command.category}: ` + command.label! : command.label!;
         const iconClasses = this.getItemIconClasses(command);
-        const activeElement = window.document.activeElement as HTMLElement;
+        const activeElement = window.document.activeElement;
+        const commandContextElement = this.commandContextElement ?? (activeElement instanceof HTMLElement ? activeElement : undefined);
 
         const originalLabel = command.originalLabel || command.label!;
         const originalCategory = command.originalCategory || command.category;
@@ -121,13 +137,24 @@ export class QuickCommandService implements QuickAccessContribution, QuickAccess
             alwaysShow: !!this.commandRegistry.getActiveHandler(command.id),
             keySequence: this.getKeybinding(command),
             execute: () => {
-                activeElement.focus({ preventScroll: true });
+                commandContextElement?.focus({ preventScroll: true });
                 this.commandRegistry.executeCommand(command.id);
                 this.commandRegistry.addRecentCommand(command);
             }
         };
     }
 
+    protected updateCommandContextElement(): void {
+        // When the palette is opened directly, the picks are computed before the quick input is shown and focused.
+        const element = this.quickInputService?.previousFocusElement ?? window.document.activeElement;
+        this.commandContextElement = element instanceof HTMLElement ? element : undefined;
+    }
+
+    protected withCommandContext<T>(callback: () => T): T {
+        const element = this.commandContextElement;
+        return element?.isConnected ? this.contextKeyService.withContext(element, callback) : callback();
+    }
+
     private getKeybinding(command: Command): KeySequence | undefined {
         const keybindings = this.keybindingRegistry.getKeybindingsForCommand(command.id);
         if (!keybindings || keybindings.length === 0) {

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

@@ -60,7 +60,7 @@ export class QuickHelpService implements QuickAccessProvider, QuickAccessContrib
 
             for (const helpEntry of provider.helpEntries) {
                 const prefix = helpEntry.prefix || provider.prefix;
-                const label = prefix || '\u2026' /* ... */;
+                const label = prefix || '\u2026'; // ...
 
                 (helpEntry.needsEditor ? editorProviders : globalProviders).push({
                     label,

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/browser/tree/tree-container.spec.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import * as assert from 'assert';
+import assert from 'assert';
 import { Container } from 'inversify';
 import { createTreeContainer, isTreeServices } from './tree-container';
 import { TreeSearch } from './tree-search';