@theia/core
Version:
Theia is a cloud & desktop IDE framework implemented in TypeScript.
705 lines • 43.2 kB
JavaScript
// *****************************************************************************
// Copyright (C) 2019 TypeFox 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 { Container, injectable } from 'inversify';
import { Emitter } from '../../common/event.js';
import { Key, KeyCode } from './keys.js';
import { KeyboardLayoutService } from './keyboard-layout-service.js';
import { KeyboardLayoutProvider, KeyboardLayoutChangeNotifier, KeyValidator } from '../../common/keyboard/keyboard-layout-provider.js';
import * as chai from 'chai';
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 frFrenchMacLayout from '../../common/keyboard/layouts/fr-French-mac.json' with { type: 'json' };
import frFrenchPcLayout from '../../common/keyboard/layouts/fr-French-pc.json' with { type: 'json' };
import deSwissGermanPcLayout from '../../common/keyboard/layouts/de-Swiss_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 frBepoPcLayout from '../../common/keyboard/layouts/fr-Bepo-pc.json' with { type: 'json' };
import { stubOS } from '../../common/test/stub-os.js';
class TestKeyboardLayoutService extends KeyboardLayoutService {
getWindowsKeyCodeInterpretations(keyCode, input, layoutModifiers) {
return super.getWindowsKeyCodeInterpretations(keyCode, input, layoutModifiers);
}
}
const RUSSIAN_LAYOUT = {
info: { id: 'ru', lang: 'ru' },
mapping: {
KeyA: { value: 'ф', withShift: 'Ф', withAltGr: '', withShiftAltGr: '' },
KeyC: { 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: '' }
}
};
const deGermanMac = deGermanMacLayout;
const deGermanPc = deGermanPcLayout;
const frFrenchMac = frFrenchMacLayout;
const frFrenchPc = frFrenchPcLayout;
const deSwissGermanPc = deSwissGermanPcLayout;
const enUSMac = enUSMacLayout;
const enUSPc = enUSPcLayout;
const frBepoPc = frBepoPcLayout;
describe('keyboard layout service', function () {
let stubOSX;
let stubWindows;
const setup = async (layout, system, layoutSource, keyValidator) => {
switch (system) {
case 'mac':
stubOSX = stubOS('isOSX', true);
stubWindows = stubOS('isWindows', false);
break;
case 'win':
stubOSX = stubOS('isOSX', false);
stubWindows = stubOS('isWindows', true);
break;
default:
stubOSX = stubOS('isOSX', false);
stubWindows = stubOS('isWindows', false);
}
const container = new Container();
container.bind(KeyboardLayoutService).to(TestKeyboardLayoutService).inSingletonScope();
let MockLayoutProvider = class MockLayoutProvider {
constructor() {
this.layoutSource = layoutSource;
this.emitter = new Emitter();
}
get onDidChangeNativeLayout() {
return this.emitter.event;
}
getNativeLayout() {
return Promise.resolve(layout);
}
};
MockLayoutProvider = __decorate([
injectable()
], MockLayoutProvider);
container.bind(KeyboardLayoutProvider).to(MockLayoutProvider);
container.bind(KeyboardLayoutChangeNotifier).to(MockLayoutProvider);
if (keyValidator) {
container.bind(KeyValidator).toConstantValue(keyValidator);
}
const service = container.get(KeyboardLayoutService);
await service.initialize();
return service;
};
afterEach(() => {
stubOSX.restore();
stubWindows.restore();
});
it('reports an unknown layout source when no source provider is configured', async () => {
const layout = { info: { id: 'mock', lang: 'en' }, mapping: {} };
chai.expect((await setup(layout, 'linux')).layoutSource).to.equal('unknown');
});
it('reports the configured layout source', async () => {
const layout = { info: { id: 'mock', lang: 'en' }, mapping: {} };
chai.expect((await setup(layout, 'linux', 'native-keymap')).layoutSource).to.equal('native-keymap');
});
it('resolves correct key bindings with German Mac layout', async () => {
const macGerman = deGermanMac;
const service = await setup(macGerman, 'mac');
const toggleComment = service.resolveKeyCode(KeyCode.createKeyCode('Slash+M1'));
chai.expect(toggleComment.toString()).to.equal('meta+7');
chai.expect(toggleComment.character).to.equal('/');
chai.expect(toggleComment.layoutModifiers).to.deep.equal('shift');
chai.expect(service.getKeyboardCharacter(toggleComment.key)).to.equal('7');
const indentLine = service.resolveKeyCode(KeyCode.createKeyCode('BracketRight+M1'));
chai.expect(indentLine.toString()).to.equal('meta+6');
chai.expect(indentLine.character).to.equal(']');
chai.expect(indentLine.layoutModifiers).to.deep.equal('altGraph');
chai.expect(service.getKeyboardCharacter(indentLine.key)).to.equal('6');
});
it('resolves correct key bindings with French Mac layout', async () => {
const macFrench = frFrenchMac;
const service = await setup(macFrench, 'mac');
const toggleComment = service.resolveKeyCode(KeyCode.createKeyCode('Slash+M1'));
chai.expect(toggleComment.toString()).to.equal('meta+.');
chai.expect(toggleComment.character).to.equal('/');
chai.expect(toggleComment.layoutModifiers).to.deep.equal('shift');
chai.expect(service.getKeyboardCharacter(toggleComment.key)).to.equal(':');
const indentLine = service.resolveKeyCode(KeyCode.createKeyCode('BracketRight+M1'));
chai.expect(indentLine.toString()).to.equal('meta+-');
chai.expect(indentLine.character).to.equal(']');
chai.expect(indentLine.layoutModifiers).to.deep.equal('shiftAltGraph');
chai.expect(service.getKeyboardCharacter(indentLine.key)).to.equal(')');
});
it('uses global layout modifier priority and a stable physical-key tie-break', async () => {
const layout = {
info: { id: 'priority', lang: 'fr' },
mapping: {
Backslash: { value: '*', withShift: 'µ', withAltGr: '@', withShiftAltGr: '#' },
IntlBackslash: { value: '@', withShift: '#', withAltGr: 'µ', withShiftAltGr: '*' },
KeyB: { value: 'x', withShift: 'X', withAltGr: '', withShiftAltGr: '' },
KeyA: { value: 'x', withShift: 'X', withAltGr: '', withShiftAltGr: '' }
}
};
const service = await setup(layout, 'linux');
chai.expect(service.resolveKeyCode(KeyCode.parse('shift+2')).key).to.equal(Key.INTL_BACKSLASH);
chai.expect(service.resolveKeyCode(KeyCode.parse('x')).key).to.equal(Key.KEY_A);
const shifted = service.resolveKeyCode(KeyCode.parse('shift+x'));
const event = service.getKeyCodeInterpretations({ key: 'X', code: 'KeyA', shiftKey: true }, 'code')
.find(candidate => candidate.interpretation === 'layoutModifiers');
chai.expect(event.dispatchString()).to.equal(shifted.dispatchString());
const altShifted = service.resolveKeyCode(KeyCode.parse('alt+shift+x'));
const altEvent = service.getKeyCodeInterpretations({ key: 'X', code: 'KeyA', altKey: true, shiftKey: true }, 'code')
.find(candidate => candidate.interpretation === 'layoutModifiers');
chai.expect(altEvent.dispatchString()).to.equal(altShifted.dispatchString());
const capsLockEvent = service.getKeyCodeInterpretations({ key: 'x', code: 'KeyA', shiftKey: true }, 'code')
.find(candidate => candidate.interpretation === 'layoutModifiers');
chai.expect(capsLockEvent.dispatchString()).to.equal(shifted.dispatchString());
});
it('globally ranks case-folded fallback candidates', async () => {
const layout = {
info: { id: 'case-folded-priority', lang: 'en' },
mapping: {
KeyA: { value: 'a', withShift: 'A', withAltGr: 'ä', withShiftAltGr: '' },
KeyB: { value: 'b', withShift: 'ä', withAltGr: '', withShiftAltGr: '' }
}
};
const service = await setup(layout, 'linux');
const resolved = service.resolveKeyCode(KeyCode.parse('[char:0xC4]'));
chai.expect(resolved.key).to.equal(Key.KEY_B);
chai.expect(resolved.layoutModifiers).to.deep.equal('shift');
});
it('matches shifted physical scan-code bindings through the command interpretation', async () => {
const us = enUSPc;
const service = await setup(us, 'linux');
const physical = service.resolveKeyCode(KeyCode.parse('ctrl+shift+[BracketRight]'));
const interpretations = service.getKeyCodeInterpretations({
key: '}', code: 'BracketRight', ctrlKey: true, shiftKey: true
}, 'code');
chai.expect(physical.physical).to.be.true;
chai.expect(interpretations.some(candidate => candidate.dispatchString() === physical.dispatchString())).to.be.true;
});
it('keeps BÉPO logical bindings distinct from their former US-position collisions', async () => {
const bepo = frBepoPc;
const service = await setup(bepo, 'linux');
const undo = service.resolveKeyCode(KeyCode.parse('ctrl+z'));
const outdent = service.resolveKeyCode(KeyCode.parse('ctrl+['));
const close = service.resolveKeyCode(KeyCode.parse('ctrl+w'));
const indent = service.resolveKeyCode(KeyCode.parse('ctrl+]'));
chai.expect(undo.key).to.equal(Key.BRACKET_LEFT);
chai.expect(outdent.key).to.equal(Key.DIGIT4);
chai.expect(outdent.layoutModifiers).to.equal('altGraph');
chai.expect(close.key).to.equal(Key.BRACKET_RIGHT);
chai.expect(indent.key).to.equal(Key.DIGIT5);
chai.expect(indent.layoutModifiers).to.equal('altGraph');
});
it('falls back to the US position for Latin letters missing from a non-Latin layout', async () => {
const service = await setup(RUSSIAN_LAYOUT, 'linux');
const resolved = service.resolveKeyCode(KeyCode.parse('ctrl+c'));
chai.expect(resolved.key).to.equal(Key.KEY_C);
chai.expect(resolved.supportedByLayout).to.be.true;
chai.expect(resolved.layoutModifiers).to.equal('none');
chai.expect(resolved.dispatchString()).to.equal('ctrl+c');
chai.expect(service.getLatinLetterFallback(Key.KEY_C)).to.equal('c');
chai.expect(service.getLatinLetterFallback(Key.DIGIT8)).to.be.undefined;
chai.expect(service.resolveKeyCode(KeyCode.parse('с')).key).to.equal(Key.KEY_C);
chai.expect(service.getKeyboardCharacter(Key.KEY_C)).to.equal('с');
});
it('absorbs Shift into the Latin fallback letter', async () => {
const service = await setup(RUSSIAN_LAYOUT, 'linux');
const resolved = service.resolveKeyCode(KeyCode.parse('ctrl+shift+a'));
chai.expect(resolved.key).to.equal(Key.KEY_A);
chai.expect(resolved.layoutModifiers).to.equal('shift');
chai.expect(resolved.shift).to.be.false;
chai.expect(resolved.character).to.equal('A');
});
it('does not fall back for punctuation on a non-Latin layout', async () => {
const service = await setup(RUSSIAN_LAYOUT, 'linux');
chai.expect(service.resolveKeyCode(KeyCode.parse('ctrl+[')).supportedByLayout).to.be.false;
});
it('does not override Latin letters produced elsewhere on the layout', async () => {
const german = deGermanPc;
const service = await setup(german, 'linux');
chai.expect(service.resolveKeyCode(KeyCode.parse('ctrl+z')).key).to.equal(Key.KEY_Y);
chai.expect(service.getLatinLetterFallback(Key.KEY_Z)).to.be.undefined;
});
it('does not override letters produced in only one case on the base or Shift layer', async () => {
const layout = {
info: { id: 'one-case-only', lang: 'en' },
mapping: {
KeyS: { value: 'o', withShift: 'Q', withAltGr: '', withShiftAltGr: '' },
KeyO: { value: 's', withShift: 'P', withAltGr: '', withShiftAltGr: '' }
}
};
const service = await setup(layout, 'linux');
chai.expect(service.resolveKeyCode(KeyCode.parse('o')).key).to.equal(Key.KEY_S);
chai.expect(service.resolveKeyCode(KeyCode.parse('p')).key).to.equal(Key.KEY_O);
chai.expect(service.resolveKeyCode(KeyCode.parse('p')).layoutModifiers).to.equal('shift');
for (const key of [Key.KEY_O, Key.KEY_P, Key.KEY_Q, Key.KEY_S]) {
chai.expect(service.getLatinLetterFallback(key)).to.be.undefined;
}
});
it('adds a fallback when a letter is produced only on the AltGraph layer', async () => {
const layout = {
info: { id: 'altgraph-only-latin', lang: 'ru' },
mapping: {
KeyQ: { value: 'й', withShift: 'Й', withAltGr: 'a', withShiftAltGr: '' }
}
};
const service = await setup(layout, 'linux');
const resolved = service.resolveKeyCode(KeyCode.parse('a'));
chai.expect(resolved.key).to.equal(Key.KEY_A);
chai.expect(resolved.layoutModifiers).to.equal('none');
chai.expect(service.getLatinLetterFallback(Key.KEY_A)).to.equal('a');
});
it('adds Latin fallbacks to Windows mappings with vkeys and character values', async () => {
const layout = {
...RUSSIAN_LAYOUT,
mapping: {
...RUSSIAN_LAYOUT.mapping,
KeyC: { ...RUSSIAN_LAYOUT.mapping.KeyC, vkey: 'VK_C' }
}
};
const service = await setup(layout, 'win');
chai.expect(service.resolveKeyCode(KeyCode.parse('ctrl+c')).key).to.equal(Key.KEY_C);
chai.expect(service.getLatinLetterFallback(Key.KEY_C)).to.equal('c');
});
it('marks printable bindings unresolved when the layout mapping is empty', async () => {
const layout = { info: { id: 'empty', lang: 'en' }, mapping: {} };
const service = await setup(layout, 'linux');
chai.expect(service.resolveKeyCode(KeyCode.parse('ctrl+[')).supportedByLayout).to.be.false;
for (const lower of 'abcdefghijklmnopqrstuvwxyz') {
const key = Key.getKey(`Key${lower.toUpperCase()}`);
chai.expect(service.resolveKeyCode(KeyCode.parse(`ctrl+${lower}`)).key).to.equal(key);
chai.expect(service.getLatinLetterFallback(key)).to.equal(lower);
}
chai.expect(service.resolveKeyCode(KeyCode.parse('f1')).supportedByLayout).to.be.true;
});
it('marks unavailable logical characters unresolved instead of using the US position', async () => {
const layout = {
info: { id: 'missing-bracket', lang: 'en' },
mapping: {
KeyA: { value: 'a', withShift: 'A', withAltGr: '', withShiftAltGr: '' }
}
};
const service = await setup(layout, 'linux');
const outdent = service.resolveKeyCode(KeyCode.parse('ctrl+['));
chai.expect(outdent.supportedByLayout).to.be.false;
chai.expect(outdent.key).to.equal(Key.BRACKET_LEFT);
});
it('does not let a dead key hijack a keybinding on Mac (#17677)', async () => {
// On macOS US Extended, Option+P is the "combining comma below" dead key whose display glyph
// is reported as ',' by native-keymap. Since KeyP is reported before Comma, without honoring the
// dead-key flags it would claim the ',' slot and resolve ctrlcmd+, to Cmd+Ctrl+Option+P.
const macUSExtended = {
info: { id: 'com.apple.keylayout.USExtended', lang: 'en' },
mapping: {
KeyP: {
value: 'p', valueIsDeadKey: false,
withShift: 'P', withShiftIsDeadKey: false,
withAltGr: ',', withAltGrIsDeadKey: true,
withShiftAltGr: '̦', withShiftAltGrIsDeadKey: true
},
Comma: {
value: ',', valueIsDeadKey: false,
withShift: '<', withShiftIsDeadKey: false,
withAltGr: '≤', withAltGrIsDeadKey: false,
withShiftAltGr: '¯', withShiftAltGrIsDeadKey: false
}
}
};
const service = await setup(macUSExtended, 'mac');
const openSettings = service.resolveKeyCode(KeyCode.createKeyCode('Comma+M1'));
chai.expect(openSettings.toString()).to.equal('meta+,');
chai.expect(service.getKeyboardCharacter(openSettings.key)).to.equal(',');
});
it('filters dead AltGraph mappings on Linux and Windows', async () => {
const layout = {
info: { id: 'dead-altgraph', lang: 'en' },
mapping: {
KeyP: {
value: 'p', withShift: 'P', withAltGr: '§', withShiftAltGr: '', withAltGrIsDeadKey: true, vkey: 'VK_P'
}
}
};
for (const system of ['linux', 'win']) {
const service = await setup(layout, system);
chai.expect(service.resolveKeyCode(KeyCode.parse('§')).supportedByLayout).to.be.false;
stubOSX.restore();
stubWindows.restore();
}
stubOSX = stubOS('isOSX', false);
stubWindows = stubOS('isWindows', false);
});
it('retains the Windows vkey fallback for value-less mappings', async () => {
const layout = {
info: { id: 'vkey-fallback', lang: 'en' },
mapping: { KeyA: { vkey: 'VK_A', value: '' } }
};
const service = await setup(layout, 'win');
const resolved = service.resolveKeyCode(KeyCode.parse('a'));
chai.expect(resolved.supportedByLayout).to.be.true;
chai.expect(resolved.key).to.equal(Key.KEY_A);
});
it('absorbs authored Shift when it selects a US character or layout shift layer', async () => {
const german = deGermanPc;
const service = await setup(german, 'linux');
const legacy = service.resolveKeyCode(KeyCode.parse('ctrl+shift+['));
chai.expect(legacy.shift).to.be.false;
chai.expect(legacy.dispatchString()).to.equal('ctrl+7@altgraph');
});
it('retains authored Shift when it is not consumed by the logical character', async () => {
const german = deGermanPc;
const service = await setup(german, 'linux');
const umlaut = service.resolveKeyCode(KeyCode.parse('ctrl+shift+ü'));
chai.expect(umlaut.dispatchString()).to.equal('shift+ctrl+[');
chai.expect(umlaut.layoutModifiers).to.equal('none');
chai.expect(service.resolveKeyCode(KeyCode.parse('shift+[char:0x41]')).dispatchString()).to.equal('a@shift');
chai.expect(service.resolveKeyCode(KeyCode.parse('shift+[char:0x61]')).dispatchString()).to.equal('shift+a');
chai.expect(service.resolveKeyCode(KeyCode.parse('ctrl+shift+a')).dispatchString()).to.equal('ctrl+a@shift');
chai.expect(service.resolveKeyCode(KeyCode.parse('ctrl+shift+[')).dispatchString()).to.equal('ctrl+7@altgraph');
});
it('requires Option for a macOS Shift+AltGraph layer', async () => {
const macUS = enUSMac;
const service = await setup(macUS, 'mac');
chai.expect(service.detectLayoutModifiers({ key: '±', code: 'IntlBackslash', shiftKey: true })).to.equal('shift');
chai.expect(service.detectLayoutModifiers({ key: '±', code: 'IntlBackslash', shiftKey: true, altKey: true })).to.equal('shiftAltGraph');
});
it('interprets macOS Option as a command modifier besides the Option layer', async () => {
const macUS = enUSMac;
const service = await setup(macUS, 'mac');
const optionShift = service.getKeyCodeInterpretations({ key: '∏', code: 'KeyP', shiftKey: true, altKey: true }, 'code');
chai.expect(optionShift.map(candidate => candidate.dispatchString())).to.deep.equal(['shift+alt+p', 'alt+p@shift', 'p@shift@altgraph']);
chai.expect(optionShift.map(candidate => candidate.character)).to.deep.equal(['P', 'P', '∏']);
chai.expect(service.resolveKeyCode(KeyCode.parse('shift+alt+p')).dispatchString()).to.equal('alt+p@shift');
const option = service.getKeyCodeInterpretations({ key: 'π', code: 'KeyP', altKey: true }, 'code');
chai.expect(option.map(candidate => candidate.dispatchString())).to.deep.equal(['alt+p', 'p@altgraph']);
chai.expect(option.map(candidate => candidate.character)).to.deep.equal(['p', 'π']);
const shift = service.getKeyCodeInterpretations({ key: 'P', code: 'KeyP', shiftKey: true }, 'code');
chai.expect(shift.map(candidate => candidate.dispatchString())).to.deep.equal(['shift+p', 'p@shift']);
});
it('records the base character for dead Option keys on macOS', async () => {
const service = await setup(enUSMac, 'mac');
const option = service.getKeyCodeInterpretations({ key: 'Dead', code: 'KeyE', altKey: true }, 'code');
chai.expect(option).to.have.length(1);
chai.expect(option[0].character).to.equal('e');
chai.expect(option[0].interpretation).to.equal('commandModifiers');
chai.expect(option[0].dispatchString()).to.equal('alt+e');
const optionShift = service.getKeyCodeInterpretations({ key: 'Dead', code: 'KeyE', altKey: true, shiftKey: true }, 'code');
chai.expect(optionShift.map(candidate => candidate.character)).to.deep.equal(['E', 'E']);
chai.expect(optionShift.map(candidate => candidate.dispatchString())).to.deep.equal(['shift+alt+e', 'alt+e@shift']);
const withoutOption = service.getKeyCodeInterpretations({ key: 'Dead', code: 'KeyE' }, 'code');
chai.expect(withoutOption).to.have.length(1);
chai.expect(withoutOption[0].character).to.be.undefined;
});
it('normalizes the character to the layout layer when Caps Lock inverts the case', async () => {
const us = await setup(enUSPc, 'linux');
const capsShift = us.getKeyCodeInterpretations({ key: 'p', code: 'KeyP', ctrlKey: true, shiftKey: true }, 'code');
chai.expect(capsShift.map(candidate => candidate.character)).to.deep.equal(['P', 'P']);
chai.expect(capsShift.map(candidate => candidate.dispatchString())).to.deep.equal(['shift+ctrl+p', 'ctrl+p@shift']);
const shift = us.getKeyCodeInterpretations({ key: 'P', code: 'KeyP', shiftKey: true }, 'code');
chai.expect(shift.map(candidate => candidate.character)).to.deep.equal(['P', 'P']);
stubOSX.restore();
stubWindows.restore();
const german = await setup(deGermanPc, 'linux');
const capsBase = german.getKeyCodeInterpretations({ key: 'Ü', code: 'BracketLeft', ctrlKey: true }, 'code');
chai.expect(capsBase).to.have.length(1);
chai.expect(capsBase[0].character).to.equal('ü');
chai.expect(capsBase[0].dispatchString()).to.equal('ctrl+[');
});
it('normalizes the character to the macOS Option layer when Caps Lock inverts the case', async () => {
const service = await setup(enUSMac, 'mac');
const capsOption = service.getKeyCodeInterpretations({ key: 'Å', code: 'KeyA', altKey: true }, 'code');
chai.expect(capsOption.map(candidate => candidate.character)).to.deep.equal(['a', 'å']);
chai.expect(capsOption.map(candidate => candidate.dispatchString())).to.deep.equal(['alt+a', 'a@altgraph']);
const capsShiftOption = service.getKeyCodeInterpretations({ key: 'å', code: 'KeyA', altKey: true, shiftKey: true }, 'code');
chai.expect(capsShiftOption[0].character).to.equal('A');
chai.expect(capsShiftOption[0].dispatchString()).to.equal('shift+alt+a');
});
it('attributes Shift to the Shift layer when input reports the base character', async () => {
// Test automation such as Puppeteer can report the base character while Shift is held.
const us = enUSPc;
const service = await setup(us, 'linux');
const input = { key: '`', code: 'Backquote', ctrlKey: true, shiftKey: true };
chai.expect(service.detectLayoutModifiers(input)).to.equal('shift');
const interpretations = service.getKeyCodeInterpretations(input, 'code');
chai.expect(interpretations.map(keyCode => keyCode.interpretation)).to.deep.equal(['commandModifiers', 'layoutModifiers']);
chai.expect(interpretations.map(keyCode => keyCode.dispatchString())).to.deep.equal(['shift+ctrl+`', 'ctrl+`@shift']);
chai.expect(interpretations[1].dispatchString()).to.equal(service.resolveKeyCode(KeyCode.parse('ctrl+shift+`')).dispatchString());
});
it('does not attribute base-character input to the Shift layer when AltGraph is active or the Shift layer is dead', async () => {
const layout = {
info: { id: 'dead-shift', lang: 'en' },
mapping: {
Backquote: {
value: '`', valueIsDeadKey: false, withShift: '~', withShiftIsDeadKey: false,
withAltGr: '', withAltGrIsDeadKey: false, withShiftAltGr: '', withShiftAltGrIsDeadKey: false
},
Equal: {
value: '=', valueIsDeadKey: false, withShift: '^', withShiftIsDeadKey: true,
withAltGr: '', withAltGrIsDeadKey: false, withShiftAltGr: '', withShiftAltGrIsDeadKey: false
}
}
};
const service = await setup(layout, 'linux');
chai.expect(service.detectLayoutModifiers({ key: '`', code: 'Backquote', shiftKey: true, altGraph: true })).to.be.undefined;
chai.expect(service.detectLayoutModifiers({ key: '=', code: 'Equal', shiftKey: true })).to.be.undefined;
});
it('normalizes the character to the Linux AltGraph layer when Caps Lock inverts the case', async () => {
const layout = {
info: { id: 'altgraph-letters', lang: 'pl' },
mapping: { KeyL: { value: 'l', withShift: 'L', withAltGr: 'ł', withShiftAltGr: 'Ł' } }
};
const service = await setup(layout, 'linux');
const capsAltGraph = service.getKeyCodeInterpretations({ key: 'Ł', code: 'KeyL', altGraph: true }, 'code');
chai.expect(capsAltGraph).to.have.length(1);
chai.expect(capsAltGraph[0].character).to.equal('ł');
chai.expect(capsAltGraph[0].dispatchString()).to.equal('l@altgraph');
const capsShiftAltGraph = service.getKeyCodeInterpretations({ key: 'ł', code: 'KeyL', shiftKey: true, altGraph: true }, 'code');
chai.expect(capsShiftAltGraph).to.have.length(1);
chai.expect(capsShiftAltGraph[0].character).to.equal('Ł');
});
it('does not add an AltGraph layer to Linux Alt+Shift input', async () => {
const service = await setup(enUSPc, 'linux');
chai.expect(service.getKeyCodeInterpretations({ key: 'P', code: 'KeyP', shiftKey: true, altKey: true }, 'code')
.map(candidate => candidate.dispatchString())).to.deep.equal(['shift+alt+p', 'alt+p@shift']);
});
it('requires AltGraph for a Linux Shift+AltGraph layer', async () => {
const layout = {
info: { id: 'same-shift-layers', lang: 'en' },
mapping: { KeyA: { value: 'a', withShift: 'A', withAltGr: 'ä', withShiftAltGr: 'A' } }
};
const service = await setup(layout, 'linux');
chai.expect(service.detectLayoutModifiers({ key: 'A', code: 'KeyA', shiftKey: true })).to.equal('shift');
chai.expect(service.detectLayoutModifiers({ key: 'A', code: 'KeyA', shiftKey: true, altGraph: true })).to.equal('shiftAltGraph');
});
it('uses Option as macOS AltGraph layer evidence', async () => {
const layout = {
info: { id: 'altgraph-evidence', lang: 'en' },
mapping: { KeyA: { value: 'a', withShift: 'A', withAltGr: 'ä', withShiftAltGr: 'Ä' } }
};
const service = await setup(layout, 'mac');
chai.expect(service.detectLayoutModifiers({ key: 'ä', code: 'KeyA', altKey: true })).to.equal('altGraph');
chai.expect(service.detectLayoutModifiers({ key: 'ä', code: 'KeyA' })).to.be.undefined;
});
it('uses emulated Windows AltGraph as platform layer evidence', async () => {
const layout = {
info: { id: 'altgraph-evidence', lang: 'en' },
mapping: { KeyA: { value: 'a', withShift: 'A', withAltGr: 'ä', withShiftAltGr: 'Ä' } }
};
const service = await setup(layout, 'win');
chai.expect(service.detectLayoutModifiers({ key: 'ä', code: 'KeyA', ctrlKey: true, altKey: true })).to.equal('altGraph');
});
it('constructs Linux layout modifier interpretations only for participating AltGraph', async () => {
const german = deGermanPc;
const service = await setup(german, 'linux');
const participating = service.getKeyCodeInterpretations({ key: '[', code: 'Digit8', altGraph: true }, 'code');
chai.expect(participating).to.have.length(1);
chai.expect(participating[0].layoutModifiers).to.deep.equal('altGraph');
chai.expect(participating[0].dispatchString()).to.equal('8@altgraph');
const nonParticipating = service.getKeyCodeInterpretations({ key: 'o', code: 'KeyO', altGraph: true }, 'code');
chai.expect(nonParticipating[0].layoutModifiers).to.equal('none');
const withoutModifierEvidence = service.getKeyCodeInterpretations({ key: '[', code: 'Digit8' }, 'code');
chai.expect(withoutModifierEvidence[0].layoutModifiers).to.equal('none');
const withCommandAlt = service.getKeyCodeInterpretations({ key: '[', code: 'Digit8', altKey: true, altGraph: true }, 'code');
chai.expect(withCommandAlt[0].alt).to.be.true;
chai.expect(withCommandAlt[0].layoutModifiers).to.equal('altGraph');
});
it('keeps shifted printable bindings symmetric in keyCode dispatch mode', async () => {
const german = deGermanPc;
const service = await setup(german, 'linux');
const commandPalette = KeyCode.parse('ctrl+shift+p');
const shiftedPrintable = KeyCode.parse('shift+/');
chai.expect(service.getKeyCodeInterpretations({ key: 'P', code: 'KeyP', keyCode: Key.KEY_P.keyCode, ctrlKey: true, shiftKey: true }, 'keyCode')[0]
.dispatchString()).to.equal(commandPalette.dispatchString());
chai.expect(service.getKeyCodeInterpretations({ key: '/', code: 'Digit7', keyCode: Key.SLASH.keyCode, shiftKey: true }, 'keyCode')[0]
.dispatchString()).to.equal(shiftedPrintable.dispatchString());
});
it('constructs command-first and layout modifier Windows interpretations', async () => {
const german = deGermanPc;
const service = await setup(german, 'win');
const interpretations = service.getKeyCodeInterpretations({
key: '[', code: 'Digit8', ctrlKey: true, altKey: true, altGraph: false
}, 'code');
chai.expect(interpretations.map(code => code.interpretation)).to.deep.equal(['commandModifiers', 'layoutModifiers']);
chai.expect(interpretations[0].dispatchString()).to.equal('alt+ctrl+8');
chai.expect(interpretations[1].dispatchString()).to.equal('8@altgraph');
const intentional = service.getKeyCodeInterpretations({
key: 'f', code: 'KeyF', ctrlKey: true, altKey: true, altGraph: false
}, 'code');
chai.expect(intentional).to.have.length(1);
chai.expect(intentional[0].dispatchString()).to.equal('alt+ctrl+f');
const shiftedBinding = service.resolveKeyCode(KeyCode.parse('ctrl+shift+p'));
const shiftedEvent = service.getKeyCodeInterpretations({ key: 'P', code: 'KeyP', ctrlKey: true, shiftKey: true }, 'code')
.find(candidate => candidate.interpretation === 'layoutModifiers');
chai.expect(shiftedBinding.supportedByLayout).to.be.true;
chai.expect(shiftedEvent.dispatchString()).to.equal(shiftedBinding.dispatchString());
});
it('preserves authored command modifiers alongside explicit Windows AltGraph', async () => {
const german = deGermanPc;
const service = await setup(german, 'win');
const cases = [
{ ctrlKey: false, altKey: false, metaKey: false, expected: '8@altgraph' },
{ ctrlKey: true, altKey: false, metaKey: true, expected: 'meta+ctrl+8@altgraph' },
{ ctrlKey: false, altKey: true, metaKey: true, expected: 'meta+alt+8@altgraph' }
];
for (const { expected, ...modifiers } of cases) {
const input = { key: '[', code: 'Digit8', altGraph: true, ...modifiers };
const keyCode = new KeyCode({
key: Key.DIGIT8, character: '[', ctrl: input.ctrlKey, alt: input.altKey, meta: input.metaKey
});
const interpretations = service.getWindowsKeyCodeInterpretations(keyCode, input, 'altGraph');
chai.expect(interpretations).to.have.length(1);
chai.expect(interpretations[0].interpretation).to.equal('layoutModifiers');
chai.expect(interpretations[0].dispatchString()).to.equal(expected);
}
});
it('keeps legacy Windows AltGraph reporting typing-safe and preserves Meta', async () => {
const german = deGermanPc;
const service = await setup(german, 'win');
for (const metaKey of [false, true]) {
const input = { key: '[', code: 'Digit8', ctrlKey: true, altKey: true, altGraph: true, metaKey };
const keyCode = new KeyCode({ key: Key.DIGIT8, character: '[', ctrl: true, alt: true, meta: metaKey });
const interpretations = service.getWindowsKeyCodeInterpretations(keyCode, input, 'altGraph');
const prefix = metaKey ? 'meta+' : '';
chai.expect(interpretations.map(code => code.interpretation)).to.deep.equal(['commandModifiers', 'layoutModifiers']);
chai.expect(interpretations[0].dispatchString()).to.equal(`${prefix}alt+ctrl+8`);
chai.expect(interpretations[1].dispatchString()).to.equal(`${prefix}8@altgraph`);
}
});
it('uses confirmed withAltGr output as Shift+AltGraph fallback when the shifted layer is absent', async () => {
const layout = {
info: { id: 'shift-altgraph-fallback', lang: 'en' },
mapping: {
Digit8: { value: '8', withShift: '*', withAltGr: '[', withShiftAltGr: '' }
}
};
const service = await setup(layout, 'linux');
chai.expect(service.detectLayoutModifiers({ key: '[', code: 'Digit8', shiftKey: true, altGraph: true }))
.to.deep.equal('shiftAltGraph');
chai.expect(service.detectLayoutModifiers({ key: '*', code: 'Digit8', shiftKey: true, altGraph: true }))
.to.equal('shift');
});
it('passes Linux AltGraph evidence to the key validator', async () => {
let validated;
const validator = { validateKey: validation => validated = validation };
const german = deGermanPc;
const service = await setup(german, 'linux', undefined, validator);
const input = { key: '[', code: 'Digit8', ctrlKey: true, altGraph: true, shiftKey: false };
service.validateKeyCode(service.getKeyCodeInterpretations(input, 'code')[0], input);
chai.expect(validated?.altGraph).to.be.true;
});
it('passes macOS Option evidence to the key validator', async () => {
let validated;
const validator = { validateKey: validation => validated = validation };
const german = deGermanPc;
const service = await setup(german, 'mac', undefined, validator);
const input = { key: '[', code: 'Digit8', altKey: true, shiftKey: false };
service.validateKeyCode(service.getKeyCodeInterpretations(input, 'code')[0], input);
chai.expect(validated?.altGraph).to.be.true;
});
it('passes emulated Windows AltGraph evidence to the key validator', async () => {
let validated;
const validator = { validateKey: validation => validated = validation };
const german = deGermanPc;
const service = await setup(german, 'win', undefined, validator);
const input = { key: '[', code: 'Digit8', ctrlKey: true, altKey: true, shiftKey: false };
service.validateKeyCode(service.getKeyCodeInterpretations(input, 'code')[0], input);
chai.expect(validated?.altGraph).to.be.true;
});
it('does not treat excluded or non-printable keys as layout modifier', async () => {
const layout = {
info: { id: 'native-shaped', lang: 'en' },
mapping: {
Space: { value: ' ', withShift: ' ', withAltGr: ' ', withShiftAltGr: ' ' },
Numpad1: { value: '1', withShift: '1', withAltGr: '¹', withShiftAltGr: '¹' }
}
};
const service = await setup(layout, 'linux');
chai.expect(service.detectLayoutModifiers({ key: ' ', code: 'Space', shiftKey: true })).to.be.undefined;
chai.expect(service.detectLayoutModifiers({ key: '¹', code: 'Numpad1', altGraph: true })).to.be.undefined;
});
it('ingests all Windows layout modifier layers across representative PC layouts', async () => {
const fixtures = [
{ layout: deGermanPc, assertions: [['²', Key.DIGIT2, false, true], ['ẞ', Key.MINUS, true, true]] },
{ layout: frFrenchPc, assertions: [['€', Key.KEY_E, false, true]] },
{ layout: deSwissGermanPc, assertions: [['@', Key.DIGIT2, false, true]] },
{ layout: frBepoPc, assertions: [['Æ', Key.KEY_A, true, true]] }
];
for (const fixture of fixtures) {
const service = await setup(fixture.layout, 'win');
for (const [character, key, shift, altGraph] of fixture.assertions) {
const resolved = service.resolveKeyCode(KeyCode.parse(character));
chai.expect(resolved.key).to.equal(key);
chai.expect(resolved.character).to.equal(character);
const expected = shift ? 'shiftAltGraph' : altGraph ? 'altGraph' : 'none';
chai.expect(resolved.layoutModifiers).to.equal(expected);
}
stubOSX.restore();
stubWindows.restore();
}
stubOSX = stubOS('isOSX', false);
stubWindows = stubOS('isWindows', false);
});
it('handles missing Windows layer values defensively', async () => {
const layout = {
info: { id: 'missing-windows-layers', lang: 'en' },
mapping: { KeyA: { vkey: 'VK_A', value: 'a' } }
};
const service = await setup(layout, 'win');
chai.expect(service.resolveKeyCode(KeyCode.parse('a')).supportedByLayout).to.be.true;
chai.expect(service.resolveKeyCode(KeyCode.parse('§')).supportedByLayout).to.be.false;
});
it('resolves logical plus on US, German, and macOS layouts', async () => {
const fixtures = [
{ layout: enUSPc, system: 'win', key: Key.EQUAL, shift: true },
{ layout: deGermanPc, system: 'win', key: Key.BRACKET_RIGHT, shift: false },
{ layout: enUSMac, system: 'mac', key: Key.EQUAL, shift: true }
];
for (const fixture of fixtures) {
const service = await setup(fixture.layout, fixture.system);
const resolved = service.resolveKeyCode(KeyCode.parse('[char:0x2B]'));
chai.expect(resolved.key).to.equal(fixture.key);
chai.expect(resolved.layoutModifiers === 'shift' || resolved.layoutModifiers === 'shiftAltGraph').to.equal(fixture.shift);
stubOSX.restore();
stubWindows.restore();
}
stubOSX = stubOS('isOSX', false);
stubWindows = stubOS('isWindows', false);
});
it('resolves correct key bindings with German Windows layout', async () => {
const winGerman = deGermanPc;
const service = await setup(winGerman, 'win');
const toggleComment = service.resolveKeyCode(KeyCode.createKeyCode('Slash+M1'));
chai.expect(toggleComment.toString()).to.equal('ctrl+7');
chai.expect(toggleComment.character).to.equal('/');
chai.expect(toggleComment.layoutModifiers).to.deep.equal('shift');
chai.expect(service.getKeyboardCharacter(toggleComment.key)).to.equal('7');
const indentLine = service.resolveKeyCode(KeyCode.createKeyCode('BracketRight+M1'));
chai.expect(indentLine.toString()).to.equal('ctrl+9');
chai.expect(indentLine.character).to.equal(']');
chai.expect(indentLine.layoutModifiers).to.deep.equal('altGraph');
chai.expect(service.getKeyboardCharacter(indentLine.key)).to.equal('9');
});
it('resolves correct key bindings with French Windows layout', async () => {
const winFrench = frFrenchPc;
const service = await setup(winFrench, 'win');
const toggleComment = service.resolveKeyCode(KeyCode.createKeyCode('Slash+M1'));
chai.expect(toggleComment.toString()).to.equal('ctrl+.');
chai.expect(toggleComment.character).to.equal('/');
chai.expect(toggleComment.layoutModifiers).to.deep.equal('shift');
chai.expect(service.getKeyboardCharacter(toggleComment.key)).to.equal(':');
const indentLine = service.resolveKeyCode(KeyCode.createKeyCode('BracketRight+M1'));
chai.expect(indentLine.toString()).to.equal('ctrl+-');
chai.expect(indentLine.character).to.equal(']');
chai.expect(indentLine.layoutModifiers).to.deep.equal('altGraph');
chai.expect(service.getKeyboardCharacter(indentLine.key)).to.equal(')');
});
});
//# sourceMappingURL=keyboard-layout-service.spec.js.map