1 | "use strict";
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 |
|
11 |
|
12 |
|
13 |
|
14 |
|
15 |
|
16 |
|
17 | Object.defineProperty(exports, "__esModule", { value: true });
|
18 | exports.KeysOrKeyCodes = exports.Key = exports.SpecialCases = exports.KeyModifier = exports.KeyCode = exports.KeySequence = void 0;
|
19 | const os_1 = require("./os");
|
20 | var KeySequence;
|
21 | (function (KeySequence) {
|
22 | function equals(a, b) {
|
23 | if (a.length !== b.length) {
|
24 | return false;
|
25 | }
|
26 | for (let i = 0; i < a.length; i++) {
|
27 | if (!a[i].equals(b[i])) {
|
28 | return false;
|
29 | }
|
30 | }
|
31 | return true;
|
32 | }
|
33 | KeySequence.equals = equals;
|
34 | let CompareResult;
|
35 | (function (CompareResult) {
|
36 | CompareResult[CompareResult["NONE"] = 0] = "NONE";
|
37 | CompareResult[CompareResult["PARTIAL"] = 1] = "PARTIAL";
|
38 | CompareResult[CompareResult["SHADOW"] = 2] = "SHADOW";
|
39 | CompareResult[CompareResult["FULL"] = 3] = "FULL";
|
40 | })(CompareResult = KeySequence.CompareResult || (KeySequence.CompareResult = {}));
|
41 | |
42 |
|
43 |
|
44 |
|
45 |
|
46 |
|
47 | function compare(a, b) {
|
48 | let first = a;
|
49 | let second = b;
|
50 | let shadow = false;
|
51 | if (b.length < a.length) {
|
52 | first = b;
|
53 | second = a;
|
54 | shadow = true;
|
55 | }
|
56 | for (let i = 0; i < first.length; i++) {
|
57 | if (first[i].equals(second[i]) === false) {
|
58 | return KeySequence.CompareResult.NONE;
|
59 | }
|
60 | }
|
61 | if (first.length < second.length) {
|
62 | if (shadow === false) {
|
63 | return KeySequence.CompareResult.PARTIAL;
|
64 | }
|
65 | else {
|
66 | return KeySequence.CompareResult.SHADOW;
|
67 | }
|
68 | }
|
69 | return KeySequence.CompareResult.FULL;
|
70 | }
|
71 | KeySequence.compare = compare;
|
72 | function parse(keybinding) {
|
73 | const keyCodes = [];
|
74 | const rawKeyCodes = keybinding.trim().split(/\s+/g);
|
75 | for (const rawKeyCode of rawKeyCodes) {
|
76 | const keyCode = KeyCode.parse(rawKeyCode);
|
77 | if (keyCode !== undefined) {
|
78 | keyCodes.push(keyCode);
|
79 | }
|
80 | }
|
81 | return keyCodes;
|
82 | }
|
83 | KeySequence.parse = parse;
|
84 | })(KeySequence = exports.KeySequence || (exports.KeySequence = {}));
|
85 |
|
86 |
|
87 |
|
88 | class KeyCode {
|
89 | constructor(schema) {
|
90 | const key = schema.key;
|
91 | if (key) {
|
92 | if (key.code && key.keyCode && key.easyString) {
|
93 | this.key = key;
|
94 | }
|
95 | else if (key.code) {
|
96 | this.key = Key.getKey(key.code);
|
97 | }
|
98 | else if (key.keyCode) {
|
99 | this.key = Key.getKey(key.keyCode);
|
100 | }
|
101 | }
|
102 | this.ctrl = !!schema.ctrl;
|
103 | this.shift = !!schema.shift;
|
104 | this.alt = !!schema.alt;
|
105 | this.meta = !!schema.meta;
|
106 | this.character = schema.character;
|
107 | }
|
108 | |
109 |
|
110 |
|
111 | isModifierOnly() {
|
112 | return this.key === undefined;
|
113 | }
|
114 | |
115 |
|
116 |
|
117 | equals(other) {
|
118 | if (this.key && (!other.key || this.key.code !== other.key.code) || !this.key && other.key) {
|
119 | return false;
|
120 | }
|
121 | return this.ctrl === other.ctrl && this.alt === other.alt && this.shift === other.shift && this.meta === other.meta;
|
122 | }
|
123 | |
124 |
|
125 |
|
126 | toString() {
|
127 | const result = [];
|
128 | if (this.meta) {
|
129 | result.push(SpecialCases.META);
|
130 | }
|
131 | if (this.shift) {
|
132 | result.push(Key.SHIFT_LEFT.easyString);
|
133 | }
|
134 | if (this.alt) {
|
135 | result.push(Key.ALT_LEFT.easyString);
|
136 | }
|
137 | if (this.ctrl) {
|
138 | result.push(Key.CONTROL_LEFT.easyString);
|
139 | }
|
140 | if (this.key) {
|
141 | result.push(this.key.easyString);
|
142 | }
|
143 | return result.join('+');
|
144 | }
|
145 | |
146 |
|
147 |
|
148 | static createKeyCode(input, eventDispatch = 'code') {
|
149 | if (typeof input === 'string') {
|
150 | const parts = input.split('+');
|
151 | if (!KeyCode.isModifierString(parts[0])) {
|
152 | return KeyCode.createKeyCode({
|
153 | first: Key.getKey(parts[0]),
|
154 | modifiers: parts.slice(1)
|
155 | });
|
156 | }
|
157 | return KeyCode.createKeyCode({ modifiers: parts });
|
158 | }
|
159 | else if (KeyCode.isKeyboardEvent(input)) {
|
160 | const key = KeyCode.toKey(input, eventDispatch);
|
161 | return new KeyCode({
|
162 | key: Key.isModifier(key.code) ? undefined : key,
|
163 | meta: os_1.isOSX && input.metaKey,
|
164 | shift: input.shiftKey,
|
165 | alt: input.altKey,
|
166 | ctrl: input.ctrlKey,
|
167 | character: KeyCode.toCharacter(input)
|
168 | });
|
169 | }
|
170 | else if (input.first || input.modifiers) {
|
171 | const keystroke = input;
|
172 | const schema = {
|
173 | key: keystroke.first
|
174 | };
|
175 | if (keystroke.modifiers) {
|
176 | if (os_1.isOSX) {
|
177 | schema.meta = keystroke.modifiers.some(mod => mod === KeyModifier.CtrlCmd);
|
178 | schema.ctrl = keystroke.modifiers.some(mod => mod === KeyModifier.MacCtrl);
|
179 | }
|
180 | else {
|
181 | schema.meta = false;
|
182 | schema.ctrl = keystroke.modifiers.some(mod => mod === KeyModifier.CtrlCmd);
|
183 | }
|
184 | schema.shift = keystroke.modifiers.some(mod => mod === KeyModifier.Shift);
|
185 | schema.alt = keystroke.modifiers.some(mod => mod === KeyModifier.Alt);
|
186 | }
|
187 | return new KeyCode(schema);
|
188 | }
|
189 | else {
|
190 | return new KeyCode(input);
|
191 | }
|
192 | }
|
193 |
|
194 | static resetKeyBindings() {
|
195 | KeyCode.keybindings = {};
|
196 | }
|
197 | |
198 |
|
199 |
|
200 |
|
201 | static parse(keybinding) {
|
202 | if (KeyCode.keybindings[keybinding]) {
|
203 | return KeyCode.keybindings[keybinding];
|
204 | }
|
205 | const schema = {};
|
206 | const keys = [];
|
207 | let currentKey = '';
|
208 | for (const character of keybinding.trim().toLowerCase()) {
|
209 | if (currentKey && (character === '-' || character === '+')) {
|
210 | keys.push(currentKey);
|
211 | currentKey = '';
|
212 | }
|
213 | else if (character !== '+') {
|
214 | currentKey += character;
|
215 | }
|
216 | }
|
217 | if (currentKey) {
|
218 | keys.push(currentKey);
|
219 | }
|
220 |
|
221 | if (keys.length !== new Set(keys).size) {
|
222 | throw new Error(`Can't parse keybinding ${keybinding} Duplicate modifiers`);
|
223 | }
|
224 | for (let keyString of keys) {
|
225 | if (SPECIAL_ALIASES[keyString] !== undefined) {
|
226 | keyString = SPECIAL_ALIASES[keyString];
|
227 | }
|
228 | const key = EASY_TO_KEY[keyString];
|
229 |
|
230 | if (keyString === SpecialCases.META) {
|
231 | if (os_1.isOSX) {
|
232 | schema.meta = true;
|
233 | }
|
234 | else {
|
235 | throw new Error(`Can't parse keybinding ${keybinding} meta is for OSX only`);
|
236 | }
|
237 |
|
238 | }
|
239 | else if (keyString === SpecialCases.CTRLCMD) {
|
240 | if (os_1.isOSX) {
|
241 | schema.meta = true;
|
242 | }
|
243 | else {
|
244 | schema.ctrl = true;
|
245 | }
|
246 | }
|
247 | else if (Key.isKey(key)) {
|
248 | if (Key.isModifier(key.code)) {
|
249 | if (key.code === Key.CONTROL_LEFT.code || key.code === Key.CONTROL_RIGHT.code) {
|
250 | schema.ctrl = true;
|
251 | }
|
252 | else if (key.code === Key.SHIFT_LEFT.code || key.code === Key.SHIFT_RIGHT.code) {
|
253 | schema.shift = true;
|
254 | }
|
255 | else if (key.code === Key.ALT_LEFT.code || key.code === Key.ALT_RIGHT.code) {
|
256 | schema.alt = true;
|
257 | }
|
258 | }
|
259 | else {
|
260 | schema.key = key;
|
261 | }
|
262 | }
|
263 | else {
|
264 | throw new Error(`Unrecognized key '${keyString}' in '${keybinding}'`);
|
265 | }
|
266 | }
|
267 | KeyCode.keybindings[keybinding] = new KeyCode(schema);
|
268 | return KeyCode.keybindings[keybinding];
|
269 | }
|
270 | }
|
271 | exports.KeyCode = KeyCode;
|
272 | KeyCode.keybindings = {};
|
273 | (function (KeyCode) {
|
274 | |
275 |
|
276 |
|
277 | function isModifierString(key) {
|
278 | return key === KeyModifier.CtrlCmd
|
279 | || key === KeyModifier.Shift
|
280 | || key === KeyModifier.Alt
|
281 | || key === KeyModifier.MacCtrl;
|
282 | }
|
283 | KeyCode.isModifierString = isModifierString;
|
284 | |
285 |
|
286 |
|
287 |
|
288 |
|
289 |
|
290 |
|
291 |
|
292 |
|
293 | function isKeyboardEvent(event) {
|
294 | if (typeof KeyboardEvent === 'undefined') {
|
295 | return false;
|
296 | }
|
297 | if (event instanceof KeyboardEvent) {
|
298 | return true;
|
299 | }
|
300 | const { type } = event;
|
301 | if (type) {
|
302 | return type === 'keypress' || type === 'keydown' || type === 'keyup';
|
303 | }
|
304 | return false;
|
305 | }
|
306 | KeyCode.isKeyboardEvent = isKeyboardEvent;
|
307 | |
308 |
|
309 |
|
310 |
|
311 |
|
312 |
|
313 |
|
314 | function toKey(event, dispatch = 'code') {
|
315 | const code = event.code;
|
316 | if (code && dispatch === 'code') {
|
317 | if (os_1.isOSX) {
|
318 |
|
319 | const char = event.key;
|
320 | if (code === 'IntlBackslash' && (char === '`' || char === '~')) {
|
321 | return Key.BACKQUOTE;
|
322 | }
|
323 | else if (code === 'Backquote' && (char === '§' || char === '±')) {
|
324 | return Key.INTL_BACKSLASH;
|
325 | }
|
326 | }
|
327 |
|
328 | if (code.startsWith('Numpad') && event.key && event.key.length > 1) {
|
329 | const k = Key.getKey(event.key);
|
330 | if (k) {
|
331 | return k;
|
332 | }
|
333 | }
|
334 | const key = Key.getKey(code);
|
335 | if (key) {
|
336 | return key;
|
337 | }
|
338 | }
|
339 |
|
340 | const keyCode = event.keyCode;
|
341 | if (keyCode) {
|
342 | const key = Key.getKey(keyCode);
|
343 | if (key) {
|
344 | return key;
|
345 | }
|
346 | }
|
347 | const keyIdentifier = event.keyIdentifier;
|
348 | if (keyIdentifier) {
|
349 | const key = Key.getKey(keyIdentifier);
|
350 | if (key) {
|
351 | return key;
|
352 | }
|
353 | }
|
354 | throw new Error(`Cannot get key code from the keyboard event: ${event}.`);
|
355 | }
|
356 | KeyCode.toKey = toKey;
|
357 | |
358 |
|
359 |
|
360 |
|
361 |
|
362 | function toCharacter(event) {
|
363 | const key = event.key;
|
364 |
|
365 | if (key && Array.from(key).length === 1) {
|
366 | return key;
|
367 | }
|
368 | const charCode = event.charCode;
|
369 |
|
370 | if (charCode && charCode > 0x1f && !(charCode >= 0x80 && charCode <= 0x9f)) {
|
371 | return String.fromCharCode(charCode);
|
372 | }
|
373 | return undefined;
|
374 | }
|
375 | KeyCode.toCharacter = toCharacter;
|
376 | })(KeyCode = exports.KeyCode || (exports.KeyCode = {}));
|
377 | var KeyModifier;
|
378 | (function (KeyModifier) {
|
379 | |
380 |
|
381 |
|
382 | KeyModifier["CtrlCmd"] = "M1";
|
383 | |
384 |
|
385 |
|
386 | KeyModifier["Shift"] = "M2";
|
387 | |
388 |
|
389 |
|
390 | KeyModifier["Alt"] = "M3";
|
391 | |
392 |
|
393 |
|
394 | KeyModifier["MacCtrl"] = "M4";
|
395 | })(KeyModifier = exports.KeyModifier || (exports.KeyModifier = {}));
|
396 | (function (KeyModifier) {
|
397 | |
398 |
|
399 |
|
400 |
|
401 | KeyModifier.CTRL = os_1.isOSX ? KeyModifier.MacCtrl : KeyModifier.CtrlCmd;
|
402 | |
403 |
|
404 |
|
405 | KeyModifier.SHIFT = KeyModifier.Shift;
|
406 | |
407 |
|
408 |
|
409 | function isModifier(key) {
|
410 | if (key) {
|
411 | switch (key) {
|
412 | case 'M1':
|
413 | case 'M2':
|
414 | case 'M3':
|
415 | case 'M4': return true;
|
416 | default: return false;
|
417 | }
|
418 | }
|
419 | return false;
|
420 | }
|
421 | KeyModifier.isModifier = isModifier;
|
422 | })(KeyModifier = exports.KeyModifier || (exports.KeyModifier = {}));
|
423 | const CODE_TO_KEY = {};
|
424 | const KEY_CODE_TO_KEY = {};
|
425 | const EASY_TO_KEY = {};
|
426 | const MODIFIERS = [];
|
427 | const SPECIAL_ALIASES = {
|
428 | 'option': 'alt',
|
429 | 'command': 'meta',
|
430 | 'cmd': 'meta',
|
431 | 'return': 'enter',
|
432 | 'esc': 'escape',
|
433 | 'mod': 'ctrl',
|
434 | 'ins': 'insert',
|
435 | 'del': 'delete',
|
436 | 'control': 'ctrl',
|
437 | };
|
438 | var SpecialCases;
|
439 | (function (SpecialCases) {
|
440 | SpecialCases.META = 'meta';
|
441 | SpecialCases.CTRLCMD = 'ctrlcmd';
|
442 | })(SpecialCases = exports.SpecialCases || (exports.SpecialCases = {}));
|
443 | var Key;
|
444 | (function (Key) {
|
445 |
|
446 | function isKey(arg) {
|
447 | return typeof arg === 'object' && ('code' in arg) && ('keyCode' in arg);
|
448 | }
|
449 | Key.isKey = isKey;
|
450 | function getKey(arg) {
|
451 | if (typeof arg === 'number') {
|
452 | return KEY_CODE_TO_KEY[arg];
|
453 | }
|
454 | else {
|
455 | return CODE_TO_KEY[arg];
|
456 | }
|
457 | }
|
458 | Key.getKey = getKey;
|
459 | function isModifier(arg) {
|
460 | if (typeof arg === 'number') {
|
461 | return MODIFIERS.find(key => key.keyCode === arg) !== undefined;
|
462 | }
|
463 | return MODIFIERS.find(key => key.code === arg) !== undefined;
|
464 | }
|
465 | Key.isModifier = isModifier;
|
466 | function equals(key, keyCode) {
|
467 | return !!keyCode.key && key.keyCode === keyCode.key.keyCode;
|
468 | }
|
469 | Key.equals = equals;
|
470 | Key.BACKSPACE = { code: 'Backspace', keyCode: 8, easyString: 'backspace' };
|
471 | Key.TAB = { code: 'Tab', keyCode: 9, easyString: 'tab' };
|
472 | Key.ENTER = { code: 'Enter', keyCode: 13, easyString: 'enter' };
|
473 | Key.ESCAPE = { code: 'Escape', keyCode: 27, easyString: 'escape' };
|
474 | Key.SPACE = { code: 'Space', keyCode: 32, easyString: 'space' };
|
475 | Key.PAGE_UP = { code: 'PageUp', keyCode: 33, easyString: 'pageup' };
|
476 | Key.PAGE_DOWN = { code: 'PageDown', keyCode: 34, easyString: 'pagedown' };
|
477 | Key.END = { code: 'End', keyCode: 35, easyString: 'end' };
|
478 | Key.HOME = { code: 'Home', keyCode: 36, easyString: 'home' };
|
479 | Key.ARROW_LEFT = { code: 'ArrowLeft', keyCode: 37, easyString: 'left' };
|
480 | Key.ARROW_UP = { code: 'ArrowUp', keyCode: 38, easyString: 'up' };
|
481 | Key.ARROW_RIGHT = { code: 'ArrowRight', keyCode: 39, easyString: 'right' };
|
482 | Key.ARROW_DOWN = { code: 'ArrowDown', keyCode: 40, easyString: 'down' };
|
483 | Key.INSERT = { code: 'Insert', keyCode: 45, easyString: 'insert' };
|
484 | Key.DELETE = { code: 'Delete', keyCode: 46, easyString: 'delete' };
|
485 | Key.SHIFT_LEFT = { code: 'ShiftLeft', keyCode: 16, easyString: 'shift' };
|
486 | Key.SHIFT_RIGHT = { code: 'ShiftRight', keyCode: 16, easyString: 'shift' };
|
487 | Key.CONTROL_LEFT = { code: 'ControlLeft', keyCode: 17, easyString: 'ctrl' };
|
488 | Key.CONTROL_RIGHT = { code: 'ControlRight', keyCode: 17, easyString: 'ctrl' };
|
489 | Key.ALT_LEFT = { code: 'AltLeft', keyCode: 18, easyString: 'alt' };
|
490 | Key.ALT_RIGHT = { code: 'AltRight', keyCode: 18, easyString: 'alt' };
|
491 | Key.CAPS_LOCK = { code: 'CapsLock', keyCode: 20, easyString: 'capslock' };
|
492 | Key.OS_LEFT = { code: 'OSLeft', keyCode: 91, easyString: 'super' };
|
493 | Key.OS_RIGHT = { code: 'OSRight', keyCode: 92, easyString: 'super' };
|
494 | Key.DIGIT0 = { code: 'Digit0', keyCode: 48, easyString: '0' };
|
495 | Key.DIGIT1 = { code: 'Digit1', keyCode: 49, easyString: '1' };
|
496 | Key.DIGIT2 = { code: 'Digit2', keyCode: 50, easyString: '2' };
|
497 | Key.DIGIT3 = { code: 'Digit3', keyCode: 51, easyString: '3' };
|
498 | Key.DIGIT4 = { code: 'Digit4', keyCode: 52, easyString: '4' };
|
499 | Key.DIGIT5 = { code: 'Digit5', keyCode: 53, easyString: '5' };
|
500 | Key.DIGIT6 = { code: 'Digit6', keyCode: 54, easyString: '6' };
|
501 | Key.DIGIT7 = { code: 'Digit7', keyCode: 55, easyString: '7' };
|
502 | Key.DIGIT8 = { code: 'Digit8', keyCode: 56, easyString: '8' };
|
503 | Key.DIGIT9 = { code: 'Digit9', keyCode: 57, easyString: '9' };
|
504 | Key.KEY_A = { code: 'KeyA', keyCode: 65, easyString: 'a' };
|
505 | Key.KEY_B = { code: 'KeyB', keyCode: 66, easyString: 'b' };
|
506 | Key.KEY_C = { code: 'KeyC', keyCode: 67, easyString: 'c' };
|
507 | Key.KEY_D = { code: 'KeyD', keyCode: 68, easyString: 'd' };
|
508 | Key.KEY_E = { code: 'KeyE', keyCode: 69, easyString: 'e' };
|
509 | Key.KEY_F = { code: 'KeyF', keyCode: 70, easyString: 'f' };
|
510 | Key.KEY_G = { code: 'KeyG', keyCode: 71, easyString: 'g' };
|
511 | Key.KEY_H = { code: 'KeyH', keyCode: 72, easyString: 'h' };
|
512 | Key.KEY_I = { code: 'KeyI', keyCode: 73, easyString: 'i' };
|
513 | Key.KEY_J = { code: 'KeyJ', keyCode: 74, easyString: 'j' };
|
514 | Key.KEY_K = { code: 'KeyK', keyCode: 75, easyString: 'k' };
|
515 | Key.KEY_L = { code: 'KeyL', keyCode: 76, easyString: 'l' };
|
516 | Key.KEY_M = { code: 'KeyM', keyCode: 77, easyString: 'm' };
|
517 | Key.KEY_N = { code: 'KeyN', keyCode: 78, easyString: 'n' };
|
518 | Key.KEY_O = { code: 'KeyO', keyCode: 79, easyString: 'o' };
|
519 | Key.KEY_P = { code: 'KeyP', keyCode: 80, easyString: 'p' };
|
520 | Key.KEY_Q = { code: 'KeyQ', keyCode: 81, easyString: 'q' };
|
521 | Key.KEY_R = { code: 'KeyR', keyCode: 82, easyString: 'r' };
|
522 | Key.KEY_S = { code: 'KeyS', keyCode: 83, easyString: 's' };
|
523 | Key.KEY_T = { code: 'KeyT', keyCode: 84, easyString: 't' };
|
524 | Key.KEY_U = { code: 'KeyU', keyCode: 85, easyString: 'u' };
|
525 | Key.KEY_V = { code: 'KeyV', keyCode: 86, easyString: 'v' };
|
526 | Key.KEY_W = { code: 'KeyW', keyCode: 87, easyString: 'w' };
|
527 | Key.KEY_X = { code: 'KeyX', keyCode: 88, easyString: 'x' };
|
528 | Key.KEY_Y = { code: 'KeyY', keyCode: 89, easyString: 'y' };
|
529 | Key.KEY_Z = { code: 'KeyZ', keyCode: 90, easyString: 'z' };
|
530 | Key.MULTIPLY = { code: 'NumpadMultiply', keyCode: 106, easyString: 'multiply' };
|
531 | Key.ADD = { code: 'NumpadAdd', keyCode: 107, easyString: 'add' };
|
532 | Key.DECIMAL = { code: 'NumpadDecimal', keyCode: 108, easyString: 'decimal' };
|
533 | Key.SUBTRACT = { code: 'NumpadSubtract', keyCode: 109, easyString: 'subtract' };
|
534 | Key.DIVIDE = { code: 'NumpadDivide', keyCode: 111, easyString: 'divide' };
|
535 | Key.F1 = { code: 'F1', keyCode: 112, easyString: 'f1' };
|
536 | Key.F2 = { code: 'F2', keyCode: 113, easyString: 'f2' };
|
537 | Key.F3 = { code: 'F3', keyCode: 114, easyString: 'f3' };
|
538 | Key.F4 = { code: 'F4', keyCode: 115, easyString: 'f4' };
|
539 | Key.F5 = { code: 'F5', keyCode: 116, easyString: 'f5' };
|
540 | Key.F6 = { code: 'F6', keyCode: 117, easyString: 'f6' };
|
541 | Key.F7 = { code: 'F7', keyCode: 118, easyString: 'f7' };
|
542 | Key.F8 = { code: 'F8', keyCode: 119, easyString: 'f8' };
|
543 | Key.F9 = { code: 'F9', keyCode: 120, easyString: 'f9' };
|
544 | Key.F10 = { code: 'F10', keyCode: 121, easyString: 'f10' };
|
545 | Key.F11 = { code: 'F11', keyCode: 122, easyString: 'f11' };
|
546 | Key.F12 = { code: 'F12', keyCode: 123, easyString: 'f12' };
|
547 | Key.F13 = { code: 'F13', keyCode: 124, easyString: 'f13' };
|
548 | Key.F14 = { code: 'F14', keyCode: 125, easyString: 'f14' };
|
549 | Key.F15 = { code: 'F15', keyCode: 126, easyString: 'f15' };
|
550 | Key.F16 = { code: 'F16', keyCode: 127, easyString: 'f16' };
|
551 | Key.F17 = { code: 'F17', keyCode: 128, easyString: 'f17' };
|
552 | Key.F18 = { code: 'F18', keyCode: 129, easyString: 'f18' };
|
553 | Key.F19 = { code: 'F19', keyCode: 130, easyString: 'f19' };
|
554 | Key.F20 = { code: 'F20', keyCode: 131, easyString: 'f20' };
|
555 | Key.F21 = { code: 'F21', keyCode: 132, easyString: 'f21' };
|
556 | Key.F22 = { code: 'F22', keyCode: 133, easyString: 'f22' };
|
557 | Key.F23 = { code: 'F23', keyCode: 134, easyString: 'f23' };
|
558 | Key.F24 = { code: 'F24', keyCode: 135, easyString: 'f24' };
|
559 | Key.NUM_LOCK = { code: 'NumLock', keyCode: 144, easyString: 'numlock' };
|
560 | Key.SEMICOLON = { code: 'Semicolon', keyCode: 186, easyString: ';' };
|
561 | Key.EQUAL = { code: 'Equal', keyCode: 187, easyString: '=' };
|
562 | Key.COMMA = { code: 'Comma', keyCode: 188, easyString: ',' };
|
563 | Key.MINUS = { code: 'Minus', keyCode: 189, easyString: '-' };
|
564 | Key.PERIOD = { code: 'Period', keyCode: 190, easyString: '.' };
|
565 | Key.SLASH = { code: 'Slash', keyCode: 191, easyString: '/' };
|
566 | Key.BACKQUOTE = { code: 'Backquote', keyCode: 192, easyString: '`' };
|
567 | Key.INTL_RO = { code: 'IntlRo', keyCode: 193, easyString: 'intlro' };
|
568 | Key.BRACKET_LEFT = { code: 'BracketLeft', keyCode: 219, easyString: '[' };
|
569 | Key.BACKSLASH = { code: 'Backslash', keyCode: 220, easyString: '\\' };
|
570 | Key.BRACKET_RIGHT = { code: 'BracketRight', keyCode: 221, easyString: ']' };
|
571 | Key.QUOTE = { code: 'Quote', keyCode: 222, easyString: '\'' };
|
572 | Key.INTL_BACKSLASH = { code: 'IntlBackslash', keyCode: 229, easyString: 'intlbackslash' };
|
573 | Key.INTL_YEN = { code: 'IntlYen', keyCode: 255, easyString: 'intlyen' };
|
574 | Key.MAX_KEY_CODE = Key.INTL_YEN.keyCode;
|
575 | })(Key = exports.Key || (exports.Key = {}));
|
576 |
|
577 | (() => {
|
578 |
|
579 | Object.keys(Key).map(prop => Reflect.get(Key, prop)).filter(key => Key.isKey(key)).forEach(key => {
|
580 | CODE_TO_KEY[key.code] = key;
|
581 | KEY_CODE_TO_KEY[key.keyCode] = key;
|
582 | EASY_TO_KEY[key.easyString] = key;
|
583 | });
|
584 |
|
585 | CODE_TO_KEY['Numpad0'] = Key.DIGIT0;
|
586 | KEY_CODE_TO_KEY[96] = Key.DIGIT0;
|
587 | CODE_TO_KEY['Numpad1'] = Key.DIGIT1;
|
588 | KEY_CODE_TO_KEY[97] = Key.DIGIT1;
|
589 | CODE_TO_KEY['Numpad2'] = Key.DIGIT2;
|
590 | KEY_CODE_TO_KEY[98] = Key.DIGIT2;
|
591 | CODE_TO_KEY['Numpad3'] = Key.DIGIT3;
|
592 | KEY_CODE_TO_KEY[99] = Key.DIGIT3;
|
593 | CODE_TO_KEY['Numpad4'] = Key.DIGIT4;
|
594 | KEY_CODE_TO_KEY[100] = Key.DIGIT4;
|
595 | CODE_TO_KEY['Numpad5'] = Key.DIGIT5;
|
596 | KEY_CODE_TO_KEY[101] = Key.DIGIT5;
|
597 | CODE_TO_KEY['Numpad6'] = Key.DIGIT6;
|
598 | KEY_CODE_TO_KEY[102] = Key.DIGIT6;
|
599 | CODE_TO_KEY['Numpad7'] = Key.DIGIT7;
|
600 | KEY_CODE_TO_KEY[103] = Key.DIGIT7;
|
601 | CODE_TO_KEY['Numpad8'] = Key.DIGIT8;
|
602 | KEY_CODE_TO_KEY[104] = Key.DIGIT8;
|
603 | CODE_TO_KEY['Numpad9'] = Key.DIGIT9;
|
604 | KEY_CODE_TO_KEY[105] = Key.DIGIT9;
|
605 | CODE_TO_KEY['NumpadEnter'] = Key.ENTER;
|
606 | CODE_TO_KEY['NumpadEqual'] = Key.EQUAL;
|
607 | CODE_TO_KEY['MetaLeft'] = Key.OS_LEFT;
|
608 | KEY_CODE_TO_KEY[224] = Key.OS_LEFT;
|
609 | CODE_TO_KEY['MetaRight'] = Key.OS_RIGHT;
|
610 | KEY_CODE_TO_KEY[93] = Key.OS_RIGHT;
|
611 | KEY_CODE_TO_KEY[225] = Key.ALT_RIGHT;
|
612 | KEY_CODE_TO_KEY[110] = Key.DECIMAL;
|
613 | KEY_CODE_TO_KEY[59] = Key.SEMICOLON;
|
614 | KEY_CODE_TO_KEY[61] = Key.EQUAL;
|
615 | KEY_CODE_TO_KEY[173] = Key.MINUS;
|
616 | KEY_CODE_TO_KEY[226] = Key.BACKSLASH;
|
617 | KEY_CODE_TO_KEY[60] = Key.BACKSLASH;
|
618 |
|
619 | MODIFIERS.push(...[Key.ALT_LEFT, Key.ALT_RIGHT, Key.CONTROL_LEFT, Key.CONTROL_RIGHT, Key.OS_LEFT, Key.OS_RIGHT, Key.SHIFT_LEFT, Key.SHIFT_RIGHT]);
|
620 | })();
|
621 | var KeysOrKeyCodes;
|
622 | (function (KeysOrKeyCodes) {
|
623 | KeysOrKeyCodes.toKeyCode = (keyOrKeyCode) => keyOrKeyCode instanceof KeyCode ? keyOrKeyCode : KeyCode.createKeyCode({ first: keyOrKeyCode });
|
624 | KeysOrKeyCodes.toKeyCodes = (keysOrKeyCodes) => {
|
625 | if (keysOrKeyCodes instanceof KeyCode) {
|
626 | return [keysOrKeyCodes];
|
627 | }
|
628 | else if (Array.isArray(keysOrKeyCodes)) {
|
629 | return keysOrKeyCodes.slice().map(KeysOrKeyCodes.toKeyCode);
|
630 | }
|
631 | return [KeysOrKeyCodes.toKeyCode(keysOrKeyCodes)];
|
632 | };
|
633 | })(KeysOrKeyCodes = exports.KeysOrKeyCodes || (exports.KeysOrKeyCodes = {}));
|
634 |
|
\ | No newline at end of file |