UNPKG

12 kBJavaScriptView Raw
1"use strict";
2// *****************************************************************************
3// Copyright (C) 2017 Ericsson and others.
4//
5// This program and the accompanying materials are made available under the
6// terms of the Eclipse Public License v. 2.0 which is available at
7// http://www.eclipse.org/legal/epl-2.0.
8//
9// This Source Code may also be made available under the following Secondary
10// Licenses when the conditions for such availability set forth in the Eclipse
11// Public License v. 2.0 are satisfied: GNU General Public License, version 2
12// with the GNU Classpath Exception which is available at
13// https://www.gnu.org/software/classpath/license.html.
14//
15// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
16// *****************************************************************************
17Object.defineProperty(exports, "__esModule", { value: true });
18const jsdom_1 = require("../../browser/test/jsdom");
19let disableJSDOM = (0, jsdom_1.enableJSDOM)();
20const keys_1 = require("./keys");
21const os = require("../../common/os");
22const chai = require("chai");
23const sinon = require("sinon");
24disableJSDOM();
25const expect = chai.expect;
26describe('keys api', () => {
27 const equalKeyCode = (keyCode1, keyCode2) => JSON.stringify(keyCode1) === JSON.stringify(keyCode2);
28 before(() => {
29 disableJSDOM = (0, jsdom_1.enableJSDOM)();
30 });
31 after(() => {
32 disableJSDOM();
33 });
34 it('should parse a string to a KeyCode correctly', () => {
35 const keycode = keys_1.KeyCode.parse('ctrl+b');
36 expect(keycode.ctrl).to.be.true;
37 expect(keycode.key).is.equal(keys_1.Key.KEY_B);
38 // Invalid keystroke string
39 expect(() => keys_1.KeyCode.parse('ctl+b')).to.throw(Error);
40 });
41 it('should parse a string containing special modifiers to a KeyCode correctly', () => {
42 const stub = sinon.stub(os, 'isOSX').value(false);
43 const keycode = keys_1.KeyCode.parse('ctrl+b');
44 expect(keycode.ctrl).to.be.true;
45 expect(keycode.key).is.equal(keys_1.Key.KEY_B);
46 const keycodeOption = keys_1.KeyCode.parse('option+b');
47 expect(keycodeOption.alt).to.be.true;
48 expect(keycodeOption.key).is.equal(keys_1.Key.KEY_B);
49 expect(() => keys_1.KeyCode.parse('cmd+b')).to.throw(/OSX only/);
50 const keycodeCtrlOrCommand = keys_1.KeyCode.parse('ctrlcmd+b');
51 expect(keycodeCtrlOrCommand.meta).to.be.false;
52 expect(keycodeCtrlOrCommand.ctrl).to.be.true;
53 expect(keycodeCtrlOrCommand.key).is.equal(keys_1.Key.KEY_B);
54 stub.restore();
55 });
56 it('should parse a string containing special modifiers to a KeyCode correctly (macOS)', () => {
57 keys_1.KeyCode.resetKeyBindings();
58 const stub = sinon.stub(os, 'isOSX').value(true);
59 const keycode = keys_1.KeyCode.parse('ctrl+b');
60 expect(keycode.ctrl).to.be.true;
61 expect(keycode.key).is.equal(keys_1.Key.KEY_B);
62 const keycodeOption = keys_1.KeyCode.parse('option+b');
63 expect(keycodeOption.alt).to.be.true;
64 expect(keycodeOption.key).is.equal(keys_1.Key.KEY_B);
65 const keycodeCommand = keys_1.KeyCode.parse('cmd+b');
66 expect(keycodeCommand.meta).to.be.true;
67 expect(keycodeCommand.key).is.equal(keys_1.Key.KEY_B);
68 const keycodeCtrlOrCommand = keys_1.KeyCode.parse('ctrlcmd+b');
69 expect(keycodeCtrlOrCommand.meta).to.be.true;
70 expect(keycodeCtrlOrCommand.ctrl).to.be.false;
71 expect(keycodeCtrlOrCommand.key).is.equal(keys_1.Key.KEY_B);
72 stub.restore();
73 });
74 it('should serialize a keycode properly with BACKQUOTE + M1', () => {
75 const stub = sinon.stub(os, 'isOSX').value(true);
76 let keyCode = keys_1.KeyCode.createKeyCode({ first: keys_1.Key.BACKQUOTE, modifiers: [keys_1.KeyModifier.CtrlCmd] });
77 let keyCodeString = keyCode.toString();
78 expect(keyCodeString).to.be.equal('meta+`');
79 let parsedKeyCode = keys_1.KeyCode.parse(keyCodeString);
80 expect(equalKeyCode(parsedKeyCode, keyCode)).to.be.true;
81 sinon.stub(os, 'isOSX').value(false);
82 keyCode = keys_1.KeyCode.createKeyCode({ first: keys_1.Key.BACKQUOTE, modifiers: [keys_1.KeyModifier.CtrlCmd] });
83 keyCodeString = keyCode.toString();
84 expect(keyCodeString).to.be.equal('ctrl+`');
85 parsedKeyCode = keys_1.KeyCode.parse(keyCodeString);
86 expect(equalKeyCode(parsedKeyCode, keyCode)).to.be.true;
87 stub.restore();
88 });
89 it('should serialize a keycode properly with a + M2 + M3', () => {
90 const keyCode = keys_1.KeyCode.createKeyCode({ first: keys_1.Key.KEY_A, modifiers: [keys_1.KeyModifier.Shift, keys_1.KeyModifier.Alt] });
91 const keyCodeString = keyCode.toString();
92 expect(keyCodeString).to.be.equal('shift+alt+a');
93 const parsedKeyCode = keys_1.KeyCode.parse(keyCodeString);
94 expect(equalKeyCode(parsedKeyCode, keyCode)).to.be.true;
95 });
96 it('the order of the modifiers should not matter when parsing the key code', () => {
97 const left = keys_1.KeySequence.parse('shift+alt+a');
98 const right = keys_1.KeySequence.parse('alt+shift+a');
99 expect(keys_1.KeySequence.compare(left, right)).to.be.equal(keys_1.KeySequence.CompareResult.FULL);
100 expect(keys_1.KeySequence.compare([keys_1.KeyCode.createKeyCode({ first: keys_1.Key.KEY_A, modifiers: [keys_1.KeyModifier.Alt, keys_1.KeyModifier.Shift] })], right)).to.be.equal(keys_1.KeySequence.CompareResult.FULL);
101 expect(keys_1.KeySequence.compare(left, [keys_1.KeyCode.createKeyCode({ first: keys_1.Key.KEY_A, modifiers: [keys_1.KeyModifier.Alt, keys_1.KeyModifier.Shift] })])).to.be.equal(keys_1.KeySequence.CompareResult.FULL);
102 expect(keys_1.KeySequence.compare([keys_1.KeyCode.createKeyCode({ first: keys_1.Key.KEY_A, modifiers: [keys_1.KeyModifier.Shift, keys_1.KeyModifier.Alt] })], right)).to.be.equal(keys_1.KeySequence.CompareResult.FULL);
103 expect(keys_1.KeySequence.compare(left, [keys_1.KeyCode.createKeyCode({ first: keys_1.Key.KEY_A, modifiers: [keys_1.KeyModifier.Shift, keys_1.KeyModifier.Alt] })])).to.be.equal(keys_1.KeySequence.CompareResult.FULL);
104 });
105 it('should parse ctrl key properly on both OS X and other platforms', () => {
106 const event = new KeyboardEvent('keydown', {
107 key: keys_1.Key.BACKQUOTE.easyString,
108 code: keys_1.Key.BACKQUOTE.code,
109 ctrlKey: true,
110 });
111 const stub = sinon.stub(os, 'isOSX').value(true);
112 expect(keys_1.KeyCode.createKeyCode(event).toString()).to.be.equal('ctrl+`');
113 sinon.stub(os, 'isOSX').value(false);
114 expect(keys_1.KeyCode.createKeyCode(event).toString()).to.be.equal('ctrl+`');
115 stub.restore();
116 });
117 it('should properly handle eventDispatch', () => {
118 const event = new KeyboardEvent('keydown', {
119 code: keys_1.Key.CAPS_LOCK.code,
120 });
121 Object.defineProperty(event, 'keyCode', { get: () => keys_1.Key.ESCAPE.keyCode });
122 expect(keys_1.KeyCode.createKeyCode(event, 'code').toString()).to.be.equal(keys_1.Key.CAPS_LOCK.easyString);
123 expect(keys_1.KeyCode.createKeyCode(event, 'keyCode').toString()).to.be.equal(keys_1.Key.ESCAPE.easyString);
124 });
125 it('should serialize a keycode properly with a + M4', () => {
126 const stub = sinon.stub(os, 'isOSX').value(true);
127 const keyCode = keys_1.KeyCode.createKeyCode({ first: keys_1.Key.KEY_A, modifiers: [keys_1.KeyModifier.MacCtrl] });
128 const keyCodeString = keyCode.toString();
129 expect(keyCodeString).to.be.equal('ctrl+a');
130 const parsedKeyCode = keys_1.KeyCode.parse(keyCodeString);
131 expect(equalKeyCode(parsedKeyCode, keyCode)).to.be.true;
132 stub.restore();
133 });
134 it('it should parse a multi keycode keybinding', () => {
135 const validKeyCodes = [];
136 validKeyCodes.push(keys_1.KeyCode.createKeyCode({ first: keys_1.Key.KEY_A, modifiers: [keys_1.KeyModifier.CtrlCmd] }));
137 validKeyCodes.push(keys_1.KeyCode.createKeyCode({ first: keys_1.Key.KEY_C, modifiers: [keys_1.KeyModifier.CtrlCmd, keys_1.KeyModifier.Shift] }));
138 const parsedKeyCodes = keys_1.KeySequence.parse('ctrlcmd+a ctrlcmd+shift+c');
139 expect(parsedKeyCodes).to.deep.equal(validKeyCodes);
140 });
141 it('it should parse a multi keycode keybinding with no modifiers', () => {
142 const validKeyCodes = [];
143 validKeyCodes.push(keys_1.KeyCode.createKeyCode({ first: keys_1.Key.KEY_A, modifiers: [keys_1.KeyModifier.CtrlCmd] }));
144 validKeyCodes.push(keys_1.KeyCode.createKeyCode({ first: keys_1.Key.KEY_C }));
145 const parsedKeyCodes = keys_1.KeySequence.parse('ctrlcmd+a c');
146 expect(parsedKeyCodes).to.deep.equal(validKeyCodes);
147 });
148 it('should compare keysequences properly', () => {
149 let a = keys_1.KeySequence.parse('ctrlcmd+a');
150 let b = keys_1.KeySequence.parse('ctrlcmd+a t');
151 expect(keys_1.KeySequence.compare(a, b)).to.be.equal(keys_1.KeySequence.CompareResult.PARTIAL);
152 a = keys_1.KeySequence.parse('ctrlcmd+a t');
153 b = keys_1.KeySequence.parse('ctrlcmd+a');
154 expect(keys_1.KeySequence.compare(a, b)).to.be.equal(keys_1.KeySequence.CompareResult.SHADOW);
155 a = keys_1.KeySequence.parse('ctrlcmd+a t');
156 b = keys_1.KeySequence.parse('ctrlcmd+a b c');
157 expect(keys_1.KeySequence.compare(a, b)).to.be.equal(keys_1.KeySequence.CompareResult.NONE);
158 a = keys_1.KeySequence.parse('ctrlcmd+a t');
159 b = keys_1.KeySequence.parse('ctrlcmd+a a');
160 expect(keys_1.KeySequence.compare(a, b)).to.be.equal(keys_1.KeySequence.CompareResult.NONE);
161 a = keys_1.KeySequence.parse('ctrlcmd+a t');
162 b = keys_1.KeySequence.parse('ctrlcmd+a t');
163 expect(keys_1.KeySequence.compare(a, b)).to.be.equal(keys_1.KeySequence.CompareResult.FULL);
164 a = keys_1.KeySequence.parse('ctrlcmd+a t b');
165 b = keys_1.KeySequence.parse('ctrlcmd+a t b');
166 expect(keys_1.KeySequence.compare(a, b)).to.be.equal(keys_1.KeySequence.CompareResult.FULL);
167 });
168 it('should be a modifier only', () => {
169 const keyCode = keys_1.KeyCode.createKeyCode({ modifiers: [keys_1.KeyModifier.CtrlCmd] });
170 expect(keyCode).to.be.deep.equal(keys_1.KeyCode.createKeyCode({ modifiers: [keys_1.KeyModifier.CtrlCmd] }));
171 expect(keyCode.isModifierOnly()).to.be.true;
172 });
173 it('should be multiple modifiers only', () => {
174 const keyCode = keys_1.KeyCode.createKeyCode({ modifiers: [keys_1.KeyModifier.CtrlCmd, keys_1.KeyModifier.Alt] });
175 expect(keyCode).to.be.deep.equal(keys_1.KeyCode.createKeyCode({ modifiers: [keys_1.KeyModifier.CtrlCmd, keys_1.KeyModifier.Alt] }));
176 expect(keyCode.isModifierOnly()).to.be.true;
177 });
178 it('parse bogus keybinding', () => {
179 const [first, second] = keys_1.KeySequence.parse(' Ctrl+sHiFt+F10 b ');
180 expect(first.ctrl).to.be.true;
181 expect(first.shift).to.be.true;
182 expect(first.key).is.equal(keys_1.Key.F10);
183 expect(second.key).is.equal(keys_1.Key.KEY_B);
184 });
185 it('should parse minus as key', () => {
186 const keycode = keys_1.KeyCode.parse('ctrl+-');
187 expect(keycode.ctrl).to.be.true;
188 expect(keycode.key).is.equal(keys_1.Key.MINUS);
189 });
190 it('should parse minus as key and separator', () => {
191 const keycode = keys_1.KeyCode.parse('ctrl--');
192 expect(keycode.ctrl).to.be.true;
193 expect(keycode.key).is.equal(keys_1.Key.MINUS);
194 });
195 it('should parse plus as separator', () => {
196 const keycode = keys_1.KeyCode.parse('ctrl-+-');
197 expect(keycode.ctrl).to.be.true;
198 expect(keycode.key).is.equal(keys_1.Key.MINUS);
199 });
200 it('should not parse plus as key but separator', () => {
201 const keycode = keys_1.KeyCode.parse('ctrl++-');
202 expect(keycode.ctrl).to.be.true;
203 expect(keycode.key).is.equal(keys_1.Key.MINUS);
204 });
205});
206//# sourceMappingURL=keys.spec.js.map
\No newline at end of file