tplus-components-touch 3.54.1 → 3.55.1

package/dist/components/hotKey/index.js

@@ -0,0 +1,795 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
+
+var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
+
+var _from = require('babel-runtime/core-js/array/from');
+
+var _from2 = _interopRequireDefault(_from);
+
+var _getIterator2 = require('babel-runtime/core-js/get-iterator');
+
+var _getIterator3 = _interopRequireDefault(_getIterator2);
+
+var _promise = require('babel-runtime/core-js/promise');
+
+var _promise2 = _interopRequireDefault(_promise);
+
+var _extends2 = require('babel-runtime/helpers/extends');
+
+var _extends3 = _interopRequireDefault(_extends2);
+
+var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');
+
+var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
+
+var _keys = require('babel-runtime/core-js/object/keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+var _keymaster = require('keymaster');
+
+var _keymaster2 = _interopRequireDefault(_keymaster);
+
+var _utils = require('./utils');
+
+var _config = require('./config');
+
+var _hotKeyModal = require('./hotKeyModal');
+
+var _mutantsUtil = require('mutants-util');
+
+var _mutantsMicrofx = require('mutants-microfx');
+
+require('./style.less');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var keyboard = _keymaster2.default.noConflict(); /**
+                                                  * Created by hzy on 2019/11/27.
+                                                  */
+/**
+ * @hotKey(option) 调用hotKey方法初始化状态
+ * @option 可传入选项 {handler: 全局的句柄默认为$}
+ * @observerCallback dom变化后的回调
+ * @log 是否显示log
+ * @hotKeyConfig 快捷键配置项
+ * @operationControl 快捷键权限控制
+ * @clickBefore 点击事件前的回调方法
+ *
+ * 初始化后的方法
+ * action 传入第一个参数 按键字符串，触发config中的动作，返回一个promise，执行then方法可以从参数中拿到当前的上下文对象
+ * action 第二个参数为回调函数，回调函数的参数会返回当前的动作触发的元素属性以及当前为第几步
+ *
+ * observer 监听dom变化，第一个参数为监听的dom目标，第二个参数为配置  具体查看 new MutationObserver observer
+ * find 查找dom，可链式调用
+ * next 查找下一个兄弟节点，参数中可传入数量跳过几个相邻的
+ * prev 查找上一个兄弟节点，参数中可传入数量跳过几个相邻的
+ * click 触发点击事件
+ * register 注册一个全局的快捷键，第一个方法参数为快捷键名，第二个方法参数为目标容器class名，第三个方法参数为触发事件dom class名
+ * unRegister 注销一个全局的快捷键
+ *
+ * 
+ * config & control 说明 见 ./config.js 文件
+ *
+ */
+
+
+var hotKeyFactory = {
+  constructor: function constructor() {
+    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        _ref$keys = _ref.keys,
+        keys = _ref$keys === undefined ? [] : _ref$keys,
+        _ref$handler = _ref.handler,
+        handler = _ref$handler === undefined ? '$' : _ref$handler,
+        observerCallback = _ref.observerCallback,
+        pressed = _ref.pressed,
+        _ref$log = _ref.log,
+        log = _ref$log === undefined ? false : _ref$log,
+        _ref$hotKeyConfig = _ref.hotKeyConfig,
+        hotKeyConfig = _ref$hotKeyConfig === undefined ? _config.hotKeyConfig : _ref$hotKeyConfig,
+        _ref$operationControl = _ref.operationControl,
+        operationControl = _ref$operationControl === undefined ? _config.operationControl : _ref$operationControl,
+        filter = _ref.filter,
+        clickBefore = _ref.clickBefore;
+
+    // keys = ['esc', 'enter', 'ctrl+f1', ...Object.keys(hotKeyInjectOrEject)];
+    var observe = observerCallback && new MutationObserver(observerCallback);
+    hotKeyFactory.showLog = log;
+    // 如果快捷键配置不存在使用默认
+    var defineHotKeyConfig = this.getDefineHotKeyConfigByStore();
+
+    // hotKeyFactory.hotKeyConfig = Object.keys(defineHotKeyConfig).length?defineHotKeyConfig:hotKeyConfig;
+    hotKeyFactory.hotKeyConfig = (0, _keys2.default)(defineHotKeyConfig).length ? defineHotKeyConfig : hotKeyConfig;
+    keys = keys.length == 0 ? ['esc', 'enter', 'ctrl+f1'].concat((0, _toConsumableArray3.default)((0, _keys2.default)(hotKeyFactory.hotKeyConfig))) : keys;
+
+    // 删除原来挂载的按键监听
+    if (window[handler]) {
+      keyboard.deleteScope(keyboard.getScope());
+    }
+    keyboard(keys.join(), pressed);
+    keyboard.filter = filter;
+
+    var defineOperationControl = this.getDefineOperationControlByStore(hotKeyFactory.hotKeyConfig);
+    hotKeyFactory.operationControl = defineOperationControl || operationControl;
+
+    // 排序复合结算
+    if (hotKeyFactory.operationControl[5] && hotKeyFactory.operationControl[5].control && hotKeyFactory.operationControl[5].dynamicSelector) {
+      var dynamicSelector = hotKeyFactory.operationControl[5].dynamicSelector;
+      hotKeyFactory.operationControl[5].control = hotKeyFactory.newhotKeyArraySort(hotKeyFactory.operationControl[5].control, function (a, b) {
+        return dynamicSelector[a] && dynamicSelector[b] ? dynamicSelector[a][0].replace('.settlement .paymode:', '') - dynamicSelector[b][0].replace('.settlement .paymode:', '') : -1;
+      });
+    }
+
+    hotKeyFactory.clickBeforeProp = clickBefore;
+    var controller = {
+      keys: keys,
+      hotKeyConfig: hotKeyFactory.hotKeyConfig,
+      operationControl: hotKeyFactory.operationControl,
+      action: this.actuator,
+      find: this.find,
+      next: this.next,
+      find_element: this.find_element,
+      getFocusId: this.getFocusId.bind(this),
+      register: this.register,
+      unRegister: this.unRegister,
+      setFocus: this.setFocus,
+      clearFocus: this.clearFocus,
+      observerTrigger: observerCallback,
+      bind: this.bind,
+      unbind: this.unbind,
+      on: this.on,
+      off: this.off,
+      observer: function observer(dom) {
+        var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { attributes: true, childList: true, subtree: true };
+
+        var containerDom = dom || document.body;
+        observe.observe(containerDom, config);
+      }
+    };
+    // if (!window[handler]) {
+    window[handler] = controller;
+    // }
+    return controller;
+  },
+  asyncQueryHotKeyDom: function asyncQueryHotKeyDom(operator, currentNode) {
+    var pollQueryDom = function pollQueryDom() {
+      if (Array.isArray(operator)) {
+        for (var index = 0; index < operator.length; index++) {
+          var element = operator[index];
+          var target = (0, _utils.queryHotKey)(element, currentNode);
+          if (target) return target;
+        }
+      } else {
+        var _target = (0, _utils.queryHotKey)(operator, currentNode);
+        if (_target) return _target;
+      }
+      var result = (0, _utils.queryCount)();
+      if (result === 'done') return;
+
+      return pollQueryDom();
+    };
+
+    return pollQueryDom();
+  },
+
+
+  // 获取自定义快捷键
+  getDefineHotKeyConfigByStore: function getDefineHotKeyConfigByStore() {
+    // 正式环境使用缓存对象
+    var setting_setData = _mutantsUtil.localStore.get("setting_setData");
+    setting_setData = setting_setData == 'undefined' || !setting_setData ? [] : setting_setData;
+    if (setting_setData == null) {
+      setting_setData = JSON.parse(localStorage.getItem("setting_setData"));
+    }
+
+    // 本地调试使用
+    // const setting_setData = window.web_hotKeyConfig
+    var defineHotKeyConfig = {};
+    var defineHotKeyConfigList = [];
+    var conflictHotKeyConfigList = [];
+    if (setting_setData && setting_setData.length != 0) {
+      setting_setData.forEach(function (settingItem) {
+        // 快捷键固定ParamType
+        var _enumController$getEn = _mutantsUtil.enumController.getEnumOj(),
+            RE_POSParamType = _enumController$getEn.RE_POSParamType;
+
+        var SHORTCUT_KEY = RE_POSParamType.SHORTCUT_KEY;
+
+        if (settingItem.ParamType && (settingItem.ParamType.Id === SHORTCUT_KEY || settingItem.ParamType === SHORTCUT_KEY)) {
+          var _ref2 = settingItem || {},
+              DefaultValue = _ref2.DefaultValue,
+              ExtField = _ref2.ExtField,
+              Title = _ref2.Title,
+              ID = _ref2.ID,
+              Value = _ref2.Value,
+              Name = _ref2.Name,
+              TabIndex = _ref2.TabIndex;
+
+          var ExtFieldParse = { dynamic: false, classification: "", enableEdit: false, operation: [], operationType: 1, isdisplay: false };
+          try {
+            ExtFieldParse = JSON.parse(ExtField);
+          } catch (error) {}
+          var _ExtFieldParse = ExtFieldParse,
+              dynamic = _ExtFieldParse.dynamic,
+              classification = _ExtFieldParse.classification,
+              enableEdit = _ExtFieldParse.enableEdit,
+              operation = _ExtFieldParse.operation,
+              operationType = _ExtFieldParse.operationType,
+              isdisplay = _ExtFieldParse.isdisplay;
+
+
+          var configItem = { Name: Name, describe: Title, dynamic: dynamic, keyValue: Value, operation: operation, enableEdit: enableEdit, classification: classification, id: ID, DefaultValue: DefaultValue, operationType: operationType, TabIndex: TabIndex, isdisplay: isdisplay };
+
+          if (Value !== '') {
+            // 快捷键未被设置为空
+            if (defineHotKeyConfig[Value]) {
+              // 存在使用相同快捷键
+              var operationControl = defineHotKeyConfig[Value].operationControl;
+
+              if (operationControl) {
+                // 之前已经存入过两个快捷键 这是第三个
+                if (!operationControl[operationType]) {
+                  defineHotKeyConfig[Value].operationControl[operationType] = configItem;
+                } else {
+                  // 表示有冲突快捷键
+                  conflictHotKeyConfigList.push((0, _extends3.default)({}, configItem, { keyValue: "" }));
+                  return null;
+                }
+              } else {
+                var itemOperationType = defineHotKeyConfig[Value].operationType;
+
+                if (operationType == itemOperationType) {
+                  // 存在冲突快捷键  因为 dynamic 并未改变为动态键所致
+                  conflictHotKeyConfigList.push((0, _extends3.default)({}, configItem, { keyValue: "" }));
+                  return null;
+                } else {
+                  // 存储第二个快捷键
+                  var _operationControl = (0, _extends3.default)({}, defineHotKeyConfig[Value], { dynamic: true });
+                  defineHotKeyConfig[Value] = {
+                    operationControl: {}
+                  };
+                  // 搬移一层对象信息到第二次 变为动态键
+                  defineHotKeyConfig[Value].dynamic = true;
+                  defineHotKeyConfig[Value].operationControl[itemOperationType] = _operationControl;
+                  // 增加第二个动态键
+                  defineHotKeyConfig[Value].operationControl[operationType] = (0, _extends3.default)({}, configItem, { dynamic: true });
+                }
+              }
+            } else {
+              // 单个动态键
+              if (dynamic) {
+                defineHotKeyConfig[Value] = {
+                  dynamic: true,
+                  operationControl: {}
+                };
+                defineHotKeyConfig[Value].operationControl[operationType] = (0, _extends3.default)({}, configItem, { dynamic: true });
+              } else {
+                defineHotKeyConfig[Value] = (0, _extends3.default)({}, configItem, { dynamic: false });
+              }
+            }
+          } else {
+            // 快捷键设置为空
+          }
+
+          defineHotKeyConfigList.push(configItem);
+        }
+      });
+    } else {
+      defineHotKeyConfig = _config.hotKeyConfig;
+    }
+    window.defineHotKeyConfigList = [].concat(defineHotKeyConfigList, conflictHotKeyConfigList);
+    return defineHotKeyConfig;
+  },
+
+
+  // 获取自定义权限
+  getDefineOperationControlByStore: function getDefineOperationControlByStore(defineHotKey) {
+    // 获取自定义快捷键配置JSON  KEY值集合
+    var defineHotKeyList = (0, _keys2.default)(defineHotKey);
+
+    var defineOperationControl = {};
+
+    // 遍历自定义快捷键的key值 
+    defineHotKeyList.forEach(function (defineKey) {
+      var _ref3 = defineHotKey[defineKey] || {},
+          dynamic = _ref3.dynamic,
+          operationControl = _ref3.operationControl;
+      // 是否是动态键 
+
+
+      if (dynamic) {
+        if (operationControl) {
+          // 动态键
+          var operationKeys = (0, _keys2.default)(operationControl);
+          operationKeys.forEach(function (opKey) {
+            var _ref4 = operationControl[opKey] || {},
+                operation = _ref4.operation;
+            // 构建权限页面结构
+
+
+            if (!defineOperationControl[opKey]) {
+              defineOperationControl[opKey] = {
+                control: [],
+                dynamicSelector: {}
+              };
+            }
+
+            // 添加键值 
+            defineOperationControl[opKey].control.push(defineKey);
+            // 如果是上下键 dynamicSelector值有所不同 
+            if (defineKey === 'down' || defineKey === 'up') {
+              defineOperationControl[opKey].dynamicSelector['up&down'] = operation;
+              return;
+            }
+            defineOperationControl[opKey].dynamicSelector[defineKey] = operation;
+          });
+        } else {
+          var _ref5 = defineHotKey[defineKey] || {},
+              operationType = _ref5.operationType,
+              operation = _ref5.operation;
+
+          if (!defineOperationControl[operationType]) {
+            defineOperationControl[operationType] = {
+              control: [],
+              dynamicSelector: {}
+            };
+          }
+          // 添加键值 
+          defineOperationControl[operationType].control.push(defineKey);
+          defineOperationControl[operationType].dynamicSelector[defineKey] = operation;
+          // const {}
+        }
+      }
+    });
+    return defineOperationControl;
+  },
+  newhotKeyArraySort: function newhotKeyArraySort(array, fn) {
+    var t = void 0;
+    fn = fn || function (x, y) {
+      return x - y;
+    };
+    for (var i = 0; i < array.length; i++) {
+      for (var j = i; j < array.length; j++) {
+        if (fn(array[i], array[j]) > 0) {
+          t = array[i];
+          array[i] = array[j];
+          array[j] = t;
+        }
+      }
+    }
+    return array;
+  },
+  dynamicAction: function dynamicAction(keyName, target) {
+    var _ref6 = this.hotKeyConfig[keyName] || {},
+        dynamic = _ref6.dynamic;
+
+    if (!dynamic) return;
+
+    var _ref7 = this.operationControl[this.focusId] || {},
+        _ref7$dynamicSelector = _ref7.dynamicSelector,
+        dynamicSelector = _ref7$dynamicSelector === undefined ? {} : _ref7$dynamicSelector;
+
+    var _ref8 = this.operationControl[this.focusId] || {},
+        _ref8$directionSelect = _ref8.directionSelector,
+        directionSelector = _ref8$directionSelect === undefined ? {} : _ref8$directionSelect;
+
+    var targetKey = 'up&down';
+
+    if (keyName !== 'up' && keyName !== 'down') {
+      targetKey = (0, _keys2.default)(dynamicSelector).find(function (key) {
+        return key === keyName;
+      });
+    }
+
+    var domSelector = dynamicSelector[targetKey];
+    var actionNode = hotKeyFactory.queryNode(target).find(domSelector);
+
+    if ('updown'.includes(keyName) && actionNode.currentNode) {
+      var fnName = { down: 'next', up: 'prev' };
+      actionNode = actionNode[fnName[keyName]]();
+    }
+
+    if (this.focusId == 7 && 'leftright'.includes(keyName) && actionNode.currentNode) {
+      var _fnName = { right: 'next', left: 'prev' };
+      actionNode = actionNode[_fnName[keyName]]();
+    }
+
+    actionNode.currentNode && actionNode.click();
+
+    if (!actionNode.currentNode) {
+      hotKeyFactory.log(true, { waring: 'the [' + keyName + '] hot-key of dynamic trigger Dom not found' });
+      return true;
+    }
+
+    return actionNode.currentNode;
+  },
+  triggerRegister: function triggerRegister(keyName) {
+    if (!hotKeyFactory.registerKey) return;
+
+    var trigger = this.registerKey.find(function (item) {
+      return item.key === keyName;
+    });
+    if (!trigger) return;
+
+    var container = trigger.container,
+        className = trigger.className;
+
+    var containerDom = this.asyncQueryHotKeyDom(container);
+    var targetDom = void 0;
+    var classNameList = Array.isArray(className) ? className : [className];
+    classNameList.some(function (name) {
+      var queryDom = hotKeyFactory.queryNode(containerDom).find(name);
+      targetDom = queryDom;
+      return !!queryDom.currentNode;
+    });
+
+    targetDom.currentNode && targetDom.click();
+    hotKeyFactory.log(!targetDom.currentNode, { waring: 'register hot-key trigger Dom not found' });
+
+    hotKeyFactory.unlock();
+  },
+  register: function register(keyName) {
+    return function (containerName) {
+      return function (className) {
+        var registerKey = {
+          key: keyName,
+          container: containerName,
+          className: className
+        };
+
+        if (!hotKeyFactory.registerKey) {
+          hotKeyFactory.registerKey = [registerKey];
+        } else {
+          var addKey = [].concat((0, _toConsumableArray3.default)(hotKeyFactory.registerKey.filter(function (item) {
+            return item.key !== keyName;
+          })), [registerKey]);
+          hotKeyFactory.registerKey = addKey;
+        }
+      };
+    };
+  },
+  unRegister: function unRegister(keyName) {
+    if (hotKeyFactory.registerKey) {
+      var keys = hotKeyFactory.registerKey.filter(function (item) {
+        return item.key !== keyName;
+      });
+      hotKeyFactory.registerKey = keys;
+    }
+  },
+  queryNode: function queryNode(target) {
+    var find = this.find,
+        next = this.next,
+        prev = this.prev,
+        setFocus = this.setFocus,
+        clearFocus = this.clearFocus;
+
+
+    return {
+      currentNode: target,
+      find: find,
+      next: next,
+      prev: prev,
+      setFocus: setFocus,
+      clearFocus: clearFocus,
+      click: function click() {
+        hotKeyFactory.clickBefore();
+        this.currentNode.click();
+      }
+    };
+  },
+  rejectDoAction: function rejectDoAction(keyName) {
+    var id = hotKeyFactory.getFocusId();
+    if (!id) return true;
+
+    var _ref9 = this.operationControl[id] || {},
+        control = _ref9.control,
+        directionSelector = _ref9.directionSelector;
+
+    // if (control === 'ALL') return;
+
+
+    if (id == '1') return; //动态生成id=='1' 代替ALL
+    if (!control || !control.includes(keyName)) return true;
+  },
+  action: function action(keyName, className) {
+    var _this = this;
+
+    return new _promise2.default(function (resolve, reject) {
+      var target = _this.asyncQueryHotKeyDom(className);
+
+      var dynamicActionTarget = hotKeyFactory.dynamicAction(keyName, target);
+      if (dynamicActionTarget) return resolve(dynamicActionTarget);
+
+      if (target) {
+        var hotKeyProto = hotKeyFactory.queryNode(target);
+
+        hotKeyProto.click();
+        hotKeyFactory.unlock();
+
+        resolve(hotKeyProto);
+      } else {
+        hotKeyFactory.log(true, { waring: 'not found hot ket target of [' + className + ']' });
+        hotKeyFactory.unlock();
+      }
+    });
+  },
+  actionCompose: function actionCompose(operation, keyName, callback) {
+    var _this2 = this;
+
+    var actionPromise = null;
+    var prveValue = null;
+    var listener = hotKeyFactory.listener;
+
+
+    operation.forEach(function (value, index) {
+      if (!actionPromise) {
+        prveValue = value;
+        actionPromise = hotKeyFactory.action(keyName, value);
+        if (index === operation.length - 1) {
+          actionPromise.then(function (res) {
+            listener(callback, res, index);
+            hotKeyFactory.unlock();
+            return _this2;
+          });
+        }
+      } else {
+        actionPromise.then(function (res) {
+          listener(callback, res, index - 1);
+          prveValue = value;
+          return hotKeyFactory.action(keyName, value);
+        });
+
+        if (index === operation.length - 1) {
+          actionPromise.then(function (res) {
+            listener(callback, res, index);
+            hotKeyFactory.unlock();
+            return _this2;
+          });
+        }
+      }
+    });
+
+    return actionPromise;
+  },
+  actuator: function actuator(keyName, callback) {
+    hotKeyFactory.log(true, { keyName: keyName });
+
+    if (hotKeyFactory.isShouldQuickKeyClicked()) return null;
+    // if (hotKeyFactory.lock) return;
+    hotKeyFactory.lock = true;
+
+    if (hotKeyFactory.triggerRegister(keyName)) return;
+    if (hotKeyFactory.rejectDoAction(keyName)) return;
+
+    var _ref10 = this.hotKeyConfig[keyName] || {},
+        _ref10$operation = _ref10.operation,
+        operation = _ref10$operation === undefined ? ['.hot-key-focus-container'] : _ref10$operation;
+
+    var operations = Array.isArray(operation[0]) ? operation : [operation]; // 存在一个按键操作多个节点
+
+    operations.forEach(function (operationItem) {
+      return hotKeyFactory.actionCompose(operationItem, keyName, callback);
+    });
+  },
+  find: function find(selector, isNew) {
+    var currentNode = void 0;
+    if (!this.currentNode || isNew) {
+      currentNode = hotKeyFactory.asyncQueryHotKeyDom(selector);
+    } else {
+      currentNode = hotKeyFactory.asyncQueryHotKeyDom(selector, this.currentNode);
+    }
+
+    return hotKeyFactory.queryNode(currentNode);
+  },
+  next: function next() {
+    var filterNum = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+
+    for (var i = 0; i < filterNum; i++) {
+      if (!this.currentNode) {
+        hotKeyFactory.log(true, { waring: 'There is a warning in the next，trigger Dom is not found ' });
+        break;
+      }
+      this.currentNode = this.currentNode.nextSibling;
+    }
+
+    return this;
+  },
+  prev: function prev() {
+    var filterNum = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+
+    for (var i = 0; i < filterNum; i++) {
+      if (!this.currentNode) {
+        hotKeyFactory.log(true, { waring: 'There is a warning in the prev，trigger Dom is not found ' });
+        break;
+      }
+      this.currentNode = this.currentNode.previousSibling;
+    }
+
+    return this;
+  },
+  find_element: function find_element(selector) {
+    var returnValue = [];
+    var arr = selector.split(' ');
+    if (arr && arr.length > 0) {
+      arr.map(function (item) {
+        var el = document.querySelectorAll('.hot-key-focus-container ' + item);
+        returnValue = [].concat((0, _toConsumableArray3.default)(returnValue), (0, _toConsumableArray3.default)(el));
+      });
+      returnValue = returnValue && [].concat((0, _toConsumableArray3.default)(returnValue)).filter(function (v) {
+        return v.style.display != 'none';
+      });
+    }
+    return returnValue;
+  },
+  setFocus: function setFocus(target) {
+    var container = target || this.currentNode;
+    container && container.classList.add('hot-key-focus-container');
+    //hotKeyFactory.log(!container, { waring: 'the set focus container Dom is not found' });
+  },
+  clearFocus: function clearFocus() {
+    var focusContainer = document.querySelectorAll('.hot-key-focus-container');
+
+    var _iteratorNormalCompletion = true;
+    var _didIteratorError = false;
+    var _iteratorError = undefined;
+
+    try {
+      for (var _iterator = (0, _getIterator3.default)(focusContainer), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var dom = _step.value;
+
+        dom.classList.remove('hot-key-focus-container');
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+
+    hotKeyFactory.log(true, { log: 'the focus container is clear' });
+  },
+  clickBefore: function clickBefore() {
+    var clickBeforeProp = hotKeyFactory.clickBeforeProp;
+
+    clickBeforeProp && clickBeforeProp();
+  },
+  unlock: function unlock() {
+    hotKeyFactory.lock = false;
+  },
+  getFocusId: function getFocusId() {
+    var focusContainer = document.querySelector('.hot-key-focus-container');
+    if (!focusContainer) return hotKeyFactory.log(true, { waring: 'the focus container is not found' });
+
+    var classList = void 0;
+    var currentClassList = (0, _from2.default)(focusContainer.classList) || [];
+    if (currentClassList.includes('hot-key-id')) {
+      classList = currentClassList;
+    } else {
+      var hotKeyIdNode = focusContainer.querySelector('.hot-key-id');
+      hotKeyFactory.log(!hotKeyIdNode, { waring: 'not have any bind hot-key id node' });
+
+      if (!hotKeyIdNode) return;
+
+      classList = (0, _from2.default)(hotKeyIdNode.classList) || [];
+    }
+
+    var _split = (classList.find(function (className) {
+      return className.includes('hot-key-id=');
+    }) || '').split('='),
+        _split2 = (0, _slicedToArray3.default)(_split, 2),
+        id = _split2[1];
+
+    this.focusId = id;
+
+    return id;
+  },
+  bind: function bind() {
+    var keys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    var callBack = arguments[1];
+
+    keyboard(keys.join(), callBack);
+  },
+  unbind: function unbind() {
+    var keys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+
+    keys.forEach(function (key) {
+      return keyboard.unbind(key);
+    });
+  },
+
+  handles: [],
+  on: function on(callback) {
+    var handles = hotKeyFactory.handles || [];
+    var isHaveEvent = handles.some(function (handle) {
+      return handle === callback;
+    });
+
+    if (!isHaveEvent) {
+      handles.push(callback);
+    }
+  },
+  off: function off(callback) {
+    var handles = hotKeyFactory.handles || [];
+    var handleIndex = handles.findIndex(function (handle) {
+      return handle === callback;
+    });
+
+    if (~handleIndex) {
+      handles.splice(handleIndex, 1);
+    }
+  },
+  listener: function listener(callback) {
+    var result = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var index = arguments[2];
+
+    var node = result.nodeType === 1 ? result : result.currentNode;
+    hotKeyFactory.handles.forEach(function (handle) {
+      return handle(node, index);
+    });
+
+    callback && callback(node, index);
+  },
+  log: function log(isShowLog) {
+    var _ref11 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+        keyName = _ref11.keyName,
+        waring = _ref11.waring;
+
+    if (!this.showLog || !isShowLog) return;
+
+    if (keyName) console.log('[hot-key]: ' + keyName);
+    if (waring) console.log('[hot-key-waring]: ' + waring);
+  },
+  isShouldQuickKeyClicked: function isShouldQuickKeyClicked() {
+    var loadingImgs = document.querySelector("img.loading-img-symbol");
+    // const doNotSettleQuickKey = document.querySelector("#doNotSettleQuickKey");
+    var isCanSettleOnQuickKey = _mutantsMicrofx.stores.settlementVoucherStore.isCanSettleOnQuickKey;
+
+    if (loadingImgs || !isCanSettleOnQuickKey) return true;
+  }
+};
+
+function hotKey(option) {
+  return hotKeyFactory.constructor.call(hotKeyFactory, option);
+}
+
+hotKey.hotKeyPart = function (partName) {
+  var otherClassName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+
+  return otherClassName + ' hot-key-part-' + partName;
+};
+
+hotKey.hotKeyBindClass = function (id) {
+  var otherClassName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+
+  return otherClassName + ' hot-key-id hot-key-id=' + id;
+};
+
+hotKey.hotKeyNotFilter = function () {
+  var otherClassName = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+
+  return otherClassName + ' hot-key-not-filter';
+};
+
+hotKey.hotKeyConfig = _config.hotKeyConfig;
+hotKey.operationControl = _config.operationControl;
+hotKey.showHotKeyModal = _hotKeyModal.showHotKeyModal;
+hotKey.classificationList = _config.classificationList;
+hotKey.keyReplaceStringList = _config.keyReplaceStringList;
+hotKey.operationTypeName = _config.operationTypeName;
+
+exports.default = hotKey;
+//# sourceMappingURL=index.js.map