1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 | (function (global, factory) {
|
11 | typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
|
12 | typeof define === 'function' && define.amd ? define(factory) :
|
13 | (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.hotkeys = factory());
|
14 | })(this, (function () { 'use strict';
|
15 |
|
16 | var isff = typeof navigator !== 'undefined' ? navigator.userAgent.toLowerCase().indexOf('firefox') > 0 : false;
|
17 |
|
18 | function addEvent(object, event, method, useCapture) {
|
19 | if (object.addEventListener) {
|
20 | object.addEventListener(event, method, useCapture);
|
21 | } else if (object.attachEvent) {
|
22 | object.attachEvent("on".concat(event), function () {
|
23 | method(window.event);
|
24 | });
|
25 | }
|
26 | }
|
27 |
|
28 |
|
29 | function getMods(modifier, key) {
|
30 | var mods = key.slice(0, key.length - 1);
|
31 |
|
32 | for (var i = 0; i < mods.length; i++) {
|
33 | mods[i] = modifier[mods[i].toLowerCase()];
|
34 | }
|
35 |
|
36 | return mods;
|
37 | }
|
38 |
|
39 |
|
40 | function getKeys(key) {
|
41 | if (typeof key !== 'string') key = '';
|
42 | key = key.replace(/\s/g, '');
|
43 |
|
44 | var keys = key.split(',');
|
45 |
|
46 | var index = keys.lastIndexOf('');
|
47 |
|
48 | for (; index >= 0;) {
|
49 | keys[index - 1] += ',';
|
50 | keys.splice(index, 1);
|
51 | index = keys.lastIndexOf('');
|
52 | }
|
53 |
|
54 | return keys;
|
55 | }
|
56 |
|
57 |
|
58 | function compareArray(a1, a2) {
|
59 | var arr1 = a1.length >= a2.length ? a1 : a2;
|
60 | var arr2 = a1.length >= a2.length ? a2 : a1;
|
61 | var isIndex = true;
|
62 |
|
63 | for (var i = 0; i < arr1.length; i++) {
|
64 | if (arr2.indexOf(arr1[i]) === -1) isIndex = false;
|
65 | }
|
66 |
|
67 | return isIndex;
|
68 | }
|
69 |
|
70 | var _keyMap = {
|
71 | backspace: 8,
|
72 | tab: 9,
|
73 | clear: 12,
|
74 | enter: 13,
|
75 | return: 13,
|
76 | esc: 27,
|
77 | escape: 27,
|
78 | space: 32,
|
79 | left: 37,
|
80 | up: 38,
|
81 | right: 39,
|
82 | down: 40,
|
83 | del: 46,
|
84 | delete: 46,
|
85 | ins: 45,
|
86 | insert: 45,
|
87 | home: 36,
|
88 | end: 35,
|
89 | pageup: 33,
|
90 | pagedown: 34,
|
91 | capslock: 20,
|
92 | num_0: 96,
|
93 | num_1: 97,
|
94 | num_2: 98,
|
95 | num_3: 99,
|
96 | num_4: 100,
|
97 | num_5: 101,
|
98 | num_6: 102,
|
99 | num_7: 103,
|
100 | num_8: 104,
|
101 | num_9: 105,
|
102 | num_multiply: 106,
|
103 | num_add: 107,
|
104 | num_enter: 108,
|
105 | num_subtract: 109,
|
106 | num_decimal: 110,
|
107 | num_divide: 111,
|
108 | '⇪': 20,
|
109 | ',': 188,
|
110 | '.': 190,
|
111 | '/': 191,
|
112 | '`': 192,
|
113 | '-': isff ? 173 : 189,
|
114 | '=': isff ? 61 : 187,
|
115 | ';': isff ? 59 : 186,
|
116 | '\'': 222,
|
117 | '[': 219,
|
118 | ']': 221,
|
119 | '\\': 220
|
120 | };
|
121 |
|
122 | var _modifier = {
|
123 |
|
124 | '⇧': 16,
|
125 | shift: 16,
|
126 |
|
127 | '⌥': 18,
|
128 | alt: 18,
|
129 | option: 18,
|
130 |
|
131 | '⌃': 17,
|
132 | ctrl: 17,
|
133 | control: 17,
|
134 |
|
135 | '⌘': 91,
|
136 | cmd: 91,
|
137 | command: 91
|
138 | };
|
139 | var modifierMap = {
|
140 | 16: 'shiftKey',
|
141 | 18: 'altKey',
|
142 | 17: 'ctrlKey',
|
143 | 91: 'metaKey',
|
144 | shiftKey: 16,
|
145 | ctrlKey: 17,
|
146 | altKey: 18,
|
147 | metaKey: 91
|
148 | };
|
149 | var _mods = {
|
150 | 16: false,
|
151 | 18: false,
|
152 | 17: false,
|
153 | 91: false
|
154 | };
|
155 | var _handlers = {};
|
156 |
|
157 | for (var k = 1; k < 20; k++) {
|
158 | _keyMap["f".concat(k)] = 111 + k;
|
159 | }
|
160 |
|
161 | var _downKeys = [];
|
162 |
|
163 | var winListendFocus = false;
|
164 |
|
165 | var _scope = 'all';
|
166 |
|
167 | var elementHasBindEvent = [];
|
168 |
|
169 |
|
170 | var code = function code(x) {
|
171 | return _keyMap[x.toLowerCase()] || _modifier[x.toLowerCase()] || x.toUpperCase().charCodeAt(0);
|
172 | };
|
173 |
|
174 |
|
175 | function setScope(scope) {
|
176 | _scope = scope || 'all';
|
177 | }
|
178 |
|
179 |
|
180 | function getScope() {
|
181 | return _scope || 'all';
|
182 | }
|
183 |
|
184 |
|
185 | function getPressedKeyCodes() {
|
186 | return _downKeys.slice(0);
|
187 | }
|
188 |
|
189 |
|
190 |
|
191 | function filter(event) {
|
192 | var target = event.target || event.srcElement;
|
193 | var tagName = target.tagName;
|
194 | var flag = true;
|
195 |
|
196 | if (target.isContentEditable || (tagName === 'INPUT' || tagName === 'TEXTAREA' || tagName === 'SELECT') && !target.readOnly) {
|
197 | flag = false;
|
198 | }
|
199 |
|
200 | return flag;
|
201 | }
|
202 |
|
203 |
|
204 | function isPressed(keyCode) {
|
205 | if (typeof keyCode === 'string') {
|
206 | keyCode = code(keyCode);
|
207 | }
|
208 |
|
209 | return _downKeys.indexOf(keyCode) !== -1;
|
210 | }
|
211 |
|
212 |
|
213 | function deleteScope(scope, newScope) {
|
214 | var handlers;
|
215 | var i;
|
216 |
|
217 | if (!scope) scope = getScope();
|
218 |
|
219 | for (var key in _handlers) {
|
220 | if (Object.prototype.hasOwnProperty.call(_handlers, key)) {
|
221 | handlers = _handlers[key];
|
222 |
|
223 | for (i = 0; i < handlers.length;) {
|
224 | if (handlers[i].scope === scope) handlers.splice(i, 1);else i++;
|
225 | }
|
226 | }
|
227 | }
|
228 |
|
229 |
|
230 | if (getScope() === scope) setScope(newScope || 'all');
|
231 | }
|
232 |
|
233 |
|
234 | function clearModifier(event) {
|
235 | var key = event.keyCode || event.which || event.charCode;
|
236 |
|
237 | var i = _downKeys.indexOf(key);
|
238 |
|
239 |
|
240 | if (i >= 0) {
|
241 | _downKeys.splice(i, 1);
|
242 | }
|
243 |
|
244 |
|
245 | if (event.key && event.key.toLowerCase() === 'meta') {
|
246 | _downKeys.splice(0, _downKeys.length);
|
247 | }
|
248 |
|
249 |
|
250 | if (key === 93 || key === 224) key = 91;
|
251 |
|
252 | if (key in _mods) {
|
253 | _mods[key] = false;
|
254 |
|
255 | for (var k in _modifier) {
|
256 | if (_modifier[k] === key) hotkeys[k] = false;
|
257 | }
|
258 | }
|
259 | }
|
260 |
|
261 | function unbind(keysInfo) {
|
262 |
|
263 | if (typeof keysInfo === 'undefined') {
|
264 | Object.keys(_handlers).forEach(function (key) {
|
265 | return delete _handlers[key];
|
266 | });
|
267 | } else if (Array.isArray(keysInfo)) {
|
268 |
|
269 | keysInfo.forEach(function (info) {
|
270 | if (info.key) eachUnbind(info);
|
271 | });
|
272 | } else if (typeof keysInfo === 'object') {
|
273 |
|
274 | if (keysInfo.key) eachUnbind(keysInfo);
|
275 | } else if (typeof keysInfo === 'string') {
|
276 | for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
277 | args[_key - 1] = arguments[_key];
|
278 | }
|
279 |
|
280 |
|
281 |
|
282 | var scope = args[0],
|
283 | method = args[1];
|
284 |
|
285 | if (typeof scope === 'function') {
|
286 | method = scope;
|
287 | scope = '';
|
288 | }
|
289 |
|
290 | eachUnbind({
|
291 | key: keysInfo,
|
292 | scope: scope,
|
293 | method: method,
|
294 | splitKey: '+'
|
295 | });
|
296 | }
|
297 | }
|
298 |
|
299 |
|
300 | var eachUnbind = function eachUnbind(_ref) {
|
301 | var key = _ref.key,
|
302 | scope = _ref.scope,
|
303 | method = _ref.method,
|
304 | _ref$splitKey = _ref.splitKey,
|
305 | splitKey = _ref$splitKey === void 0 ? '+' : _ref$splitKey;
|
306 | var multipleKeys = getKeys(key);
|
307 | multipleKeys.forEach(function (originKey) {
|
308 | var unbindKeys = originKey.split(splitKey);
|
309 | var len = unbindKeys.length;
|
310 | var lastKey = unbindKeys[len - 1];
|
311 | var keyCode = lastKey === '*' ? '*' : code(lastKey);
|
312 | if (!_handlers[keyCode]) return;
|
313 |
|
314 | if (!scope) scope = getScope();
|
315 | var mods = len > 1 ? getMods(_modifier, unbindKeys) : [];
|
316 | _handlers[keyCode] = _handlers[keyCode].filter(function (record) {
|
317 |
|
318 | var isMatchingMethod = method ? record.method === method : true;
|
319 | return !(isMatchingMethod && record.scope === scope && compareArray(record.mods, mods));
|
320 | });
|
321 | });
|
322 | };
|
323 |
|
324 |
|
325 | function eventHandler(event, handler, scope, element) {
|
326 | if (handler.element !== element) {
|
327 | return;
|
328 | }
|
329 |
|
330 | var modifiersMatch;
|
331 |
|
332 | if (handler.scope === scope || handler.scope === 'all') {
|
333 |
|
334 | modifiersMatch = handler.mods.length > 0;
|
335 |
|
336 | for (var y in _mods) {
|
337 | if (Object.prototype.hasOwnProperty.call(_mods, y)) {
|
338 | if (!_mods[y] && handler.mods.indexOf(+y) > -1 || _mods[y] && handler.mods.indexOf(+y) === -1) {
|
339 | modifiersMatch = false;
|
340 | }
|
341 | }
|
342 | }
|
343 |
|
344 |
|
345 | if (handler.mods.length === 0 && !_mods[16] && !_mods[18] && !_mods[17] && !_mods[91] || modifiersMatch || handler.shortcut === '*') {
|
346 | if (handler.method(event, handler) === false) {
|
347 | if (event.preventDefault) event.preventDefault();else event.returnValue = false;
|
348 | if (event.stopPropagation) event.stopPropagation();
|
349 | if (event.cancelBubble) event.cancelBubble = true;
|
350 | }
|
351 | }
|
352 | }
|
353 | }
|
354 |
|
355 |
|
356 | function dispatch(event, element) {
|
357 | var asterisk = _handlers['*'];
|
358 | var key = event.keyCode || event.which || event.charCode;
|
359 |
|
360 | if (!hotkeys.filter.call(this, event)) return;
|
361 |
|
362 |
|
363 | if (key === 93 || key === 224) key = 91;
|
364 | |
365 |
|
366 |
|
367 |
|
368 |
|
369 |
|
370 |
|
371 | if (_downKeys.indexOf(key) === -1 && key !== 229) _downKeys.push(key);
|
372 | |
373 |
|
374 |
|
375 |
|
376 |
|
377 | ['ctrlKey', 'altKey', 'shiftKey', 'metaKey'].forEach(function (keyName) {
|
378 | var keyNum = modifierMap[keyName];
|
379 |
|
380 | if (event[keyName] && _downKeys.indexOf(keyNum) === -1) {
|
381 | _downKeys.push(keyNum);
|
382 | } else if (!event[keyName] && _downKeys.indexOf(keyNum) > -1) {
|
383 | _downKeys.splice(_downKeys.indexOf(keyNum), 1);
|
384 | } else if (keyName === 'metaKey' && event[keyName] && _downKeys.length === 3) {
|
385 | |
386 |
|
387 |
|
388 |
|
389 | if (!(event.ctrlKey || event.shiftKey || event.altKey)) {
|
390 | _downKeys = _downKeys.slice(_downKeys.indexOf(keyNum));
|
391 | }
|
392 | }
|
393 | });
|
394 | |
395 |
|
396 |
|
397 |
|
398 | if (key in _mods) {
|
399 | _mods[key] = true;
|
400 |
|
401 | for (var k in _modifier) {
|
402 | if (_modifier[k] === key) hotkeys[k] = true;
|
403 | }
|
404 |
|
405 | if (!asterisk) return;
|
406 | }
|
407 |
|
408 |
|
409 | for (var e in _mods) {
|
410 | if (Object.prototype.hasOwnProperty.call(_mods, e)) {
|
411 | _mods[e] = event[modifierMap[e]];
|
412 | }
|
413 | }
|
414 | |
415 |
|
416 |
|
417 |
|
418 |
|
419 |
|
420 |
|
421 |
|
422 | if (event.getModifierState && !(event.altKey && !event.ctrlKey) && event.getModifierState('AltGraph')) {
|
423 | if (_downKeys.indexOf(17) === -1) {
|
424 | _downKeys.push(17);
|
425 | }
|
426 |
|
427 | if (_downKeys.indexOf(18) === -1) {
|
428 | _downKeys.push(18);
|
429 | }
|
430 |
|
431 | _mods[17] = true;
|
432 | _mods[18] = true;
|
433 | }
|
434 |
|
435 |
|
436 | var scope = getScope();
|
437 |
|
438 | if (asterisk) {
|
439 | for (var i = 0; i < asterisk.length; i++) {
|
440 | if (asterisk[i].scope === scope && (event.type === 'keydown' && asterisk[i].keydown || event.type === 'keyup' && asterisk[i].keyup)) {
|
441 | eventHandler(event, asterisk[i], scope, element);
|
442 | }
|
443 | }
|
444 | }
|
445 |
|
446 |
|
447 | if (!(key in _handlers)) return;
|
448 |
|
449 | for (var _i = 0; _i < _handlers[key].length; _i++) {
|
450 | if (event.type === 'keydown' && _handlers[key][_i].keydown || event.type === 'keyup' && _handlers[key][_i].keyup) {
|
451 | if (_handlers[key][_i].key) {
|
452 | var record = _handlers[key][_i];
|
453 | var splitKey = record.splitKey;
|
454 | var keyShortcut = record.key.split(splitKey);
|
455 | var _downKeysCurrent = [];
|
456 |
|
457 | for (var a = 0; a < keyShortcut.length; a++) {
|
458 | _downKeysCurrent.push(code(keyShortcut[a]));
|
459 | }
|
460 |
|
461 | if (_downKeysCurrent.sort().join('') === _downKeys.sort().join('')) {
|
462 |
|
463 | eventHandler(event, record, scope, element);
|
464 | }
|
465 | }
|
466 | }
|
467 | }
|
468 | }
|
469 |
|
470 |
|
471 | function isElementBind(element) {
|
472 | return elementHasBindEvent.indexOf(element) > -1;
|
473 | }
|
474 |
|
475 | function hotkeys(key, option, method) {
|
476 | _downKeys = [];
|
477 | var keys = getKeys(key);
|
478 |
|
479 | var mods = [];
|
480 | var scope = 'all';
|
481 |
|
482 | var element = document;
|
483 |
|
484 | var i = 0;
|
485 | var keyup = false;
|
486 | var keydown = true;
|
487 | var splitKey = '+';
|
488 | var capture = false;
|
489 |
|
490 | if (method === undefined && typeof option === 'function') {
|
491 | method = option;
|
492 | }
|
493 |
|
494 | if (Object.prototype.toString.call(option) === '[object Object]') {
|
495 | if (option.scope) scope = option.scope;
|
496 |
|
497 | if (option.element) element = option.element;
|
498 |
|
499 | if (option.keyup) keyup = option.keyup;
|
500 |
|
501 | if (option.keydown !== undefined) keydown = option.keydown;
|
502 |
|
503 | if (option.capture !== undefined) capture = option.capture;
|
504 |
|
505 | if (typeof option.splitKey === 'string') splitKey = option.splitKey;
|
506 | }
|
507 |
|
508 | if (typeof option === 'string') scope = option;
|
509 |
|
510 | for (; i < keys.length; i++) {
|
511 | key = keys[i].split(splitKey);
|
512 |
|
513 | mods = [];
|
514 |
|
515 | if (key.length > 1) mods = getMods(_modifier, key);
|
516 |
|
517 | key = key[key.length - 1];
|
518 | key = key === '*' ? '*' : code(key);
|
519 |
|
520 |
|
521 | if (!(key in _handlers)) _handlers[key] = [];
|
522 |
|
523 | _handlers[key].push({
|
524 | keyup: keyup,
|
525 | keydown: keydown,
|
526 | scope: scope,
|
527 | mods: mods,
|
528 | shortcut: keys[i],
|
529 | method: method,
|
530 | key: keys[i],
|
531 | splitKey: splitKey,
|
532 | element: element
|
533 | });
|
534 | }
|
535 |
|
536 |
|
537 | if (typeof element !== 'undefined' && !isElementBind(element) && window) {
|
538 | elementHasBindEvent.push(element);
|
539 | addEvent(element, 'keydown', function (e) {
|
540 | dispatch(e, element);
|
541 | }, capture);
|
542 |
|
543 | if (!winListendFocus) {
|
544 | winListendFocus = true;
|
545 | addEvent(window, 'focus', function () {
|
546 | _downKeys = [];
|
547 | }, capture);
|
548 | }
|
549 |
|
550 | addEvent(element, 'keyup', function (e) {
|
551 | dispatch(e, element);
|
552 | clearModifier(e);
|
553 | }, capture);
|
554 | }
|
555 | }
|
556 |
|
557 | function trigger(shortcut) {
|
558 | var scope = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'all';
|
559 | Object.keys(_handlers).forEach(function (key) {
|
560 | var data = _handlers[key].find(function (item) {
|
561 | return item.scope === scope && item.shortcut === shortcut;
|
562 | });
|
563 |
|
564 | if (data && data.method) {
|
565 | data.method();
|
566 | }
|
567 | });
|
568 | }
|
569 |
|
570 | var _api = {
|
571 | setScope: setScope,
|
572 | getScope: getScope,
|
573 | deleteScope: deleteScope,
|
574 | getPressedKeyCodes: getPressedKeyCodes,
|
575 | isPressed: isPressed,
|
576 | filter: filter,
|
577 | trigger: trigger,
|
578 | unbind: unbind,
|
579 | keyMap: _keyMap,
|
580 | modifier: _modifier,
|
581 | modifierMap: modifierMap
|
582 | };
|
583 |
|
584 | for (var a in _api) {
|
585 | if (Object.prototype.hasOwnProperty.call(_api, a)) {
|
586 | hotkeys[a] = _api[a];
|
587 | }
|
588 | }
|
589 |
|
590 | if (typeof window !== 'undefined') {
|
591 | var _hotkeys = window.hotkeys;
|
592 |
|
593 | hotkeys.noConflict = function (deep) {
|
594 | if (deep && window.hotkeys === hotkeys) {
|
595 | window.hotkeys = _hotkeys;
|
596 | }
|
597 |
|
598 | return hotkeys;
|
599 | };
|
600 |
|
601 | window.hotkeys = hotkeys;
|
602 | }
|
603 |
|
604 | return hotkeys;
|
605 |
|
606 | }));
|