@theia/core
Version:
Theia is a cloud & desktop IDE framework implemented in TypeScript.
1,440 lines • 76.7 kB
JavaScript
// *****************************************************************************
// Copyright (C) 2017 Ericsson 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 { __decorate } from "tslib";
import { enableJSDOM } from './test/jsdom.js';
let disableJSDOM = enableJSDOM();
import { FrontendApplicationConfigProvider } from './frontend-application-config-provider.js';
try {
FrontendApplicationConfigProvider.get();
}
catch {
FrontendApplicationConfigProvider.set({});
}
import { Container, injectable, ContainerModule } from 'inversify';
import { bindContributionProvider } from '../common/contribution-provider.js';
import { KeyboardLayoutProvider, KeyboardLayoutChangeNotifier } from '../common/keyboard/keyboard-layout-provider.js';
import { ILogger } from '../common/logger.js';
import { KeybindingRegistry, KeybindingContext, KeybindingContribution, KeybindingScope } from './keybinding.js';
import { KeyCode, Key, KeyModifier, KeySequence } from './keyboard/keys.js';
import { KeyboardLayoutService } from './keyboard/keyboard-layout-service.js';
import { CommandRegistry, CommandService, CommandContribution } from '../common/command.js';
import { LabelParser } from './label-parser.js';
import { MockLogger } from '../common/test/mock-logger.js';
import { FrontendApplicationStateService } from './frontend-application-state.js';
import { ContextKeyService, ContextKeyServiceDummyImpl } from './context-key-service.js';
import { CorePreferences } from '../common/core-preferences.js';
import * as chai from 'chai';
import * as sinon from 'sinon';
import { Emitter } from '../common/event.js';
import { bindPreferenceService } from './frontend-application-bindings.js';
import { MarkdownRenderer, MarkdownRendererFactory, MarkdownRendererImpl } from './markdown-rendering/markdown-renderer.js';
import { StatusBar } from './status-bar/index.js';
import deGermanMacLayout from '../common/keyboard/layouts/de-German-mac.json' with { type: 'json' };
import deGermanPcLayout from '../common/keyboard/layouts/de-German-pc.json' with { type: 'json' };
import enUSMacLayout from '../common/keyboard/layouts/en-US-mac.json' with { type: 'json' };
import enUSPcLayout from '../common/keyboard/layouts/en-US-pc.json' with { type: 'json' };
import { stubOS } from '../common/test/stub-os.js';
disableJSDOM();
const deGermanMac = deGermanMacLayout;
const deGermanPc = deGermanPcLayout;
const enUSMac = enUSMacLayout;
const enUSPc = enUSPcLayout;
const expect = chai.expect;
function testKeyboardEvent(input = {}) {
let defaultPrevented = false;
return {
key: input.key,
code: input.code,
keyCode: input.keyCode,
ctrlKey: input.ctrlKey,
shiftKey: input.shiftKey,
altKey: input.altKey,
metaKey: input.metaKey,
repeat: input.repeat,
isComposing: input.isComposing,
location: input.location,
timeStamp: input.timeStamp,
target: input.target,
get defaultPrevented() { return defaultPrevented; },
preventDefault() { defaultPrevented = true; },
stopPropagation() { }
};
}
let keybindingRegistry;
let commandRegistry;
let testContainer;
let stub;
const preferenceChanged = new Emitter();
const corePreferences = {
'keyboard.dispatch': 'code',
onPreferenceChanged: preferenceChanged.event
};
const RUSSIAN_LAYOUT = {
info: { id: 'ru', lang: 'ru' },
mapping: {
KeyA: { value: 'ф', withShift: 'Ф', withAltGr: '', withShiftAltGr: '' },
KeyC: { value: 'с', withShift: 'С', withAltGr: '', withShiftAltGr: '' },
KeyE: { value: 'у', withShift: 'У', withAltGr: '€', withShiftAltGr: '' },
KeyV: { value: 'м', withShift: 'М', withAltGr: '', withShiftAltGr: '' },
KeyS: { value: 'ы', withShift: 'Ы', withAltGr: '', withShiftAltGr: '' },
Digit8: { value: '8', withShift: '*', withAltGr: '', withShiftAltGr: '' },
BracketLeft: { value: 'х', withShift: 'Х', withAltGr: '', withShiftAltGr: '' },
Comma: { value: 'б', withShift: 'Б', withAltGr: '', withShiftAltGr: '' }
}
};
before(async () => {
testContainer = new Container();
const module = new ContainerModule((bind, unbind, isBound, rebind) => {
/* Mock logger binding*/
bind(ILogger).to(MockLogger);
bind(KeyboardLayoutService).toSelf().inSingletonScope();
bind(MockKeyboardLayoutProvider).toSelf().inSingletonScope();
bind(KeyboardLayoutProvider).toDynamicValue(ctx => {
const provider = ctx.container.get(MockKeyboardLayoutProvider);
return new Proxy(provider, {
get: (target, property) => property === 'then' ? undefined
: property === 'layoutSource' ? 'navigator.keyboard'
: property in target ? Reflect.get(target, property) : () => undefined
});
});
bind(MockKeyboardLayoutChangeNotifier).toSelf().inSingletonScope();
bind(KeyboardLayoutChangeNotifier).toService(MockKeyboardLayoutChangeNotifier);
bindContributionProvider(bind, KeybindingContext);
bind(CommandRegistry).toSelf().inSingletonScope();
bindContributionProvider(bind, CommandContribution);
bind(KeybindingRegistry).toSelf();
bindContributionProvider(bind, KeybindingContribution);
bind(TestContribution).toSelf().inSingletonScope();
[CommandContribution, KeybindingContribution].forEach(serviceIdentifier => bind(serviceIdentifier).toService(TestContribution));
bind(KeybindingContext).toConstantValue({
id: 'testContext',
isEnabled(arg) {
return true;
}
});
bind(StatusBar).toConstantValue({
setElement: () => Promise.resolve(),
removeElement: () => Promise.resolve()
});
bind(MarkdownRendererImpl).toSelf().inSingletonScope();
bind(MarkdownRenderer).toService(MarkdownRendererImpl);
bind(MarkdownRendererFactory).toFactory(({ container }) => () => container.get(MarkdownRenderer));
bind(CommandService).toService(CommandRegistry);
bind(LabelParser).toSelf().inSingletonScope();
bind(ContextKeyService).to(MockContextKeyService).inSingletonScope();
bind(FrontendApplicationStateService).toSelf().inSingletonScope();
bind(CorePreferences).toConstantValue(corePreferences);
bindPreferenceService(bind);
});
testContainer.load(module);
commandRegistry = testContainer.get(CommandRegistry);
commandRegistry.onStart();
});
beforeEach(async function () {
if (this.currentTest?.file?.endsWith('keybinding.spec.js')) {
disableJSDOM();
disableJSDOM = enableJSDOM();
}
stub = stubOS('isOSX', false);
keybindingRegistry = testContainer.get(KeybindingRegistry);
corePreferences['keyboard.dispatch'] = 'code';
await keybindingRegistry.onStart();
});
afterEach(function () {
stub.restore();
if (this.currentTest?.file?.endsWith('keybinding.spec.js')) {
disableJSDOM();
}
});
describe('keybindings', () => {
it('should register the default keybindings', () => {
const keybinding = keybindingRegistry.getKeybindingsForCommand(TEST_COMMAND.id);
expect(keybinding).is.not.undefined;
const keybinding2 = keybindingRegistry.getKeybindingsForCommand('undefined.command');
expect(keybinding2.length).is.equal(0);
});
it('should set a keymap', () => {
const keybindings = [{
command: TEST_COMMAND.id,
keybinding: 'ctrl+c'
}];
keybindingRegistry.setKeymap(KeybindingScope.USER, keybindings);
const bindings = keybindingRegistry.getKeybindingsForCommand(TEST_COMMAND.id);
if (bindings) {
const keyCode = KeyCode.parse(bindings[0].keybinding);
expect(keyCode.key).to.be.equal(Key.KEY_C);
expect(keyCode.ctrl).to.be.true;
}
});
it('should reset to default in case of invalid keybinding', () => {
const keybindings = [{
command: TEST_COMMAND.id,
keybinding: 'ctrl+invalid'
}];
keybindingRegistry.setKeymap(KeybindingScope.USER, keybindings);
const bindings = keybindingRegistry.getKeybindingsForCommand(TEST_COMMAND.id);
if (bindings) {
const keyCode = KeyCode.parse(bindings[0].keybinding);
expect(keyCode.key).to.be.equal(Key.KEY_A);
expect(keyCode.ctrl).to.be.true;
}
});
it('should remove all disabled keybindings from a command that has multiple keybindings', () => {
const keybindings = [{
command: TEST_COMMAND2.id,
keybinding: 'F3'
},
{
command: '-' + TEST_COMMAND2.id,
context: 'testContext',
keybinding: 'ctrl+f1'
},
];
keybindingRegistry.setKeymap(KeybindingScope.USER, keybindings);
const bindings = keybindingRegistry.getKeybindingsForCommand(TEST_COMMAND2.id);
if (bindings) {
// a USER one and a DEFAULT one
expect(bindings.length).to.be.equal(2);
const keyCode = KeyCode.parse(bindings[0].keybinding);
expect(keyCode.key).to.be.equal(Key.F3);
expect(keyCode.ctrl).to.be.false;
const keyCode2 = KeyCode.parse(bindings[1].keybinding);
expect(keyCode2.key).to.be.equal(Key.F2);
expect(keyCode2.ctrl).to.be.true;
}
});
it('should register a keybinding', () => {
const keybinding = {
command: TEST_COMMAND2.id,
keybinding: 'F5'
};
expect(isKeyBindingRegistered(keybinding)).to.be.false;
keybindingRegistry.registerKeybinding(keybinding);
expect(isKeyBindingRegistered(keybinding)).to.be.true;
});
it('should unregister all keybindings from a specific command', () => {
const otherKeybinding = {
command: TEST_COMMAND.id,
keybinding: 'F4'
};
keybindingRegistry.registerKeybinding(otherKeybinding);
expect(isKeyBindingRegistered(otherKeybinding)).to.be.true;
const keybinding = {
command: TEST_COMMAND2.id,
keybinding: 'F5'
};
const keybinding2 = {
command: TEST_COMMAND2.id,
keybinding: 'F6'
};
keybindingRegistry.registerKeybinding(keybinding);
keybindingRegistry.registerKeybinding(keybinding2);
expect(isKeyBindingRegistered(keybinding)).to.be.true;
expect(isKeyBindingRegistered(keybinding2)).to.be.true;
keybindingRegistry.unregisterKeybinding(TEST_COMMAND2);
expect(isKeyBindingRegistered(keybinding)).to.be.false;
expect(isKeyBindingRegistered(keybinding2)).to.be.false;
const bindingsAfterUnregister = keybindingRegistry.getKeybindingsForCommand(TEST_COMMAND2.id);
expect(bindingsAfterUnregister).not.to.be.undefined;
expect(bindingsAfterUnregister.length).to.be.equal(0);
expect(isKeyBindingRegistered(otherKeybinding)).to.be.true;
});
it('should unregister a specific keybinding', () => {
const otherKeybinding = {
command: TEST_COMMAND2.id,
keybinding: 'F4'
};
keybindingRegistry.registerKeybinding(otherKeybinding);
const keybinding = {
command: TEST_COMMAND2.id,
keybinding: 'F5'
};
keybindingRegistry.registerKeybinding(keybinding);
expect(isKeyBindingRegistered(otherKeybinding)).to.be.true;
expect(isKeyBindingRegistered(keybinding)).to.be.true;
keybindingRegistry.unregisterKeybinding(keybinding);
expect(isKeyBindingRegistered(keybinding)).to.be.false;
expect(isKeyBindingRegistered(otherKeybinding)).to.be.true;
});
it('should unregister a specific key', () => {
const otherKeybinding = {
command: TEST_COMMAND.id,
keybinding: 'F4'
};
keybindingRegistry.registerKeybinding(otherKeybinding);
const testKey = 'F5';
const keybinding = {
command: TEST_COMMAND2.id,
keybinding: testKey
};
const keybinding2 = {
command: TEST_COMMAND.id,
keybinding: testKey
};
keybindingRegistry.registerKeybinding(keybinding);
keybindingRegistry.registerKeybinding(keybinding2);
expect(isKeyBindingRegistered(otherKeybinding)).to.be.true;
expect(isKeyBindingRegistered(keybinding)).to.be.true;
expect(isKeyBindingRegistered(keybinding2)).to.be.true;
keybindingRegistry.unregisterKeybinding(testKey);
expect(isKeyBindingRegistered(otherKeybinding)).to.be.true;
expect(isKeyBindingRegistered(keybinding)).to.be.false;
expect(isKeyBindingRegistered(keybinding2)).to.be.false;
});
it('should register a correct keybinding, then default back to the original for a wrong one after', () => {
let keybindings = [{
command: TEST_COMMAND.id,
keybinding: 'ctrl+c'
}];
// Get default binding
const keystroke = keybindingRegistry.getKeybindingsForCommand(TEST_COMMAND.id);
// Set correct new binding
keybindingRegistry.setKeymap(KeybindingScope.USER, keybindings);
const bindings = keybindingRegistry.getKeybindingsForCommand(TEST_COMMAND.id);
if (bindings) {
const keyCode = KeyCode.parse(bindings[0].keybinding);
expect(keyCode.key).to.be.equal(Key.KEY_C);
expect(keyCode.ctrl).to.be.true;
}
// Set invalid binding
keybindings = [{
command: TEST_COMMAND.id,
keybinding: 'ControlLeft+Invalid'
}];
keybindingRegistry.setKeymap(KeybindingScope.USER, keybindings);
const defaultBindings = keybindingRegistry.getKeybindingsForCommand(TEST_COMMAND.id);
if (defaultBindings) {
if (keystroke) {
const keyCode = KeyCode.parse(defaultBindings[0].keybinding);
const keyStrokeCode = KeyCode.parse(keystroke[0].keybinding);
expect(keyCode.key).to.be.equal(keyStrokeCode.key);
}
}
});
it('should only return the more specific keybindings when a keystroke is entered', () => {
const keybindingsUser = [{
command: TEST_COMMAND.id,
keybinding: 'ctrl+b'
}];
keybindingRegistry.setKeymap(KeybindingScope.USER, keybindingsUser);
const keybindingsSpecific = [{
command: TEST_COMMAND.id,
keybinding: 'ctrl+c'
}];
const validKeyCode = KeyCode.createKeyCode({ first: Key.KEY_C, modifiers: [KeyModifier.CtrlCmd] });
keybindingRegistry.setKeymap(KeybindingScope.WORKSPACE, keybindingsSpecific);
let match = keybindingRegistry.matchKeybinding([KeyCode.createKeyCode({ first: Key.KEY_A, modifiers: [KeyModifier.CtrlCmd] })]);
expect(match && match.kind).to.be.equal('full');
match = keybindingRegistry.matchKeybinding([KeyCode.createKeyCode({ first: Key.KEY_B, modifiers: [KeyModifier.CtrlCmd] })]);
expect(match && match.kind).to.be.equal('full');
match = keybindingRegistry.matchKeybinding([KeyCode.createKeyCode({ first: Key.KEY_C, modifiers: [KeyModifier.CtrlCmd] })]);
const keyCode = match && KeyCode.parse(match.runtime.binding.keybinding);
expect(keyCode?.key).to.be.equal(validKeyCode.key);
});
it('should return partial keybinding matches', () => {
const keybindingsUser = [{
command: TEST_COMMAND.id,
keybinding: 'ctrlcmd+x t'
}];
keybindingRegistry.setKeymap(KeybindingScope.USER, keybindingsUser);
const validKeyCodes = [];
validKeyCodes.push(KeyCode.createKeyCode({ first: Key.KEY_C, modifiers: [KeyModifier.CtrlCmd] }));
validKeyCodes.push(KeyCode.createKeyCode({ first: Key.KEY_T }));
const match = keybindingRegistry.matchKeybinding(KeySequence.parse('ctrlcmd+x'));
expect(match && match.kind).to.be.equal('partial');
});
it('should possible to override keybinding', () => {
const overriddenKeybinding = 'ctrlcmd+b a';
const command = TEST_COMMAND_SHADOW.id;
const keybindingShadowing = [
{
command,
keybinding: overriddenKeybinding
},
{
command,
keybinding: 'ctrlcmd+b'
}
];
keybindingRegistry.registerKeybindings(...keybindingShadowing);
const bindings = keybindingRegistry.getKeybindingsForCommand(command);
expect(bindings.length).to.be.equal(2);
expect(bindings[0].keybinding).to.be.equal('ctrlcmd+b');
expect(bindings[1].keybinding).to.be.equal(overriddenKeybinding);
});
it('overridden bindings should be returned last', () => {
const keyCode = KeyCode.createKeyCode({ first: Key.KEY_A, modifiers: [KeyModifier.Shift] });
const overriddenDefaultBinding = {
keybinding: keyCode.toString(),
command: 'test.overridden-default-command'
};
const defaultBinding = {
keybinding: keyCode.toString(),
command: 'test.default-command'
};
const userBinding = {
keybinding: keyCode.toString(),
command: 'test.user-command'
};
const workspaceBinding = {
keybinding: keyCode.toString(),
command: 'test.workspace-command'
};
keybindingRegistry.setKeymap(KeybindingScope.DEFAULT, [overriddenDefaultBinding, defaultBinding]);
keybindingRegistry.setKeymap(KeybindingScope.USER, [userBinding]);
keybindingRegistry.setKeymap(KeybindingScope.WORKSPACE, [workspaceBinding]);
// now WORKSPACE bindings are overriding the other scopes
let match = keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(workspaceBinding));
expect(match?.kind).to.be.equal('full');
expect(match?.runtime.binding?.command).to.be.equal(workspaceBinding.command);
keybindingRegistry.resetKeybindingsForScope(KeybindingScope.WORKSPACE);
// now it should find USER bindings
match = keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(userBinding));
expect(match?.kind).to.be.equal('full');
expect(match?.runtime.binding?.command).to.be.equal(userBinding.command);
keybindingRegistry.resetKeybindingsForScope(KeybindingScope.USER);
// and finally it should fallback to DEFAULT bindings.
match = keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(defaultBinding));
expect(match?.kind).to.be.equal('full');
expect(match?.runtime.binding?.command).to.be.equal(defaultBinding.command);
keybindingRegistry.resetKeybindingsForScope(KeybindingScope.DEFAULT);
// now the registry should be empty
match = keybindingRegistry.matchKeybinding([keyCode]);
expect(match).to.be.undefined;
});
it('should not match disabled keybindings', () => {
const keyCode = KeyCode.createKeyCode({ first: Key.KEY_A, modifiers: [KeyModifier.Shift] });
const defaultBinding = {
keybinding: keyCode.toString(),
command: 'test.workspace-command'
};
const disableDefaultBinding = {
keybinding: keyCode.toString(),
command: '-test.workspace-command'
};
keybindingRegistry.setKeymap(KeybindingScope.DEFAULT, [defaultBinding]);
let match = keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(defaultBinding));
expect(match?.kind).to.be.equal('full');
expect(match?.runtime.binding?.command).to.be.equal(defaultBinding.command);
keybindingRegistry.setKeymap(KeybindingScope.USER, [disableDefaultBinding]);
match = keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(defaultBinding));
expect(match).to.be.undefined;
keybindingRegistry.resetKeybindingsForScope(KeybindingScope.USER);
match = keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(defaultBinding));
expect(match?.kind).to.be.equal('full');
expect(match?.runtime.binding?.command).to.be.equal(defaultBinding.command);
});
it('should dispatch already-handled compatibility events to capture listeners', () => {
const target = document.createElement('iframe');
document.body.appendChild(target);
const captured = sinon.spy();
document.addEventListener('keydown', captured, true);
const match = sinon.spy(keybindingRegistry, 'matchKeybinding');
keybindingRegistry.dispatchKeyDown({ key: 'a', code: 'KeyA' }, target, true);
expect(captured.calledOnce).to.be.true;
expect(captured.firstCall.args[0].defaultPrevented).to.be.false;
expect(match.called).to.be.false;
document.removeEventListener('keydown', captured, true);
target.remove();
});
it('should dispatch normalized keyboard data directly', () => {
const match = sinon.spy(keybindingRegistry, 'matchKeybinding');
keybindingRegistry.dispatchNormalizedKeyDown({
key: 'a',
code: 'KeyA',
keyCode: 65,
ctrlKey: true
}, new EventTarget());
expect(match.calledOnce).to.be.true;
expect(match.firstCall.args[0][0].dispatchString()).to.equal('ctrl+a');
});
it('should dispatch a DOM keydown for dispatched commands without executing them twice', async () => {
const target = document.createElement('div');
document.body.appendChild(target);
const captured = sinon.spy();
const run = (event) => keybindingRegistry.run(event);
document.addEventListener('keydown', captured, true);
document.addEventListener('keydown', run, true);
const match = sinon.spy(keybindingRegistry, 'matchKeybinding');
const execute = sinon.spy();
const handler = commandRegistry.registerHandler(TEST_COMMAND.id, { execute });
try {
keybindingRegistry.dispatchCommand(TEST_COMMAND.id, target);
await new Promise(resolve => setTimeout(resolve, 0));
expect(captured.calledOnce).to.be.true;
expect(captured.firstCall.args[0].ctrlKey).to.be.true;
expect(execute.calledOnce).to.be.true;
expect(match.calledOnce).to.be.true;
}
finally {
handler.dispose();
document.removeEventListener('keydown', captured, true);
document.removeEventListener('keydown', run, true);
target.remove();
}
});
it('should preserve authored modifiers when dispatching commands through normalized Windows layout modifier data', async () => {
const windows = stubOS('isWindows', true);
testContainer.get(MockKeyboardLayoutChangeNotifier).emitter.fire(deGermanPc);
const dispatch = sinon.spy(keybindingRegistry, 'dispatchNormalizedKeyDown');
const target = document.createElement('div');
const cases = [
{ keybinding: '[', ctrlKey: false, altKey: false },
{ keybinding: 'ctrl+[', ctrlKey: true, altKey: false, inactive: true },
{ keybinding: 'alt+[', ctrlKey: false, altKey: true, inactive: true },
{ keybinding: 'ctrl+alt+[', ctrlKey: true, altKey: true, inactive: true }
];
try {
for (const testCase of cases) {
const binding = { command: TEST_COMMAND_SHADOW.id, keybinding: testCase.keybinding };
keybindingRegistry.setKeymap(KeybindingScope.USER, [binding]);
const execute = sinon.spy();
const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute });
dispatch.resetHistory();
try {
keybindingRegistry.dispatchCommand(TEST_COMMAND_SHADOW.id, target);
await new Promise(resolve => setTimeout(resolve, 0));
if (testCase.inactive) {
// Windows reports AltGr as Ctrl+Alt, so neither command Ctrl nor Alt can accompany an AltGraph character.
expect(keybindingRegistry.isKeybindingInactive(binding)).to.be.true;
expect(dispatch.called).to.be.false;
expect(execute.called).to.be.false;
continue;
}
expect(dispatch.calledOnce).to.be.true;
expect(dispatch.firstCall.args[0]).to.include({
key: '[',
code: 'Digit8',
keyCode: 56,
ctrlKey: testCase.ctrlKey,
altKey: testCase.altKey,
altGraph: true
});
expect(execute.calledOnce).to.be.true;
}
finally {
handler.dispose();
}
}
}
finally {
windows.restore();
}
});
it('should interpret native and transported AltGraph input identically', () => {
testContainer.get(MockKeyboardLayoutChangeNotifier).emitter.fire(deGermanPc);
const native = keybindingRegistry.getKeyCodeInterpretations({
key: '[',
code: 'Digit8',
keyCode: 56,
ctrlKey: true,
getModifierState: modifier => modifier === 'AltGraph'
});
const transported = keybindingRegistry.getKeyCodeInterpretations({
key: '[',
code: 'Digit8',
keyCode: 56,
ctrlKey: true,
altGraph: true
});
expect(transported.map(code => code.dispatchString())).to.deep.equal(native.map(code => code.dispatchString()));
});
it('should log normalized keyboard troubleshooting data when enabled', () => {
const logger = keybindingRegistry.logger;
const info = sinon.spy(logger, 'info');
keybindingRegistry.toggleKeyboardShortcutsTroubleshooting();
keybindingRegistry.dispatchNormalizedKeyDown({
key: '[',
code: 'Digit8',
keyCode: 56,
getModifierState: modifier => modifier === 'AltGraph',
timeStamp: 42
}, new EventTarget());
expect(info.calledTwice).to.be.true;
expect(info.secondCall.args[1].input).to.include({
key: '[',
code: 'Digit8',
altGraph: true,
timeStamp: 42
});
expect(info.secondCall.args[1].layout.source).to.equal('navigator.keyboard');
});
it('should skip composing normalized keyboard data', () => {
const match = sinon.spy(keybindingRegistry, 'matchKeybinding');
keybindingRegistry.dispatchNormalizedKeyDown({
key: 'a',
code: 'KeyA',
keyCode: 65,
isComposing: true
}, new EventTarget());
expect(match.called).to.be.false;
});
it('should exclude inactive bindings and reactivate them after a layout change', () => {
const binding = { command: TEST_COMMAND.id, keybinding: 'ctrl+[' };
keybindingRegistry.setKeymap(KeybindingScope.USER, [binding]);
expect(keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(binding))?.kind).to.equal('full');
const notifier = testContainer.get(MockKeyboardLayoutChangeNotifier);
notifier.emitter.fire({
info: { id: 'missing-bracket', lang: 'en' },
mapping: { KeyA: { value: 'a', withShift: 'A', withAltGr: '', withShiftAltGr: '' } }
});
expect(keybindingRegistry.getKeybindingsForCommand(TEST_COMMAND.id).some(candidate => candidate.keybinding === 'ctrl+[')).to.be.true;
expect(keybindingRegistry.getKeybindingInactiveReason(binding)).to.be.a('string');
expect(keybindingRegistry.matchKeybinding(KeySequence.parse('ctrl+['))).to.be.undefined;
expect(keybindingRegistry.containsKeybindingInScope({ command: TEST_COMMAND2.id, keybinding: 'ctrl+[' })).to.be.false;
notifier.emitter.fire(enUSPc);
expect(keybindingRegistry.getKeybindingInactiveReason(binding)).to.be.undefined;
expect(keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(binding))?.kind).to.equal('full');
});
it('should keep default Latin-letter bindings active on a non-Latin layout', async () => {
const binding = { command: TEST_COMMAND_SHADOW.id, keybinding: 'ctrl+c' };
keybindingRegistry.setKeymap(KeybindingScope.USER, [binding]);
const notifier = testContainer.get(MockKeyboardLayoutChangeNotifier);
notifier.emitter.fire(RUSSIAN_LAYOUT);
const execute = sinon.spy();
const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute });
try {
expect(keybindingRegistry.isKeybindingInactive(binding)).to.be.false;
keybindingRegistry.dispatchNormalizedKeyDown({
key: 'с', code: 'KeyC', ctrlKey: true
}, new EventTarget());
await new Promise(resolve => setTimeout(resolve, 0));
expect(execute.calledOnce).to.be.true;
}
finally {
handler.dispose();
notifier.emitter.fire(enUSPc);
}
});
it('should dispatch a shifted Latin-letter binding on a non-Latin layout', async () => {
const binding = { command: TEST_COMMAND_SHADOW.id, keybinding: 'ctrl+shift+a' };
keybindingRegistry.setKeymap(KeybindingScope.USER, [binding]);
const notifier = testContainer.get(MockKeyboardLayoutChangeNotifier);
notifier.emitter.fire(RUSSIAN_LAYOUT);
const execute = sinon.spy();
const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute });
try {
keybindingRegistry.dispatchNormalizedKeyDown({
key: 'Ф', code: 'KeyA', ctrlKey: true, shiftKey: true
}, new EventTarget());
await new Promise(resolve => setTimeout(resolve, 0));
expect(execute.calledOnce).to.be.true;
}
finally {
handler.dispose();
notifier.emitter.fire(enUSPc);
}
});
it('should dispatch a Shift+punctuation binding from input that reports the base character', async () => {
keybindingRegistry.setKeymap(KeybindingScope.USER, [{ command: TEST_COMMAND_SHADOW.id, keybinding: 'ctrl+shift+`' }]);
const execute = sinon.spy();
const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute });
try {
keybindingRegistry.dispatchNormalizedKeyDown({
key: '`', code: 'Backquote', ctrlKey: true, shiftKey: true
}, new EventTarget());
await new Promise(resolve => setTimeout(resolve, 0));
expect(execute.calledOnce).to.be.true;
}
finally {
handler.dispose();
}
});
it('should keep punctuation bindings inactive on a non-Latin layout', () => {
const binding = { command: TEST_COMMAND.id, keybinding: 'ctrl+[' };
keybindingRegistry.setKeymap(KeybindingScope.USER, [binding]);
const notifier = testContainer.get(MockKeyboardLayoutChangeNotifier);
notifier.emitter.fire(RUSSIAN_LAYOUT);
try {
expect(keybindingRegistry.isKeybindingInactive(binding)).to.be.true;
}
finally {
notifier.emitter.fire(enUSPc);
}
});
it('should execute an authored Shift command modifier on a non-US logical character', async () => {
testContainer.get(MockKeyboardLayoutChangeNotifier).emitter.fire(deGermanPc);
const binding = { command: TEST_COMMAND_SHADOW.id, keybinding: 'ctrl+shift+ü' };
keybindingRegistry.setKeymap(KeybindingScope.USER, [binding]);
const execute = sinon.spy();
const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute });
try {
keybindingRegistry.dispatchNormalizedKeyDown({
key: 'Ü', code: 'BracketLeft', ctrlKey: true, shiftKey: true
}, new EventTarget());
await new Promise(resolve => setTimeout(resolve, 0));
expect(execute.calledOnce).to.be.true;
}
finally {
handler.dispose();
}
});
it('should mark an unmatchable Shift plus AltGraph character binding inactive', async () => {
testContainer.get(MockKeyboardLayoutChangeNotifier).emitter.fire(deGermanPc);
const binding = { command: TEST_COMMAND_SHADOW.id, keybinding: 'ctrl+shift+[char:0x7B]' };
keybindingRegistry.setKeymap(KeybindingScope.USER, [binding]);
const execute = sinon.spy();
const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute });
try {
expect(keybindingRegistry.getKeybindingInactiveReason(binding)).to.be.a('string');
keybindingRegistry.dispatchNormalizedKeyDown({
key: '{', code: 'Digit7', ctrlKey: true, shiftKey: true, altGraph: true
}, new EventTarget());
await new Promise(resolve => setTimeout(resolve, 0));
expect(execute.called).to.be.false;
}
finally {
handler.dispose();
}
});
it('should mark command Alt plus AltGraph character bindings inactive on macOS and Windows', async () => {
const notifier = testContainer.get(MockKeyboardLayoutChangeNotifier);
const binding = { command: TEST_COMMAND_SHADOW.id, keybinding: 'alt+[' };
const execute = sinon.spy();
const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute });
const windows = stubOS('isWindows', false);
const dispatch = async (input) => {
keybindingRegistry.dispatchNormalizedKeyDown(input, new EventTarget());
await new Promise(resolve => setTimeout(resolve, 0));
};
try {
stub.value(true);
notifier.emitter.fire(deGermanMac);
keybindingRegistry.setKeymap(KeybindingScope.USER, [binding]);
expect(keybindingRegistry.getKeybindingInactiveReason(binding)).to.be.a('string');
expect(keybindingRegistry.acceleratorForCommand(TEST_COMMAND_SHADOW.id, undefined, 'physical')).to.deep.equal([]);
await dispatch({ key: '[', code: 'Digit5', altKey: true });
expect(execute.called).to.be.false;
stub.value(false);
windows.value(true);
notifier.emitter.fire(deGermanPc);
keybindingRegistry.setKeymap(KeybindingScope.USER, [binding]);
expect(keybindingRegistry.getKeybindingInactiveReason(binding)).to.be.a('string');
await dispatch({ key: '[', code: 'Digit8', ctrlKey: true, altKey: true });
expect(execute.called).to.be.false;
windows.value(false);
notifier.emitter.fire(deGermanPc);
keybindingRegistry.setKeymap(KeybindingScope.USER, [binding]);
expect(keybindingRegistry.getKeybindingInactiveReason(binding)).to.be.undefined;
await dispatch({ key: '[', code: 'Digit8', altKey: true, altGraph: true });
expect(execute.calledOnce).to.be.true;
}
finally {
windows.restore();
handler.dispose();
notifier.emitter.fire(enUSPc);
}
});
it('should mark command Ctrl plus AltGraph character bindings inactive on Windows', async () => {
const notifier = testContainer.get(MockKeyboardLayoutChangeNotifier);
const binding = { command: TEST_COMMAND_SHADOW.id, keybinding: 'ctrl+[' };
const typed = { command: KeybindingRegistry.PASSTHROUGH_PSEUDO_COMMAND, keybinding: '[' };
const execute = sinon.spy();
const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute });
const windows = stubOS('isWindows', true);
const match = sinon.spy(keybindingRegistry, 'matchKeybinding');
const dispatch = async (input) => {
keybindingRegistry.dispatchNormalizedKeyDown(input, new EventTarget());
await new Promise(resolve => setTimeout(resolve, 0));
};
try {
notifier.emitter.fire(deGermanPc);
keybindingRegistry.setKeymap(KeybindingScope.USER, [binding, typed]);
expect(keybindingRegistry.getKeybindingInactiveReason(binding)).to.be.a('string');
expect(keybindingRegistry.acceleratorForCommand(TEST_COMMAND_SHADOW.id, undefined, 'physical')).to.deep.equal([]);
// Chromium reports Ctrl+AltGr+8 on Windows exactly like AltGr+8, so the input types `[`.
await dispatch({ key: '[', code: 'Digit8', ctrlKey: true, altKey: true, altGraph: true });
expect(execute.called).to.be.false;
const fullMatches = match.returnValues.filter(result => result?.kind === 'full').map(result => result.runtime.binding.keybinding);
expect(fullMatches).to.deep.equal(['[']);
windows.value(false);
notifier.emitter.fire(deGermanPc);
keybindingRegistry.setKeymap(KeybindingScope.USER, [binding]);
expect(keybindingRegistry.getKeybindingInactiveReason(binding)).to.be.undefined;
await dispatch({ key: '[', code: 'Digit8', ctrlKey: true, altGraph: true });
expect(execute.calledOnce).to.be.true;
}
finally {
windows.restore();
handler.dispose();
notifier.emitter.fire(enUSPc);
}
});
it('should route Windows Ctrl+Alt candidates through the registry with and without reported AltGraph', () => {
const windows = stubOS('isWindows', true);
try {
testContainer.get(MockKeyboardLayoutChangeNotifier).emitter.fire(deGermanPc);
const match = sinon.spy(keybindingRegistry, 'matchKeybinding');
const logicalBinding = {
command: KeybindingRegistry.PASSTHROUGH_PSEUDO_COMMAND,
keybinding: '[',
resolved: [new KeyCode({ key: Key.DIGIT8, character: '[', layoutModifiers: 'altGraph' })]
};
for (const altGraph of [true, false]) {
const input = { key: '[', code: 'Digit8', ctrlKey: true, altKey: true, altGraph };
match.resetHistory();
keybindingRegistry.setKeymap(KeybindingScope.USER, [logicalBinding]);
keybindingRegistry.dispatchNormalizedKeyDown(input, new EventTarget());
expect(match.callCount).to.equal(2);
expect(match.secondCall.returnValue?.kind).to.equal('full');
expect(match.secondCall.returnValue?.runtime.binding.keybinding).to.equal('[');
match.resetHistory();
keybindingRegistry.setKeymap(KeybindingScope.USER, [
logicalBinding,
{ command: KeybindingRegistry.PASSTHROUGH_PSEUDO_COMMAND, keybinding: 'ctrl+alt+8' }
]);
keybindingRegistry.dispatchNormalizedKeyDown(input, new EventTarget());
expect(match.callCount).to.equal(2);
expect(match.firstCall.returnValue?.runtime.binding.keybinding).to.equal('ctrl+alt+8');
}
}
finally {
windows.restore();
}
});
it('should prefer a command chord prefix over a layout modifier full match', () => {
const interpretations = sinon.stub(keybindingRegistry, 'getKeyCodeInterpretations').returns([
new KeyCode({ key: Key.KEY_A, ctrl: true, interpretation: 'commandModifiers' }),
new KeyCode({ key: Key.DIGIT8, ctrl: true, layoutModifiers: 'altGraph', interpretation: 'layoutModifiers' })
]);
const commandChord = {
command: KeybindingRegistry.PASSTHROUGH_PSEUDO_COMMAND,
keybinding: 'ctrl+a b'
};
const layoutFull = {
command: KeybindingRegistry.PASSTHROUGH_PSEUDO_COMMAND,
keybinding: 'ctrl+['
};
keybindingRegistry.resolveKeybinding(commandChord).splice(0, 2, ...KeySequence.parse('ctrl+a b'));
keybindingRegistry.resolveKeybinding(layoutFull).splice(0, 1, new KeyCode({ key: Key.DIGIT8, ctrl: true, character: '[', layoutModifiers: 'altGraph' }));
keybindingRegistry.setKeymap(KeybindingScope.USER, [commandChord, layoutFull]);
const event = testKeyboardEvent({ key: '[', code: 'Digit8' });
keybindingRegistry.run(event);
expect(event.defaultPrevented).to.be.true;
expect(keybindingRegistry.keySequenceCandidates).to.have.length(1);
expect(keybindingRegistry.keySequenceCandidates[0][0].interpretation).to.equal('commandModifiers');
interpretations.restore();
});
it('should retain alternative interpretation prefixes across a chord', () => {
const commandPrefix = new KeyCode({ key: Key.KEY_A, ctrl: true, interpretation: 'commandModifiers' });
const layoutPrefix = new KeyCode({ key: Key.DIGIT8, ctrl: true, layoutModifiers: 'altGraph', interpretation: 'layoutModifiers' });
const layoutSecond = new KeyCode({ key: Key.KEY_C, interpretation: 'layoutModifiers' });
const interpretations = sinon.stub(keybindingRegistry, 'getKeyCodeInterpretations');
interpretations.onFirstCall().returns([commandPrefix, layoutPrefix]);
interpretations.onSecondCall().returns([
new KeyCode({ key: Key.KEY_X, interpretation: 'commandModifiers' }),
layoutSecond
]);
const commandBinding = {
command: KeybindingRegistry.PASSTHROUGH_PSEUDO_COMMAND,
keybinding: 'ctrl+a b'
};
const layoutBinding = {
command: KeybindingRegistry.PASSTHROUGH_PSEUDO_COMMAND,
keybinding: 'ctrl+[ c'
};
keybindingRegistry.resolveKeybinding(commandBinding).splice(0, 2, commandPrefix, new KeyCode({ key: Key.KEY_B }));
keybindingRegistry.resolveKeybinding(layoutBinding).splice(0, 2, layoutPrefix, layoutSecond);
keybindingRegistry.setKeymap(KeybindingScope.USER, [commandBinding, layoutBinding]);
keybindingRegistry.run(testKeyboardEvent({ key: '[', code: 'Digit8' }));
expect(keybindingRegistry.keySequenceCandidates).to.have.length(2);
const second = testKeyboardEvent({ key: 'c', code: 'KeyC' });
keybindingRegistry.run(second);
expect(second.defaultPrevented).to.be.false;
expect(keybindingRegistry.keySequenceCandidates).to.deep.equal([[]]);
interpretations.restore();
});
it('should decline equal-priority full matches from different interpretations', () => {
const first = new KeyCode({ key: Key.KEY_A, ctrl: true, interpretation: 'commandModifiers' });
const second = new KeyCode({ key: Key.KEY_B, ctrl: true, interpretation: 'commandModifiers' });
const interpretations = sinon.stub(keybindingRegistry, 'getKeyCodeInterpretations').returns([first, second]);
const troubleshooting = sinon.spy(keybindingRegistry, 'logKeyboardTroubleshooting');
const logger = keybindingRegistry.logger;
const warning = sinon.spy(logger, 'warn');
const firstBinding = { command: KeybindingRegistry.PASSTHROUGH_PSEUDO_COMMAND, keybinding: 'ctrl+a' };
const secondBinding = { command: KeybindingRegistry.PASSTHROUGH_PSEUDO_COMMAND, keybinding: 'ctrl+b' };
keybindingRegistry.resolveKeybinding(firstBinding).splice(0, 1, first);
keybindingRegistry.resolveKeybinding(secondBinding).splice(0, 1, second);
keybindingRegistry.setKeymap(KeybindingScope.USER, [firstBinding, secondBinding]);
keybindingRegistry.run(testKeyboardEvent({ key: 'a', code: 'KeyA' }));
expect(troubleshooting.lastCall.args[3]).to.equal('ambiguous');
expect(troubleshooting.lastCall.args[2]).to.be.undefined;
expect(warning.calledOnce).to.be.true;
keybindingRegistry.run(testKeyboardEvent({ key: 'a', code: 'KeyA' }));
expect(warning.calledOnce).to.be.true;
interpretations.restore();
});
it('should canonicalize layout modifier input for recorder persistence', () => {
const interpretations = sinon.stub(keybindingRegistry, 'getKeyCodeInterpretations').returns([
new KeyCode({ key: Key.DIGIT8, ctrl: true, alt: true, interpretation: 'commandModifiers' }),
new KeyCode({ key: Key.DIGIT8, ctrl: true, character: '[', layoutModifiers: 'altGraph', interpretation: 'layoutModifiers' })
]);
expect(keybindingRegistry.authoredKeyCodeForKeyboardInput({ key: '[', code: 'Digit8' })?.toString()).to.equal('ctrl+[');
interpretations.restore();
});
it('should record the Latin fallback letter on a non-Latin layout', () => {
const notifier = testContainer.get(MockKeyboardLayoutChangeNotifier);
notifier.emitter.fire(RUSSIAN_LAYOUT);
expect(keybindingRegistry.authoredKeyCodeForKeyboardInput({
key: 'с', code: 'KeyC', ctrlKey: true
})?.toAuthoredKeybindingString()).to.equal('ctrl+c');
expect(keybindingRegistry.authoredKeyCodeForKeyboardInput({
key: 'С', code: 'KeyC', ctrlKey: true, shiftKey: true
})?.toAuthoredKeybindingString()).to.equal('shift+ctrl+c');
expect(keybindingRegistry.authoredKeyCodeForKeyboardInput({
key: '€', code: 'KeyE', ctrlKey: true, altGraph: true
})?.toAuthoredKeybindingString()).to.equal('ctrl+€');
expect(keybindingRegistry.authoredKeyCodeForKeyboardInput({
key: 'у', code: 'KeyE', ctrlKey: true
})?.toAuthoredKeybindingString()).to.equal('ctrl+e');
notifier.emitter.fire(enUSPc);
expect(keybindingRegistry.authoredKeyCodeForKeyboardInput({
key: 'c', code: 'KeyC', ctrlKey: true
})?.toAuthoredKeybindingString()).to.equal('ctrl+c');
});
it('should record legacy Windows AltGraph input as its logical character', () => {
const windows = stubOS('isWindows', true);
try {
testContainer.get(MockKeyboardLayoutChangeNotifier).emitter.fire(deGermanPc);
for (const altGraph of [true, false]) {
expect(keybindingRegistry.authoredKeyCodeForKeyboardInput({
key: '[', code: 'Digit8', ctrlKey: true, altKey: true, altGraph
})?.toString()).to.equal('[');
}
}
finally {
windows.restore();
}
});
it('should retain command Shift when layout modifier Shift is not the logical binding', () => {
const interpretations = sinon.stub(keybindingRegistry, 'getKeyCodeInterpretations').returns([
new KeyCode({ key: Key.KEY_P, ctrl: true, character: 'P', layoutModifiers: 'shift', interpretation: 'layoutModifiers' })
]);
expect(keybindingRegistry.authoredKeyCodeForKeyboardInput({ key: 'P', code: 'KeyP' })?.toString()).to.equal('shift+ctrl+p');
interpretations.restore();
});
it('should persist a parseable logical character produced by Shift', () => {
const interpretations = sinon.stub(keybindingRegistry, 'getKeyCodeInterpretations').returns([
new KeyCode({ key: Key.DIGIT7, character: '/', layoutModifiers: 'shift', interpretation: 'layoutModifiers' })
]);
const resolve = sinon.stub(testContainer.get(KeyboardLayoutService), 'resolveKeyCode').callsFake(code => code.key === Key.SLASH
? new KeyCode({ key: Key.DIGIT7, character: '/', layoutModifiers: 'shift' })
: code);
expect(keybindingRegistry.authoredKeyCodeForKeyboardInput({ key: '/', code: 'Digit7' })?.toString()).to.equal('/');
resolve.restore();
interpretations.restore();
});
it('should record newly authorable printable characters logically', () => {
const layoutCode = new KeyCode({ key: Key.SLASH, ctrl: true, character: '?', layoutModifiers: 'shift', interpretation: 'layoutModifiers' });
const interpretations = sinon.stub(keybindingRegistry, 'getKeyCodeInterpretations').returns([layoutCode]);
const recorded = keybindingRegistry.authoredKeyCodeForKeyboardInput({ key: '?', code: 'Slash' });
expect(recorded?.toString()).to.equal('ctrl+?');
expect(keybindingRegistry.resolveKeybinding({ command: TEST_COMMAND.id, keybinding: recorded.toString() })[0].dispatchString())
.to.equal(layoutCode.dispatchString());
interpretations.restore();
});
it('should record logical characters, physical non-printables, and ignore modifier-only input', () => {
const registry = Object.create(KeybindingRegistry.prototype);
registry.authoredKeyCodeForKeyboardInput = input => {
if (input.code === 'ControlLeft') {
return new KeyCode({ ctrl: true });
}
if (input.code === 'F1') {
return new KeyCode({ key: Key.F1, ctrl: true });
}
if (input.code === 'Delete') {
return new KeyCode({ key: Key.DELETE, ctrl: true });
}
if (input.code === 'KeyP') {
return new KeyCode({ key: Key.KEY_P, ctrl: true, shift: true, character: 'P' });
}
return new KeyCode({ key: input.code === 'Equal' ? Key.EQUAL : Key.BRACKET_LEFT, ctrl: true, character: input.key });
};
expect(registry.authoredKeybindingStringForKeyboardInput({ key: '[', code: 'Digit8', ctrlKey: true })).to.equal('ctrl+[');
expect(registry.authoredKeybindingStringForKeyboardInput({ key: '+', code: 'Equal', ctrlKey: true })).to.equal('ctrl+[char:0x2B]');
expect(registry.authoredKeybindingStringForKeyboardInput({ key: 'F1', code: 'F1', ctrlKey: true })).to.equal('ctrl+f1');
expect(registry.authoredKeybindingStringForKeyboardInput({ key: 'Delete', code: 'Delete', ctrlKey: true })).to.equal('ctrl+delete');
const shifted = registry.authoredKeybindingStringForKeyboardInput({ key: 'P', code: 'KeyP', ctrlKey: true, shiftKey: true });
expect(shifted).to.equal('shift+ctrl+p');
expect(KeyCode.parse(shifted).dispatchString()).to.equal('shift+ctrl+p');
expect(registry.authoredKeybindingStringForKeyboardInput({ key: 'Control', code: 'ControlLeft', ctrlKey: true })).to.be.undefined;
});
it('should record Space and numpad keys by name', () => {
expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: ' ', code: 'Space', ctrlKey: true, shiftKey: true }))
.to.equal('shift+ctrl+space');
expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: '+', code: 'NumpadAdd', ctrlKey: true })).to.equal('ctrl+add');
expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: '-', code: 'NumpadSubtract', ctrlKey: true })).to.equal('ctrl+subtract');
expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: '.', code: 'NumpadDecimal', ctrlKey: true })).to.equal('ctrl+decimal');
expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: '1', code: 'Numpad1', ctrlKey: true })).to.equal('ctrl+1');
});
it('should dispatch and record Option bindings as command modifiers on macOS', async () => {
stub.value(true);
const notifier = testContainer.get(MockKeyboardLayoutChangeNotifier);
notifier.emitter.fire(enUSMac);
const execute = sinon.spy();
const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute });
try {
keybindingRegistry.setKeymap(KeybindingScope.USER, [{ command: TEST_COMMAND_SHADOW.id, keybinding: 'shift+alt+p' }]);
keybindingRegistry.run(testKeyboardEvent({ key: '∏', code: 'KeyP', shiftKey: true, altKey: true }));
await new Promise(resolve => setTimeout(resolve, 0));
expect(execute.calledOnce).to.be.true;
expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: '∏', code: 'KeyP', shiftKey: true, altKey: true }))
.to.equal('shift+alt+p');
expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: 'π', code: 'KeyP', altKey: true })).to.equal('alt+p');
expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: 'P', code: 'KeyP', shiftKey: true })).to.equal('shift+p');
}
finally {
handler.dispose();
notifier.emitter.fire(enUSPc);
}
});
it('should dispatch and record dead Option keys as their base character on macOS', async () => {
stub.value(true);
const notifier = testContainer.get(MockKeyboardLayoutChangeNotifier);
notifier.emitter.fire(enUSMac);
const execute = sinon.spy();
const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute });
try {
keybindingRegistry.setKeymap(KeybindingScope.USER, [{ command: TEST_COMMAND_SHADOW.id, keybinding: 'alt+e' }]);
keybindingRegistry.run(testKeyboardEvent({ key: 'Dead', code: 'KeyE', altKey: true }));
await new Promise(resolve => setTimeout(resolve, 0));
expect(execute.calledOnce).to.be.true;
expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: 'Dead', code: 'KeyE', altKey: true })).to.equal('alt+e');
expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: 'Dead', code: 'KeyE', altKey: true, shiftKey: true }))
.to.equal('shift+alt+e');
expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: 'Dead', code: 'KeyE', altKey: true, metaKey: true }))
.to.equal('meta+alt+e');
expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: 'F1', code: 'F1', altKey: true })).to.equal('alt+f1');
keybindingRegistry.setKeymap(KeybindingScope.USER, [{ command: TEST_COMMAND_SHADOW.id, keybinding: 'shift+alt+e' }]);
keybindingRegistry.run(testKeyboardEvent({ key: 'Dead', code: 'KeyE', altKey: true, shiftKey: true }));
await new Promise(resolve => setTimeout(resolve, 0));
expect(execute.calledTwice).to.be.true;
}
finally {
handler.dispose();
notifier.emitter.fire(enUSPc);
}
});
it('should record Caps Lock input with the layout layer case', async () => {
const notifier = testContainer.get(MockKeyboardLayoutChangeNotifier);
const execute = sinon.spy();
const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute });
try {
expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: 'p', code: 'KeyP', ctrlKey: true, shiftKey: true }))
.to.equal('shift+ctrl+p');
notifier.emitter.fire(deGermanPc);
expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: 'ü', code: 'BracketLeft', ctrlKey: true, shiftKey: true }))
.to.equal('ctrl+Ü');
const recorded = keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: 'Ü', code: 'BracketLeft', ctrlKey: true });
expect(recorded).to.equal('ctrl+ü');
keybindingRegistry.setKeymap(KeybindingScope.USER, [{ command: TEST_COMMAND_SHADOW.id, keybinding: recorded }]);
keybindingRegistry.dispatchNormalizedKeyDown({ key: 'ü', code: 'BracketLeft', ctrlKey: true }, new EventTarget());
await new Promise(resolve => setTimeout(resolve, 0));
expect(execute.calledOnce).to.be.true;
notifier.emitter.fire({
info: { id: 'altgraph-letters', lang: 'pl' },
mapping: { KeyL: { value: 'l', withShift: 'L', withAltGr: 'ł', withShiftAltGr: 'Ł' } }
});
expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: 'Ł', code: 'KeyL', ctrlKey: true, altGraph: true }))
.to.equal('ctrl+ł');
stub.value(true);
notifier.emitter.fire(deGermanMac);
expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: 'Å', code: 'KeyA', altKey: true })).to.equal('alt+a');
}
finally {
handler.dispose();
notifier.emitter.fire(enUSPc);
}
});
it('should classify interpretation shadowing separately from canonical collisions', () => {
const logical = {
command: TEST_COMMAND.id,
keybinding: 'ctrl+[',
resolved: [new KeyCode({ key: Key.DIGIT8, ctrl: true, character: '[', layoutModifiers: 'altGraph' })]
};
const command = { command: TEST_COMMAND2.id, keybinding: 'ctrl+alt+8' };
keybindingRegistry.setKeymap(KeybindingScope.USER, [logical, command]);
const diagnostics = keybindingRegistry.getKeybindingCollisionDiagnostics(logical);
expect(diagnostics.shadowedBy.map(binding => binding.command)).to.include(TEST_COMMAND2.id);
expect(diagnostics.authored.full).to.be.empty;
expect(diagnostics.layoutDerived.full).to.be.empty;
expect(keybindingRegistry.containsKeybindingInScope(logical)).to.be.false;
});
it('should keep shifted printable bindings symmetric in keyCode dispatch mode', () => {
corePreferences['keyboard.dispatch'] = 'keyCode';
const commandPalette = { command: TEST_COMMAND.id, keybinding: 'ctrl+shift+p' };
const shiftedPrintable = { command: TEST_COMMAND2.id, keybinding: 'shift+/' };
keybindingRegistry.setKeymap(KeybindingScope.USER, [commandPalette, shiftedPrintable]);
expect(keybindingRegistry.matchKeybinding(KeySequence.parse('ctrl+shift+p'))?.runtime.binding.command).to.equal(TEST_COMMAND.id);
expect(keybindingRegistry.matchKeybinding(KeySequence.parse('shift+/'))?.runtime.binding.command).to.equal(TEST_COMMAND2.id);
});
it('should mark character-only bindings inactive in keyCode dispatch mode', () => {
corePreferences['keyboard.dispatch'] = 'keyCode';
const characterOnly = { command: TEST_COMMAND.id, keybinding: 'ctrl+ü' };
const positional = { command: TEST_COMMAND2.id, keybinding: 'ctrl+[' };
keybindingRegistry.setKeymap(KeybindingScope.USER, [characterOnly, positional]);
expect(keybindingRegistry.getKeybindingInactiveReason(characterOnly)).to.be.a('string');
expect(keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(characterOnly))).to.be.undefined;
expect(keybindingRegistry.getKeybindingInactiveReason(positional)).to.be.undefined;
expect(keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(positional))?.kind).to.equal('full');
});
it('should require resolved sequences for logical matching in code dispatch mode', () => {
testContainer.get(MockKeyboardLayoutChangeNotifier).emitter.fire(enUSPc);
const binding = { command: TEST_COMMAND.id, keybinding: 'ctrl+shift+a' };
keybindingRegistry.setKeymap(KeybindingScope.USER, [binding]);
expect(KeySequence.parse('ctrl+shift+a')[0].dispatchString()).to.equal('shift+ctrl+a');
expect(keybindingRegistry.resolveKeybinding(binding)[0].dispatchString()).to.equal('ctrl+a@shift');
expect(keybindingRegistry.matchKeybinding(KeySequence.parse('ctrl+shift+a'))).to.be.undefined;
expect(keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(binding))?.kind).to.equal('full');
});
it('should invalidate resolved bindings when keyboard dispatch changes', () => {
const binding = { command: TEST_COMMAND.id, keybinding: 'ctrl+[' };
keybindingRegistry.setKeymap(KeybindingScope.USER, [binding]);
expect(keybindingRegistry.getKeybindingInactiveReason(binding)).to.be.undefined;
const changed = sinon.spy();
keybindingRegistry.onKeybindingsChanged(changed);
corePreferences['keyboard.dispatch'] = 'keyCode';
preferenceChanged.fire({ preferenceName: 'keyboard.dispatch' });
expect(changed.calledOnce).to.be.true;
expect(keybindingRegistry.resolveKeybinding(binding)[0].dispatchString()).to.equal('ctrl+[');
expect(keybindingRegistry.matchKeybinding(KeySequence.parse('ctrl+['))?.kind).to.equal('full');
});
it('should prioritize bindings that use local context keys', () => {
// Ensure JSDOM is enabled for this test since it uses document
const disable = enableJSDOM();
const keyCode = KeyCode.createKeyCode({ first: Key.KEY_A, modifiers: [KeyModifier.Shift] });
// Register two commands with the same keybinding but different when clauses
const globalBinding = {
keybinding: keyCode.toString(),
command: 'test.global-command',
when: 'globalContextKey'
};
const localBinding = {
keybinding: keyCode.toString(),
command: 'test.local-command',
when: 'localContextKey'
};
// Register commands with handlers so they are enabled
commandRegistry.registerCommand({ id: 'test.global-command' }, { execute: () => { } });
commandRegistry.registerCommand({ id: 'test.local-command' }, { execute: () => { } });
// globalBinding is registered first, so without local context prioritization it would win
keybindingRegistry.setKeymap(KeybindingScope.DEFAULT, [globalBinding, localBinding]);
// Get the mock context key service
const contextKeyService = testContainer.get(ContextKeyService);
// Set up mock to return 'localContextKey' as a local key
contextKeyService.setLocalContextKeys(new Set(['localContextKey']));
// Both when clauses should match
contextKeyService.setMatchResult(true);
// Create a mock keyboard event with a target element
const targetElement = document.createElement('div');
const mockEvent = new KeyboardEvent('keydown', {
key: 'A',
shiftKey: true
});
Object.defineProperty(mockEvent, 'target', { value: targetElement });
const match = keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(localBinding), mockEvent);
// The localBinding should be selected because it uses a local context key
expect(match?.kind).to.be.equal('full');
expect(match?.runtime.binding?.command).to.be.equal('test.local-command');
disable();
});
it('should fall back to first binding when no local context keys exist', () => {
// Ensure JSDOM is enabled for this test since it uses document
const disable = enableJSDOM();
const keyCode = KeyCode.createKeyCode({ first: Key.KEY_B, modifiers: [KeyModifier.Shift] });
const firstBinding = {
keybinding: keyCode.toString(),
command: 'test.first-command',
when: 'someContextKey'
};
const secondBinding = {
keybinding: keyCode.toString(),
command: 'test.second-command',
when: 'otherContextKey'
};
commandRegistry.registerCommand({ id: 'test.first-command' }, { execute: () => { } });
commandRegistry.registerCommand({ id: 'test.second-command' }, { execute: () => { } });
// Note: bindings registered later (later in the array) have higher priority
// because insertBindingIntoScope inserts them at the front of the scope's keymap
keybindingRegistry.setKeymap(KeybindingScope.DEFAULT, [firstBinding, secondBinding]);
const contextKeyService = testContainer.get(ContextKeyService);
// No local context keys
contextKeyService.setLocalContextKeys(new Set());
contextKeyService.setMatchResult(true);
const targetElement = document.createElement('div');
const mockEvent = new KeyboardEvent('keydown', {
key: 'B',
shiftKey: true
});
Object.defineProperty(mockEvent, 'target', { value: targetElement });
const match = keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(secondBinding), mockEvent);
// Should fall back to first enabled binding in priority order (secondBinding was registered later, so it wins)
expect(match?.kind).to.be.equal('full');
expect(match?.runtime.binding?.command).to.be.equal('test.second-command');
disable();
});
});
describe('keybindings displayed for a command', () => {
let displayedBinding;
beforeEach(() => {
displayedBinding = {
command: KeybindingRegistry.PASSTHROUGH_PSEUDO_COMMAND,
keybinding: 'ctrl+v',
displayFor: TEST_COMMAND_SHADOW.id
};
keybindingRegistry.registerKeybinding(displayedBinding);
});
it('should show a passthrough keybinding as the accelerator of the command it is displayed for', () => {
const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute: () => { } });
try {
expect(keybindingRegistry.acceleratorForCommand(TEST_COMMAND_SHADOW.id, undefined)).to.deep.equal(['Ctrl+V']);
}
finally {
handler.dispose();
}
});
it('should not show a displayed keybinding for a disabled command', () => {
const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute: () => { }, isEnabled: () => false });
try {
expect(keybindingRegistry.acceleratorForCommand(TEST_COMMAND_SHADOW.id, undefined)).to.deep.equal([]);
}
finally {
handler.dispose();
}
});
it('should not fall back to a displayed keybinding when the command is disabled but has its own keybinding', () => {
const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute: () => { }, isEnabled: () => false });
keybindingRegistry.registerKeybinding({
command: TEST_COMMAND_SHADOW.id,
keybinding: 'ctrl+shift+v'
});
try {
expect(keybindingRegistry.acceleratorForCommand(TEST_COMMAND_SHADOW.id, undefined)).to.deep.equal([]);
}
finally {
handler.dispose();
}
});
it('should not return a displayed keybinding as a keybinding of the command', () => {
expect(keybindingRegistry.getKeybindingsForCommand(TEST_COMMAND_SHADOW.id)).to.be.empty;
});
it('should let the key pass through instead of executing the command it is displayed for', () => {
const execute = sinon.spy();
const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute });
try {
expect(keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(displayedBinding))?.runtime.binding?.command)
.to.equal(KeybindingRegistry.PASSTHROUGH_PSEUDO_COMMAND);
const event = testKeyboardEvent({ key: 'v', code: 'KeyV', keyCode: 86, ctrlKey: true });
keybindingRegistry.run(event);
expect(execute.called).to.be.false;
expect(event.defaultPrevented).to.be.false;
}
finally {
handler.dispose();
}
});
it('should prefer a keybinding that executes the command over a displayed one', () => {
const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute: () => { } });
keybindingRegistry.registerKeybinding({
command: TEST_COMMAND_SHADOW.id,
keybinding: 'ctrl+shift+v'
});
try {
expect(keybindingRegistry.acceleratorForCommand(TEST_COMMAND_SHADOW.id, undefined)).to.deep.equal(['Ctrl+Shift+V']);
}
finally {
handler.dispose();
}
});
it('should not show a displayed keybinding that the user disabled', () => {
const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute: () => { } });
keybindingRegistry.setKeymap(KeybindingScope.USER, [{
command: '-' + KeybindingRegistry.PASSTHROUGH_PSEUDO_COMMAND,
keybinding: 'ctrl+v'
}]);
try {
expect(keybindingRegistry.acceleratorForCommand(TEST_COMMAND_SHADOW.id, undefined)).to.deep.equal([]);
}
finally {
handler.dispose();
}
});
});
describe('acceleratorForKeyCode', () => {
const ctrlV = KeyCode.createKeyCode({ key: Key.KEY_V, ctrl: true });
const metaV = KeyCode.createKeyCode({ key: Key.KEY_V, meta: true });
it('uses ASCII names with the separator on non-macOS', () => {
stub.value(false);
const accelerator = keybindingRegistry.acceleratorForKeyCode(ctrlV, '+');
expect(accelerator).to.equal('Ctrl+V');
});
it('uses macOS symbols without a separator on macOS browser', () => {
stub.value(true);
const accelerator = keybindingRegistry.acceleratorForKeyCode(metaV, '+');
expect(accelerator).to.equal('⌘V');
});
it('separates logical labels from physical layout modifier realizations', () => {
const logicalBracket = new KeyCode({
key: Key.DIGIT8,
ctrl: true,
character: '[',
layoutModifiers: 'altGraph'
});
const logicalSlash = new KeyCode({
key: Key.DIGIT7,
character: '/',
layoutModifiers: 'shift'
});
expect(keybindingRegistry.componentsForKeyCode(logicalBracket)).to.deep.equal(['Ctrl', '[']);
expect(keybindingRegistry.componentsForKeyCode(logicalBracket, false, 'physical')).to.deep.equal(['Ctrl', 'AltGr', '8']);
expect(keybindingRegistry.acceleratorForKeyCode(logicalBracket, '+', true, 'physical')).to.equal('Ctrl+AltGr+8');
expect(keybindingRegistry.componentsForKeyCode(logicalSlash)).to.deep.equal(['/']);
expect(keybindingRegistry.componentsForKeyCode(logicalSlash, false, 'physical')).to.deep.equal(['Shift', '7']);
expect(keybindingRegistry.acceleratorForKeyCode(logicalSlash, '+', true, 'physical')).to.equal('Shift+7');
});
it('keeps command Shift in physical realizations', () => {
const commandShift = new KeyCode({ key: Key.TAB, ctrl: true, shift: true });
expect(keybindingRegistry.componentsForKeyCode(commandShift, false, 'physical')).to.deep.equal(['Ctrl', 'Shift', 'Tab']);
const shiftedLetter = new KeyCode({ key: Key.KEY_P, ctrl: true, character: 'P', layoutModifiers: 'shift' });
expect(keybindingRegistry.componentsForKeyCode(shiftedLetter)).to.deep.equal(['Ctrl', 'Shift', 'P']);
const unresolvedCharacter = new KeyCode({ ctrl: true, character: '§', supportedByLayout: false });
expect(keybindingRegistry.componentsForKeyCode(unresolvedCharacter)).to.deep.equal(['Ctrl', '§']);
});
it('deduplicates command Alt and layout modifier Option on macOS', () => {
stub.value(true);
const commandAndLayoutOption = new KeyCode({
key: Key.DIGIT6,
meta: true,
ctrl: true,
alt: true,
layoutModifiers: 'altGraph'
});
const layoutOption = new KeyCode({ key: Key.DIGIT6, layoutModifiers: 'altGraph' });
expect(keybindingRegistry.componentsForKeyCode(commandAndLayoutOption, false, 'physical')).to.deep.equal(['⌘', '⌃', '⌥', '6']);
expect(keybindingRegistry.componentsForKeyCode(commandAndLayoutOption, true, 'physical')).to.deep.equal(['Cmd', 'Ctrl', 'Alt', '6']);
expect(keybindingRegistry.componentsForKeyCode(layoutOption, false, 'physical')).to.deep.equal(['⌥', '6']);
expect(keybindingRegistry.componentsForKeyCode(layoutOption, true, 'physical')).to.deep.equal(['Option', '6']);
});
it('uses ASCII names with the separator on macOS Electron (asciiOnly)', () => {
stub.value(true);
const accelerator = keybindingRegistry.acceleratorForKeyCode(metaV, '+', true);
expect(accelerator).to.equal('Cmd+V');
});
});
const TEST_COMMAND = {
id: 'test.command'
};
const TEST_COMMAND2 = {
id: 'test.command2'
};
const TEST_COMMAND_SHADOW = {
id: 'test.command-shadow'
};
let MockContextKeyService = class MockContextKeyService extends ContextKeyServiceDummyImpl {
constructor() {
super();
this.localKeys = new Set();
this.shouldMatch = true;
this.parsedKeys = new Map();
// Set up default parsed keys for test expressions
this.parsedKeys.set('globalContextKey', new Set(['globalContextKey']));
this.parsedKeys.set('localContextKey', new Set(['localContextKey']));
this.parsedKeys.set('someContextKey', new Set(['someContextKey']));
this.parsedKeys.set('otherContextKey', new Set(['otherContextKey']));
}
setLocalContextKeys(keys) {
this.localKeys = keys;
}
setMatchResult(result) {
this.shouldMatch = result;
}
match(expression, context) {
return this.shouldMatch;
}
parseKeys(expression) {
return this.parsedKeys.get(expression) || new Set([expression]);
}
getLocalContextKeys(element) {
return this.localKeys;
}
createOverlay(overlay) {
return this;
}
};
MockContextKeyService = __decorate([
injectable()
], MockContextKeyService);
let MockKeyboardLayoutProvider = class MockKeyboardLayoutProvider {
getNativeLayout() {
return Promise.resolve(enUSPc);
}
};
MockKeyboardLayoutProvider = __decorate([
injectable()
], MockKeyboardLayoutProvider);
let MockKeyboardLayoutChangeNotifier = class MockKeyboardLayoutChangeNotifier {
constructor() {
this.emitter = new Emitter();
}
get onDidChangeNativeLayout() {
return this.emitter.event;
}
};
MockKeyboardLayoutChangeNotifier = __decorate([
injectable()
], MockKeyboardLayoutChangeNotifier);
let TestContribution = class TestContribution {
registerCommands(commands) {
commands.registerCommand(TEST_COMMAND);
commands.registerCommand(TEST_COMMAND2);
commands.registerCommand(TEST_COMMAND_SHADOW);
}
registerKeybindings(keybindings) {
[{
command: TEST_COMMAND.id,
context: 'testContext',
keybinding: 'ctrl+a'
},
{
command: TEST_COMMAND2.id,
context: 'testContext',
keybinding: 'ctrl+f1'
},
{
command: TEST_COMMAND2.id,
context: 'testContext',
keybinding: 'ctrl+f2'
},
].forEach(binding => {
keybindings.registerKeybinding(binding);
});
}
};
TestContribution = __decorate([
injectable()
], TestContribution);
function isKeyBindingRegistered(keybinding) {
const bindings = keybindingRegistry.getKeybindingsForCommand(keybinding.command);
expect(bindings).not.to.be.undefined;
let keyBindingFound = false;
bindings.forEach((value) => {
if (value.command === keybinding.command && value.keybinding === keybinding.keybinding) {
keyBindingFound = true;
}
});
return keyBindingFound;
}
//# sourceMappingURL=keybinding.spec.js.map