@opentiny/vue-renderless 3.1.0-alpha.0

package/select/index.js

@@ -0,0 +1,1766 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+import { find } from '@opentiny/vue-renderless/common/array';
+import { getObj, isEqual } from '@opentiny/vue-renderless/common/object';
+import { isKorean } from '@opentiny/vue-renderless/common/string';
+import scrollIntoView from '@opentiny/vue-renderless/common/deps/scroll-into-view';
+import PopupManager from '@opentiny/vue-renderless/common/deps/popup-manager';
+import debounce from '@opentiny/vue-renderless/common/deps/debounce';
+import { getDataset } from '@opentiny/vue-renderless/common/dataset';
+import Memorize from '@opentiny/vue-renderless/common/deps/memorize';
+import { isEmptyObject } from '@opentiny/vue-renderless/common/type';
+import { addResizeListener, removeResizeListener } from '@opentiny/vue-renderless/common/deps/resize-event';
+import { extend } from '@opentiny/vue-renderless/common/object';
+export var handleComposition = function handleComposition(_ref) {
+  var api = _ref.api,
+    nextTick = _ref.nextTick,
+    state = _ref.state;
+  return function (event) {
+    var text = event.target.value;
+    if (event.type === 'compositionend') {
+      state.isOnComposition = false;
+      nextTick(function () {
+        return api.handleQueryChange(text);
+      });
+    } else {
+      var lastCharacter = text[text.length - 1] || '';
+      state.isOnComposition = !isKorean(lastCharacter);
+    }
+  };
+};
+export var showTip = function showTip(_ref2) {
+  var props = _ref2.props,
+    state = _ref2.state,
+    refs = _ref2.refs;
+  return function (show) {
+    if (!props.showOverflowTooltip) {
+      return;
+    }
+    var overflow;
+    if (!show) {
+      clearTimeout(state.tipTimer);
+      state.tipTimer = setTimeout(function () {
+        state.showTip = state.tipHover;
+      }, refs.popover.closeDelay);
+    } else {
+      if (!props.multiple) {
+        var reference = refs.reference.$el;
+        overflow = reference.querySelector('input').scrollWidth > reference.scrollWidth;
+      } else {
+        overflow = refs.tags.scrollHeight > refs.tags.getBoundingClientRect().height;
+      }
+      state.showTip = show && overflow && !!state.tips && !state.visible;
+    }
+  };
+};
+export var gridOnQueryChange = function gridOnQueryChange(_ref3) {
+  var props = _ref3.props,
+    refs = _ref3.refs,
+    constants = _ref3.constants,
+    state = _ref3.state;
+  return function (value) {
+    var multiple = props.multiple,
+      valueField = props.valueField,
+      filterMethod = props.filterMethod,
+      filterable = props.filterable,
+      remote = props.remote,
+      remoteMethod = props.remoteMethod;
+    if (filterable && typeof filterMethod === 'function') {
+      var table = refs.selectGrid.$refs.tinyTable;
+      var fullData = table.afterFullData;
+      refs.selectGrid.scrollTo(null, 0);
+      table.afterFullData = filterMethod(value, fullData) || [];
+      refs.selectGrid.handleTableData(!value).then(function () {
+        return state.selectEmitter.emit(constants.EVENT_NAME.updatePopper);
+      });
+      state.previousQuery = value;
+    } else if (remote && typeof remoteMethod === 'function') {
+      state.previousQuery = value;
+      remoteMethod(value).then(function (data) {
+        if (multiple) {
+          var selectedIds = state.selected.map(function (sel) {
+            return sel[valueField];
+          });
+          refs.selectGrid.clearSelection();
+          refs.selectGrid.setSelection(data.filter(function (row) {
+            return ~selectedIds.indexOf(row[valueField]);
+          }), true);
+          state.remoteData = data.filter(function (row) {
+            return !~selectedIds.indexOf(row[valueField]);
+          }).concat(state.selected);
+        } else {
+          refs.selectGrid.clearRadioRow();
+          refs.selectGrid.setRadioRow(find(data, function (item) {
+            return props.modelValue == item[props.valueField];
+          }));
+          state.remoteData = data;
+        }
+        refs.selectGrid.$refs.tinyTable.lastScrollTop = 0;
+        refs.selectGrid.loadData(data);
+        refs.selectGrid.handleTableData(!value).then(function () {
+          return state.selectEmitter.emit(constants.EVENT_NAME.updatePopper);
+        });
+      });
+    }
+  };
+};
+export var defaultOnQueryChange = function defaultOnQueryChange(_ref4) {
+  var props = _ref4.props,
+    state = _ref4.state,
+    constants = _ref4.constants,
+    api = _ref4.api;
+  return function (value) {
+    if (props.remote && typeof props.remoteMethod === 'function') {
+      state.hoverIndex = -1;
+      props.remoteMethod(value);
+    } else if (typeof props.filterMethod === 'function') {
+      props.filterMethod(value);
+      state.selectEmitter.emit(constants.COMPONENT_NAME.OptionGroup, constants.EVENT_NAME.queryChange);
+    } else {
+      state.filteredOptionsCount = state.optionsCount;
+      state.selectEmitter.emit(constants.EVENT_NAME.queryChange, value);
+    }
+    if (props.defaultFirstOption && (props.filterable || props.remote) && state.filteredOptionsCount) {
+      api.checkDefaultFirstOption();
+    }
+  };
+};
+export var handleQueryChange = function handleQueryChange(_ref5) {
+  var api = _ref5.api,
+    constants = _ref5.constants,
+    nextTick = _ref5.nextTick,
+    props = _ref5.props,
+    vm = _ref5.vm,
+    state = _ref5.state;
+  return function (value) {
+    var refs = vm.$refs;
+    if (state.previousQuery === value || state.isOnComposition) {
+      return;
+    }
+    if (state.previousQuery === null && (typeof props.filterMethod === 'function' || typeof props.remoteMethod === 'function')) {
+      state.previousQuery = value;
+      return;
+    }
+    if (props.renderType === constants.TYPE.Grid) {
+      api.gridOnQueryChange(value);
+      return;
+    }
+    if (props.renderType === constants.TYPE.Tree) {
+      state.previousQuery = value;
+      if (props.filterable && typeof props.filterMethod === 'function') {
+        refs.selectTree && refs.selectTree.filter(value);
+      }
+    }
+    state.previousQuery = value;
+    nextTick(function () {
+      if (state.visible) {
+        state.selectEmitter.emit(constants.EVENT_NAME.updatePopper);
+        state.showWarper = true;
+      }
+    });
+    state.hoverIndex = -1;
+    if (props.multiple && props.filterable) {
+      nextTick(function () {
+        var length = refs.input.value.length * 15 + 20;
+        state.inputLength = state.collapseTags ? Math.min(50, length) : length;
+        api.managePlaceholder();
+        api.resetInputHeight();
+      });
+    }
+    if (props.renderType === constants.TYPE.Tree) {
+      return;
+    }
+    api.defaultOnQueryChange(value);
+  };
+};
+export var scrollToOption = function scrollToOption(_ref6) {
+  var refs = _ref6.refs,
+    constants = _ref6.constants;
+  return function (option) {
+    var target = Array.isArray(option) && option[0] ? option[0].el : option.el;
+    if (refs.popper && target) {
+      var menu = refs.popper.$el.querySelector(constants.CLASS.SelectDropdownWrap);
+      scrollIntoView(menu, target);
+    }
+    refs.scrollbar && refs.scrollbar.handleScroll();
+  };
+};
+export var handleMenuEnter = function handleMenuEnter(_ref7) {
+  var api = _ref7.api,
+    nextTick = _ref7.nextTick,
+    state = _ref7.state;
+  return function () {
+    nextTick(function () {
+      return api.scrollToOption(state.selected);
+    });
+  };
+};
+export var emitChange = function emitChange(_ref8) {
+  var emit = _ref8.emit,
+    props = _ref8.props,
+    state = _ref8.state,
+    constants = _ref8.constants;
+  return function (value) {
+    var seekItem = function seekItem(val, arr, items, flag) {
+      if (constants.TYPE.Tree === flag) {
+        var recurNode = function recurNode(node) {
+          val === node[props.valueField] && items.push(node);
+          val !== node[props.valueField] && Array.isArray(node.children) && node.children.forEach(recurNode);
+        };
+        arr.forEach(recurNode);
+      } else if (constants.TYPE.Grid === flag) {
+        for (var i = 0; i < arr.length; i++) {
+          if (val === arr[i][props.valueField]) {
+            items.push(arr[i]);
+            break;
+          }
+        }
+      }
+    };
+    if (!isEqual(props.modelValue, value)) {
+      if (props.renderType === constants.TYPE.Grid && props.multiple) {
+        value = value || [];
+        var gridData = state.gridData || [];
+        var items = [];
+        value.forEach(function (valueItem) {
+          seekItem(valueItem, gridData, items, constants.TYPE.Grid);
+        });
+        emit('change', value, items);
+      } else if (props.renderType === constants.TYPE.Tree && props.multiple) {
+        value = value || [];
+        var treeData = state.treeData || [];
+        var _items = [];
+        value.forEach(function (valueItem) {
+          seekItem(valueItem, treeData, _items, constants.TYPE.Tree);
+        });
+        emit('change', value, _items);
+      } else {
+        emit('change', value);
+      }
+    }
+  };
+};
+export var getOption = function getOption(_ref9) {
+  var props = _ref9.props,
+    state = _ref9.state;
+  return function (value) {
+    var option;
+    var isObject = Object.prototype.toString.call(value).toLowerCase() === '[object object]';
+    var isNull = Object.prototype.toString.call(value).toLowerCase() === '[object null]';
+    var isUndefined = Object.prototype.toString.call(value).toLowerCase() === '[object undefined]';
+    for (var i = state.cachedOptions.length - 1; i >= 0; i--) {
+      var cachedOption = state.cachedOptions[i];
+      var _isEqual = isObject ? getObj(cachedOption.value, props.valueKey) === getObj(value, props.valueKey) : cachedOption.value === value;
+      if (_isEqual) {
+        option = cachedOption;
+        break;
+      }
+    }
+    if (option) {
+      return option;
+    }
+    var label = !isObject && !isNull && !isUndefined ? value : '';
+    var newOption = {
+      value: value,
+      currentLabel: label
+    };
+    if (props.multiple) {
+      newOption.hitState = false;
+    }
+    return newOption;
+  };
+};
+var getOptionOfSetSelected = function getOptionOfSetSelected(_ref10) {
+  var api = _ref10.api,
+    props = _ref10.props;
+  var option = api.getOption(props.modelValue) || {};
+  if (!option.state) {
+    option.state = {};
+  }
+  if (option.created) {
+    option.createdLabel = option.state.currentLabel;
+    option.createdSelected = true;
+  } else {
+    option.createdSelected = false;
+  }
+  return option;
+};
+var getResultOfSetSelected = function getResultOfSetSelected(_ref11) {
+  var props = _ref11.props,
+    isGrid = _ref11.isGrid,
+    isTree = _ref11.isTree,
+    api = _ref11.api;
+  var result = [];
+  if (Array.isArray(props.modelValue)) {
+    props.modelValue.forEach(function (value) {
+      if (isGrid || isTree) {
+        var option = api.getPluginOption(value, isTree);
+        result = result.concat(option);
+      } else {
+        result.push(api.getOption(value));
+      }
+    });
+  }
+  return result;
+};
+export var setSelected = function setSelected(_ref12) {
+  var api = _ref12.api,
+    constants = _ref12.constants,
+    nextTick = _ref12.nextTick,
+    props = _ref12.props,
+    refs = _ref12.refs,
+    state = _ref12.state;
+  return function () {
+    var isTree = props.renderType === constants.TYPE.Tree;
+    var isGrid = props.renderType === constants.TYPE.Grid;
+    if (!props.multiple) {
+      if (isGrid || isTree) {
+        if (!props.modelValue) {
+          state.selectedLabel = '';
+          state.selected = {};
+          state.currentKey = '';
+          refs.selectGrid && refs.selectGrid.clearRadioRow();
+          refs.selectTree && refs.selectTree.setCurrentKey && refs.selectTree.setCurrentKey(null);
+          return;
+        }
+        var isRemote = props.filterable && props.remote && typeof props.remoteMethod === 'function';
+        var nestdata = isRemote ? state.remoteData : isTree ? api.getTreeData(state.treeData) : state.gridData;
+        var data = find(nestdata, function (item) {
+          return props.modelValue == item[props.valueField];
+        });
+        if (isEmptyObject(data)) {
+          return;
+        }
+        var obj = _objectSpread({}, data);
+        var label = data[props.textField];
+        obj.currentLabel = label;
+        state.selectedLabel = label;
+        state.selected = obj;
+        state.currentKey = data[props.valueField];
+      } else {
+        var option = getOptionOfSetSelected({
+          api: api,
+          props: props
+        });
+        nextTick(function () {
+          state.selected = option;
+          state.selectedLabel = option.state.currentLabel || option.currentLabel;
+          props.filterable && (state.query = state.selectedLabel);
+        });
+      }
+      return;
+    }
+    var result = getResultOfSetSelected({
+      props: props,
+      isGrid: isGrid,
+      isTree: isTree,
+      api: api
+    });
+    state.selectCls = result.length ? result.length === state.options.length ? 'checked-sur' : 'halfselect' : 'check';
+    state.selected = result;
+    refs.selectTree && refs.selectTree.setCheckedNodes && refs.selectTree.setCheckedNodes(state.selected);
+    state.tips = state.selected.map(function (item) {
+      return item.state ? item.state.currentLabel : item.currentLabel;
+    }).join(',');
+    nextTick(api.resetInputHeight);
+  };
+};
+export var getPluginOption = function getPluginOption(_ref13) {
+  var api = _ref13.api,
+    props = _ref13.props,
+    state = _ref13.state;
+  return function (value, isTree) {
+    var isRemote = props.filterable && props.remote && typeof props.remoteMethod === 'function';
+    var textField = props.textField,
+      valueField = props.valueField;
+    var sourceData = isRemote ? state.remoteData : isTree ? api.getTreeData(state.treeData) : state.gridData;
+    var selNode = find(sourceData, function (item) {
+      return item[valueField] == value;
+    });
+    var items = [];
+    if (selNode) {
+      selNode.currentLabel = selNode[textField];
+      items.push(selNode);
+    }
+    return items;
+  };
+};
+export var toggleCheckAll = function toggleCheckAll(_ref14) {
+  var api = _ref14.api,
+    emit = _ref14.emit,
+    state = _ref14.state;
+  return function () {
+    var getEnabledValues = function getEnabledValues(options) {
+      var values = [];
+      for (var i = 0; i < options.length; i++) {
+        if (!options[i].state.disabled && !options[i].state.groupDisabled) {
+          values.push(options[i].value);
+        }
+      }
+      return values;
+    };
+    var value;
+    if (state.selectCls === 'check') {
+      value = getEnabledValues(state.options);
+    } else if (state.selectCls === 'halfselect') {
+      var unchecked = state.options.filter(function (item) {
+        return !item.disabled && item.state.selectCls === 'check';
+      });
+      unchecked.length ? value = getEnabledValues(state.options) : value = [];
+    } else if (state.selectCls === 'checked-sur') {
+      value = [];
+    }
+    api.setSoftFocus();
+    emit('update:modelValue', value);
+    emit('change', value);
+  };
+};
+export var handleFocus = function handleFocus(_ref15) {
+  var emit = _ref15.emit,
+    props = _ref15.props,
+    state = _ref15.state,
+    api = _ref15.api;
+  return function (event) {
+    if (!state.softFocus) {
+      if (props.automaticDropdown || props.filterable) {
+        state.visible = true;
+        state.softFocus = true;
+      }
+      emit('focus', event);
+    } else {
+      state.softFocus = false;
+    }
+    if (props.remote && props.filterable && state.firstAutoSeach) {
+      state.firstAutoSeach = false;
+      state.query = '';
+      state.previousQuery = undefined;
+      api.handleQueryChange(state.query);
+    }
+  };
+};
+export var focus = function focus(_ref16) {
+  var refs = _ref16.refs,
+    state = _ref16.state;
+  return function () {
+    if (!state.softFocus) {
+      refs.reference.focus();
+    }
+  };
+};
+export var blur = function blur(_ref17) {
+  var refs = _ref17.refs,
+    state = _ref17.state;
+  return function () {
+    state.visible = false;
+    refs.reference.blur();
+  };
+};
+export var handleBlur = function handleBlur(_ref18) {
+  var constants = _ref18.constants,
+    dispatch = _ref18.dispatch,
+    emit = _ref18.emit,
+    state = _ref18.state;
+  return function (event) {
+    setTimeout(function () {
+      if (state.isSilentBlur) {
+        state.isSilentBlur = false;
+      } else {
+        emit('blur', event);
+      }
+      dispatch(constants.COMPONENT_NAME.FormItem, constants.EVENT_NAME.formBlur, event.target.value);
+    }, 100);
+    state.softFocus = false;
+  };
+};
+export var handleClearClick = function handleClearClick(api) {
+  return function (event) {
+    api.deleteSelected(event);
+  };
+};
+export var doDestroy = function doDestroy(refs) {
+  return function () {
+    refs.popper && refs.popper.doDestroy();
+  };
+};
+export var handleClose = function handleClose(state) {
+  return function () {
+    state.visible = false;
+  };
+};
+export var toggleLastOptionHitState = function toggleLastOptionHitState(_ref19) {
+  var state = _ref19.state;
+  return function (hit) {
+    if (!Array.isArray(state.selected)) {
+      return;
+    }
+    var option = state.selected[state.selected.length - 1];
+    if (!option) {
+      return;
+    }
+    var hitTarget = option.state || option;
+    if (hit === true || hit === false) {
+      hitTarget.hitState = hit;
+      return hit;
+    }
+    hitTarget.hitState = !hitTarget.hitState;
+    return hitTarget.hitState;
+  };
+};
+export var deletePrevTag = function deletePrevTag(_ref20) {
+  var api = _ref20.api,
+    constants = _ref20.constants,
+    emit = _ref20.emit,
+    props = _ref20.props,
+    state = _ref20.state,
+    vm = _ref20.vm;
+  return function (event) {
+    var refs = vm.$refs;
+    if (event.target.value.length <= 0 && !api.toggleLastOptionHitState()) {
+      var value = props.modelValue.slice();
+      value.pop();
+      emit('update:modelValue', value);
+      api.emitChange(value);
+      if (props.renderType === constants.TYPE.Grid) {
+        var rows = state.selected.slice().filter(function (item) {
+          return value.indexOf(item[props.valueField]) > -1;
+        });
+        refs.selectGrid.clearSelection();
+        refs.selectGrid.setSelection(rows, true);
+      }
+    }
+  };
+};
+export var managePlaceholder = function managePlaceholder(_ref21) {
+  var refs = _ref21.refs,
+    state = _ref21.state;
+  return function () {
+    if (state.currentPlaceholder !== '') {
+      state.currentPlaceholder = refs.input.value ? '' : state.cachedPlaceHolder;
+    }
+  };
+};
+export var resetInputState = function resetInputState(_ref22) {
+  var api = _ref22.api,
+    refs = _ref22.refs,
+    state = _ref22.state;
+  return function (event) {
+    if (event.keyCode !== 8) {
+      api.toggleLastOptionHitState(false);
+    }
+    state.inputLength = refs.input.value.length * 15 + 20;
+    api.resetInputHeight();
+  };
+};
+export var resetInputHeight = function resetInputHeight(_ref23) {
+  var constants = _ref23.constants,
+    nextTick = _ref23.nextTick,
+    props = _ref23.props,
+    refs = _ref23.refs,
+    state = _ref23.state;
+  return function () {
+    if (state.collapseTags && !props.filterable) {
+      return;
+    }
+    nextTick(function () {
+      if (!refs.reference) {
+        return;
+      }
+      var inputChildNodes = refs.reference.$el.childNodes;
+      var input = [].filter.call(inputChildNodes, function (item) {
+        return item.tagName === 'INPUT';
+      })[0];
+      var tags = refs.tags;
+      if (!input) {
+        return;
+      }
+      var sizeInMap = state.initialInputHeight || 30;
+      var noSelected = state.selected.length === 0;
+      input.style.height = noSelected ? sizeInMap + 'px' : Math.max(tags ? tags.clientHeight + (tags.clientHeight > sizeInMap ? 6 : 0) : 0, sizeInMap) + 'px';
+      if (state.visible && state.emptyText !== false) {
+        state.selectEmitter.emit(constants.EVENT_NAME.updatePopper, true);
+      }
+    });
+  };
+};
+export var resetHoverIndex = function resetHoverIndex(_ref24) {
+  var props = _ref24.props,
+    state = _ref24.state;
+  return function () {
+    if (!props.showOverflowTooltip) {
+      state.hoverIndex = -1;
+    } else if (!props.multiple) {
+      state.hoverIndex = state.options.indexOf(state.selected);
+    } else {
+      if (state.selected.length > 0) {
+        state.hoverIndex = Math.min.apply(null, state.selected.map(function (item) {
+          return state.options.indexOf(item);
+        }));
+      } else {
+        state.hoverIndex = -1;
+      }
+    }
+  };
+};
+export var handleOptionSelect = function handleOptionSelect(_ref25) {
+  var api = _ref25.api,
+    emit = _ref25.emit,
+    nextTick = _ref25.nextTick,
+    props = _ref25.props,
+    refs = _ref25.refs,
+    state = _ref25.state;
+  return function (option, byClick) {
+    state.memorize && state.memorize.updateByKey(option[state.memorize._dataKey] || option.value);
+    if (props.multiple) {
+      var value = (props.modelValue || []).slice();
+      var optionIndex = api.getValueIndex(value, option.value);
+      if (optionIndex > -1) {
+        value.splice(optionIndex, 1);
+      } else if (state.multipleLimit <= 0 || value.length < state.multipleLimit) {
+        value.push(option.value);
+      }
+      emit('update:modelValue', value);
+      api.emitChange(value);
+      if (option.created) {
+        state.query = '';
+        api.handleQueryChange('');
+        state.inputLength = 20;
+      }
+      if (props.filterable) {
+        refs.input.focus();
+      }
+      if (props.autoClose) {
+        state.visible = false;
+      }
+    } else {
+      emit('update:modelValue', option.value);
+      api.emitChange(option.value);
+      state.visible = false;
+    }
+    state.isSilentBlur = byClick;
+    api.setSoftFocus();
+    if (state.visible) {
+      return;
+    }
+    nextTick(function () {
+      api.scrollToOption(option);
+    });
+  };
+};
+export var setSoftFocus = function setSoftFocus(_ref26) {
+  var refs = _ref26.refs,
+    state = _ref26.state;
+  return function () {
+    state.softFocus = true;
+    var input = refs.input || refs.reference;
+    if (input) {
+      input.focus();
+    }
+  };
+};
+export var getValueIndex = function getValueIndex(props) {
+  return function () {
+    var arr = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    var value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    var isObject = Object.prototype.toString.call(value).toLowerCase() === '[object object]';
+    if (!isObject) {
+      return arr.indexOf(value);
+    } else {
+      var valueKey = props.valueKey;
+      var index = -1;
+      arr.some(function (item, i) {
+        if (getObj(item, valueKey) === getObj(value, valueKey)) {
+          index = i;
+          return true;
+        }
+        return false;
+      });
+      return index;
+    }
+  };
+};
+export var toggleMenu = function toggleMenu(_ref27) {
+  var refs = _ref27.refs,
+    state = _ref27.state,
+    props = _ref27.props;
+  return function () {
+    if (!state.selectDisabled) {
+      !props.ignoreEnter && (state.visible = !state.visible);
+      if (state.softFocus) {
+        !props.ignoreEnter && (state.visible = !state.visible);
+        state.softFocus = false;
+      }
+      if (state.visible) {
+        var dom = refs.input || refs.reference;
+        dom.focus();
+      }
+    }
+  };
+};
+export var selectOption = function selectOption(_ref28) {
+  var api = _ref28.api,
+    state = _ref28.state,
+    props = _ref28.props;
+  return function () {
+    if (!state.visible || props.hideDrop) {
+      api.toggleMenu();
+    } else {
+      if (state.options[state.hoverIndex]) {
+        api.handleOptionSelect(state.options[state.hoverIndex]);
+      }
+    }
+  };
+};
+export var deleteSelected = function deleteSelected(_ref29) {
+  var api = _ref29.api,
+    constants = _ref29.constants,
+    emit = _ref29.emit,
+    props = _ref29.props,
+    vm = _ref29.vm,
+    state = _ref29.state;
+  return function (event) {
+    event.stopPropagation();
+    var value = props.multiple ? [] : '';
+    var refs = vm.$refs;
+    if (props.renderType === constants.TYPE.Tree) {
+      state.selected = {};
+      state.selectedLabel = '';
+      refs.selectTree.setCurrentKey(null);
+    } else if (props.renderType === constants.TYPE.Grid) {
+      state.selected = {};
+      state.selectedLabel = '';
+      refs.selectGrid.clearRadioRow();
+    }
+    state.showTip = false;
+    emit('update:modelValue', value);
+    api.emitChange(value);
+    state.visible = false;
+    emit('clear');
+  };
+};
+export var deleteTag = function deleteTag(_ref30) {
+  var api = _ref30.api,
+    constants = _ref30.constants,
+    emit = _ref30.emit,
+    props = _ref30.props,
+    state = _ref30.state,
+    vm = _ref30.vm;
+  return function (event, tag) {
+    var refs = vm.$refs;
+    var isTree = props.renderType === constants.TYPE.Tree;
+    var index = state.selected.indexOf(tag);
+    var treeValue = [];
+    var treeIds = [tag[props.valueField]];
+    if (isTree && !props.treeOp.checkStrictly) {
+      var node = refs.selectTree.getNode(tag[props.valueField]);
+      if (!node.isLeaf) {
+        treeIds.push.apply(treeIds, _toConsumableArray(api.getChildValue(node.childNodes, props.valueField)));
+      }
+      while (node.parent && !Array.isArray(node.parent.data)) {
+        treeIds.push(node.parent.data[props.valueField]);
+        node = node.parent;
+      }
+      state.selected.slice().map(function (node) {
+        return treeIds.indexOf(node[props.valueField]) === -1 && treeValue.push(node[props.valueField]);
+      });
+    }
+    if (index > -1 && !state.selectDisabled) {
+      var value = props.modelValue.slice();
+      value.splice(index, 1);
+      if (props.renderType === constants.TYPE.Tree) {
+        props.treeOp.checkStrictly && treeValue.push.apply(treeValue, _toConsumableArray(value));
+        refs.selectTree.setCheckedKeys(treeValue);
+      } else if (props.renderType === constants.TYPE.Grid) {
+        var rows = state.selected.slice().filter(function (item) {
+          return value.indexOf(item[props.valueField]) > -1;
+        });
+        refs.selectGrid.clearSelection();
+        refs.selectGrid.setSelection(rows, true);
+      }
+      emit('update:modelValue', isTree ? treeValue : value);
+      api.emitChange(value);
+      emit(constants.EVENT_NAME.removeTag, tag[props.valueField]);
+    }
+    event.stopPropagation();
+  };
+};
+export var onInputChange = function onInputChange(_ref31) {
+  var api = _ref31.api,
+    props = _ref31.props,
+    state = _ref31.state,
+    constants = _ref31.constants,
+    nextTick = _ref31.nextTick;
+  return function () {
+    if (!props.delay) {
+      if (props.filterable && state.query !== state.selectedLabel) {
+        state.query = state.selectedLabel;
+        api.handleQueryChange(state.query);
+        nextTick(function () {
+          state.selectEmitter.emit(constants.EVENT_NAME.updatePopper);
+        });
+      }
+    } else {
+      api.debouncRquest();
+    }
+    nextTick(function () {
+      state.selectEmitter.emit(constants.EVENT_NAME.updatePopper);
+    });
+  };
+};
+export var onOptionDestroy = function onOptionDestroy(state) {
+  return function (index) {
+    if (index > -1) {
+      state.optionsCount--;
+      state.filteredOptionsCount--;
+      state.options.splice(index, 1);
+    }
+  };
+};
+export var resetInputWidth = function resetInputWidth(_ref32) {
+  var refs = _ref32.refs,
+    state = _ref32.state;
+  return function () {
+    state.inputWidth = refs.reference.$el.getBoundingClientRect().width;
+  };
+};
+export var handleResize = function handleResize(_ref33) {
+  var api = _ref33.api,
+    props = _ref33.props;
+  return function () {
+    api.resetInputWidth();
+    if (props.multiple) {
+      api.resetInputHeight();
+    }
+  };
+};
+export var checkDefaultFirstOption = function checkDefaultFirstOption(state) {
+  return function () {
+    state.hoverIndex = -1;
+    var hasCreated = false;
+    for (var i = state.options.length - 1; i >= 0; i--) {
+      if (state.options[i].created) {
+        hasCreated = true;
+        state.hoverIndex = i;
+        break;
+      }
+    }
+    if (hasCreated) {
+      return;
+    }
+    for (var _i = 0; _i !== state.options.length; ++_i) {
+      var option = state.options[_i];
+      if (state.query) {
+        if (!option.disabled && !option.groupDisabled && option.visible) {
+          state.hoverIndex = _i;
+          break;
+        }
+      } else {
+        if (option.itemSelected) {
+          state.hoverIndex = _i;
+          break;
+        }
+      }
+    }
+  };
+};
+export var getValueKey = function getValueKey(props) {
+  return function (item) {
+    if (Object.prototype.toString.call(item.value).toLowerCase() !== '[object object]') {
+      return item.value;
+    }
+    return getObj(item.value, props.valueKey);
+  };
+};
+export var navigateOptions = function navigateOptions(_ref34) {
+  var api = _ref34.api,
+    nextTick = _ref34.nextTick,
+    state = _ref34.state;
+  return function (direction) {
+    var len = state.options.length;
+    if (!state.visible) {
+      state.visible = true;
+      return;
+    }
+    if (len === 0 || state.filteredOptionsCount === 0) {
+      return;
+    }
+    if (!state.optionsAllDisabled) {
+      if (direction === 'next') {
+        state.hoverIndex++;
+        if (state.hoverIndex === len) {
+          state.hoverIndex = 0;
+        }
+      } else if (direction === 'prev') {
+        state.hoverIndex--;
+        if (state.hoverIndex < 0) {
+          state.hoverIndex = len - 1;
+        }
+      }
+      var option = state.options[state.hoverIndex];
+      if (option.disabled === true || option.groupDisabled === true || !option.visible) {
+        api.navigateOptions(direction);
+      }
+      nextTick(function () {
+        return api.scrollToOption(state.hoverOption);
+      });
+    }
+  };
+};
+export var emptyText = function emptyText(_ref35) {
+  var I18N = _ref35.I18N,
+    props = _ref35.props,
+    state = _ref35.state,
+    t = _ref35.t;
+  return function () {
+    if (props.loading) {
+      return props.loadingText || t(I18N.loading);
+    } else {
+      if (props.remote && state.query === '' && props.renderType) {
+        if (props.multiple) {
+          return state.selected.length > 0 || state.remoteData.length > 0;
+        }
+        return state.selected[props.valueField] || state.remoteData.length > 0;
+      }
+      if (props.remote && state.query === '' && state.options.length === 0) {
+        return false;
+      }
+      if (props.filterable && state.query && state.options.length > 0 && state.filteredOptionsCount === 0) {
+        return props.noMatchText || t(I18N.noMatch);
+      }
+      if (!state.options.some(function (option) {
+        return option.visible;
+      })) {
+        return props.noDataText || t(I18N.noData);
+      }
+    }
+    return null;
+  };
+};
+var optmzApis = {
+  exist: function exist(val, multiple) {
+    return multiple ? Array.isArray(val) && val.length : val;
+  },
+  getValueIndex: function getValueIndex(props) {
+    var options = props.options,
+      valueField = props.valueField,
+      modelValue = props.modelValue,
+      multiple = props.multiple;
+    var contain = function contain(val, arr) {
+      return Array.isArray(arr) && ~arr.indexOf(val);
+    };
+    var equal = function equal(val, opt) {
+      return multiple ? contain(opt[valueField], [val]) : opt[valueField] === val;
+    };
+    var start = 0;
+    if (optmzApis.exist(modelValue, multiple)) {
+      var lastVal = multiple ? modelValue[modelValue.length - 1] : modelValue;
+      for (var i = 0; i < options.length; i++) {
+        if (!equal(lastVal, options[i])) continue;
+        return i;
+      }
+    }
+    return start;
+  },
+  getStartIndex: function getStartIndex(_ref36) {
+    var props = _ref36.props,
+      state = _ref36.state;
+    var options = props.options;
+    var optimizeOpts = state.optimizeOpts,
+      optimizeStore = state.optimizeStore;
+    var rSize = optimizeOpts.rSize;
+    var valueIndex = optimizeStore.valueIndex;
+    return valueIndex + rSize > options.length ? options.length - rSize : valueIndex;
+  },
+  getViewStyle: function getViewStyle(_ref37) {
+    var props = _ref37.props,
+      state = _ref37.state;
+    var options = props.options;
+    var optimizeOpts = state.optimizeOpts;
+    var optionHeight = optimizeOpts.optionHeight;
+    return "height:".concat(optionHeight * options.length, "px");
+  },
+  getStoreDatas: function getStoreDatas(_ref38) {
+    var props = _ref38.props,
+      state = _ref38.state;
+    var options = props.options,
+      valueField = props.valueField,
+      modelValue = props.modelValue,
+      multiple = props.multiple;
+    var datas = state.datas,
+      optimizeOpts = state.optimizeOpts,
+      optimizeStore = state.optimizeStore;
+    var startIndex = optimizeStore.startIndex;
+    var rSize = optimizeOpts.rSize;
+    var sliced = datas.slice(startIndex, startIndex + rSize);
+    var hiddenOptions = optimizeStore.hiddenOptions = [];
+    var findPush = function findPush(val) {
+      var opt = options.find(function (option) {
+        return option[valueField] === val;
+      });
+      if (opt && !~sliced.indexOf(opt)) {
+        sliced.push(opt);
+        hiddenOptions.push(opt);
+      }
+    };
+    if (optmzApis.exist(modelValue, multiple)) {
+      if (multiple) {
+        modelValue.forEach(findPush);
+      } else {
+        findPush(modelValue);
+      }
+    }
+    return sliced;
+  },
+  queryWrap: function queryWrap(refs) {
+    return refs.scrollbar.$el.querySelector('.tiny-scrollbar__wrap.virtual');
+  },
+  queryItems: function queryItems(refs) {
+    return refs.scrollbar.$el.querySelectorAll('.tiny-select-dropdown__item.virtual');
+  },
+  createMacro: function createMacro(cb) {
+    return setTimeout(cb);
+  },
+  setScrollTop: function setScrollTop(_ref39) {
+    var refs = _ref39.refs,
+      state = _ref39.state;
+    var optimizeOpts = state.optimizeOpts,
+      optimizeStore = state.optimizeStore;
+    var optionHeight = optimizeOpts.optionHeight;
+    var wrap = optmzApis.queryWrap(refs);
+    wrap.scrollTop = optionHeight * optimizeStore.valueIndex;
+  },
+  setValueIndex: function setValueIndex(_ref40) {
+    var props = _ref40.props,
+      state = _ref40.state;
+    return state.optimizeStore.valueIndex = optmzApis.getValueIndex(props);
+  },
+  addScrollListener: function addScrollListener(_ref41) {
+    var api = _ref41.api,
+      refs = _ref41.refs,
+      state = _ref41.state;
+    var optimizeStore = state.optimizeStore;
+    var wrap = optmzApis.queryWrap(refs);
+    !optimizeStore.bind && wrap.addEventListener('scroll', api.getScrollListener) && (optimizeStore.bind = true);
+  },
+  removeScrollListener: function removeScrollListener(_ref42) {
+    var api = _ref42.api,
+      refs = _ref42.refs,
+      state = _ref42.state;
+    var optimizeStore = state.optimizeStore;
+    var wrap = optmzApis.queryWrap(refs);
+    optimizeStore.bind && wrap.removeEventListener('scroll', api.getScrollListener) && (optimizeStore.bind = false);
+  },
+  isFirstPage: function isFirstPage(_ref43) {
+    var props = _ref43.props,
+      state = _ref43.state;
+    var optimizeStore = state.optimizeStore;
+    var datas = optimizeStore.datas;
+    var options = props.options;
+    return Array.isArray(datas) && Array.isArray(options) && datas[0] === options[0];
+  },
+  natural: function natural(val) {
+    return val < 0 ? 0 : val;
+  },
+  updateItems: function updateItems(_ref44) {
+    var refs = _ref44.refs,
+      state = _ref44.state,
+      itemFn = _ref44.itemFn;
+    var optimizeOpts = state.optimizeOpts;
+    var optionHeight = optimizeOpts.optionHeight;
+    var items = optmzApis.queryItems(refs);
+    for (var i = 0; i < items.length; i++) {
+      var item = items[i];
+      var flag = item.classList.contains('virtual-hidden');
+      item.style.top = flag ? "-".concat(optionHeight, "px") : "".concat(itemFn(i), "px");
+    }
+  },
+  process: function process(_ref45) {
+    var props = _ref45.props,
+      start = _ref45.start,
+      state = _ref45.state;
+    var optimizeStore = state.optimizeStore;
+    optimizeStore.startIndex = typeof start !== 'undefined' ? start : optmzApis.getStartIndex({
+      props: props,
+      state: state
+    });
+    optimizeStore.datas = optmzApis.getStoreDatas({
+      props: props,
+      state: state
+    });
+    optimizeStore.firstPage = optmzApis.isFirstPage({
+      props: props,
+      state: state
+    });
+  }
+};
+export var watchValue = function watchValue(_ref46) {
+  var api = _ref46.api,
+    constants = _ref46.constants,
+    dispatch = _ref46.dispatch,
+    props = _ref46.props,
+    refs = _ref46.refs,
+    state = _ref46.state;
+  return function (value, oldValue) {
+    if (props.multiple) {
+      api.resetInputHeight();
+      if (value && value.length > 0 || refs.input && state.query !== '') {
+        state.currentPlaceholder = '';
+      } else {
+        state.currentPlaceholder = state.cachedPlaceHolder;
+      }
+      if (props.filterable && !props.reserveKeyword) {
+        props.renderType !== constants.TYPE.Grid && (state.query = '');
+        api.handleQueryChange(state.query);
+      }
+    }
+    api.setSelected();
+    if (props.filterable && !props.multiple) {
+      state.inputLength = 20;
+    }
+    if (state.completed && !isEqual(value, oldValue)) {
+      dispatch(constants.COMPONENT_NAME.FormItem, constants.EVENT_NAME.formChange, value);
+    }
+    state.optimizeStore.flag && optmzApis.setValueIndex({
+      props: props,
+      state: state
+    });
+  };
+};
+export var calcOverFlow = function calcOverFlow(_ref47) {
+  var refs = _ref47.refs,
+    props = _ref47.props,
+    state = _ref47.state;
+  return function (height) {
+    if (!props.multiple || !props.showOverflowTooltip) {
+      return;
+    }
+    state.overflow = false;
+    var tagDom = refs.tags;
+    var tags = tagDom.querySelectorAll('.tiny-tag');
+    if (tags.length) {
+      tagDom.scrollTo && tagDom.scrollTo({
+        top: 0
+      });
+      var _tags$0$getBoundingCl = tags[0].getBoundingClientRect(),
+        x = _tags$0$getBoundingCl.x,
+        width = _tags$0$getBoundingCl.width;
+      if (width >= tagDom.getBoundingClientRect().width) {
+        state.overflow = 0;
+      } else {
+        for (var i = 1; i < tags.length; i++) {
+          var tx = tags[i].getBoundingClientRect().x;
+          if (tx == x) {
+            state.overflow = i - 1;
+            break;
+          }
+        }
+      }
+    }
+    refs.select.style.height = refs.select.style.height || height;
+    refs.reference.$el.style.position = 'absolute';
+    var inputWidth = refs.select.getBoundingClientRect().width;
+    var position = state.visible ? 'absolute' : '';
+    state.selectFiexd = {
+      height: height,
+      position: position,
+      width: inputWidth + 'px',
+      zIndex: PopupManager.nextZIndex()
+    };
+    state.inputWidth = inputWidth;
+  };
+};
+var postOperOfToVisible = function postOperOfToVisible(_ref48) {
+  var props = _ref48.props,
+    state = _ref48.state,
+    constants = _ref48.constants;
+  if (props.multiple) {
+    return;
+  }
+  if (state.selected) {
+    if (props.renderType === constants.TYPE.Grid || props.renderType === constants.TYPE.Tree) {
+      state.selectedLabel = state.selected.currentLabel;
+    } else {
+      if (props.filterable && props.allowCreate && state.createdSelected && state.createdLabel) {
+        state.selectedLabel = state.createdLabel;
+      } else {
+        state.selectedLabel = state.selected.state.currentLabel || state.selected.currentLabel;
+      }
+      if (props.filterable) {
+        state.query = state.selectedLabel;
+      }
+    }
+    if (props.filterable) {
+      state.currentPlaceholder = state.cachedPlaceHolder;
+    }
+  }
+};
+export var toVisible = function toVisible(_ref49) {
+  var constants = _ref49.constants,
+    state = _ref49.state,
+    props = _ref49.props,
+    vm = _ref49.vm,
+    api = _ref49.api,
+    nextTick = _ref49.nextTick;
+  return function () {
+    var refs = vm.$refs;
+    state.selectEmitter.emit(constants.EVENT_NAME.destroyPopper);
+    props.remote && props.dropOnlySearch && (state.showWarper = false);
+    if (refs.input) {
+      refs.input.blur();
+    }
+    state.query = '';
+    state.selectedLabel = '';
+    state.inputLength = 20;
+    if (props.renderType !== constants.TYPE.Tree) {
+      state.previousQuery = props.remoteConfig.clearData && state.previousQuery !== state.query ? undefined : null;
+    }
+    api.resetHoverIndex();
+    nextTick(function () {
+      if (refs.input && refs.input.value === '' && state.selected.length === 0) {
+        state.currentPlaceholder = state.cachedPlaceHolder;
+      }
+      if (refs.selectGrid) {
+        refs.selectGrid.clearScroll();
+      }
+    });
+    postOperOfToVisible({
+      props: props,
+      state: state,
+      constants: constants
+    });
+  };
+};
+export var toHide = function toHide(_ref50) {
+  var constants = _ref50.constants,
+    state = _ref50.state,
+    props = _ref50.props,
+    vm = _ref50.vm,
+    api = _ref50.api;
+  return function () {
+    var refs = vm.$refs;
+    state.selectEmitter.emit(constants.COMPONENT_NAME.SelectDropdown, constants.EVENT_NAME.updatePopper);
+    if (props.filterable) {
+      state.query = props.remote ? '' : props.renderType !== constants.TYPE.Tree ? state.selectedLabel : '';
+      state.previousQuery !== state.query && api.handleQueryChange(state.query);
+      if (props.multiple) {
+        refs.input.focus();
+      } else {
+        if (!props.remote) {
+          state.selectEmitter.emit(constants.EVENT_NAME.queryChange, '');
+          state.selectEmitter.emit(constants.COMPONENT_NAME.OptionGroup, constants.EVENT_NAME.queryChange);
+        }
+        if (state.selectedLabel) {
+          state.currentPlaceholder = state.selectedLabel;
+          state.selectedLabel = '';
+        }
+      }
+    }
+    if (refs.selectGrid) {
+      refs.selectGrid.clearSelection();
+      refs.selectGrid.setSelection(state.selected, true);
+      if (props.filterable && typeof props.filterMethod === 'function') {
+        refs.selectGrid.handleTableData(true);
+      } else if (props.filterable && props.remote && typeof props.remoteMethod === 'function') {
+        refs.selectGrid.handleTableData();
+      }
+    }
+  };
+};
+export var watchVisible = function watchVisible(_ref51) {
+  var api = _ref51.api,
+    constants = _ref51.constants,
+    emit = _ref51.emit,
+    state = _ref51.state,
+    refs = _ref51.refs;
+  return function (value) {
+    if (api.onCopying()) {
+      return;
+    }
+    value ? api.toHide() : api.toVisible();
+    emit(constants.EVENT_NAME.visibleChange, value);
+    setTimeout(function () {
+      state.selectEmitter.emit(constants.EVENT_NAME.updatePopper);
+    });
+    if (value && state.optimizeStore.flag) {
+      optmzApis.createMacro(function () {
+        optmzApis.setScrollTop({
+          refs: refs,
+          state: state
+        });
+        api.getScrollListener();
+      });
+    }
+  };
+};
+export var watchOptions = function watchOptions(_ref52) {
+  var api = _ref52.api,
+    constants = _ref52.constants,
+    nextTick = _ref52.nextTick,
+    parent = _ref52.parent,
+    props = _ref52.props,
+    state = _ref52.state;
+  return function () {
+    if (typeof window === 'undefined') {
+      return;
+    }
+    nextTick(function () {
+      state.selectEmitter.emit(constants.EVENT_NAME.updatePopper);
+    });
+    if (props.multiple) {
+      api.resetInputHeight();
+    }
+    nextTick(function () {
+      if (parent.$el.querySelector('input') !== document.activeElement) {
+        api.setSelected();
+      }
+    });
+    if (props.defaultFirstOption && (props.filterable || props.remote) && state.filteredOptionsCount) {
+      api.checkDefaultFirstOption();
+    }
+  };
+};
+export var handleCopyClick = function handleCopyClick(_ref53) {
+  var parent = _ref53.parent,
+    props = _ref53.props,
+    state = _ref53.state;
+  return function () {
+    var input = document.createElement('input');
+    input.style.height = 0;
+    input.style.border = 'none';
+    input.style.position = 'absolute';
+    parent.$el.appendChild(input);
+    input.value = state.selected.map(function (item) {
+      return item.state ? item.state.currentLabel : item.currentLabel;
+    }).join(props.textSplit);
+    input.select();
+    document.execCommand('copy');
+    parent.$el.removeChild(input);
+  };
+};
+export var selectChange = function selectChange(_ref54) {
+  var emit = _ref54.emit,
+    props = _ref54.props,
+    state = _ref54.state;
+  return function (_ref55) {
+    var $table = _ref55.$table,
+      selection = _ref55.selection,
+      checked = _ref55.checked,
+      row = _ref55.row;
+    var textField = props.textField,
+      valueField = props.valueField;
+    var remoteItem = function remoteItem(row) {
+      var removeItem = find(state.selected, function (item) {
+        return item[valueField] === row[valueField];
+      });
+      removeItem && state.selected.splice(state.selected.indexOf(removeItem), 1);
+    };
+    if (row) {
+      checked ? state.selected.push(_objectSpread(_objectSpread({}, row), {}, {
+        value: row[valueField],
+        currentLabel: row[textField]
+      })) : remoteItem(row);
+    } else {
+      checked ? state.selected = state.selected.concat(selection.filter(function (row) {
+        return !~props.modelValue.indexOf(row[valueField]);
+      })) : $table.tableData.forEach(function (row) {
+        return remoteItem(row);
+      });
+    }
+    var keys = state.selected.map(function (item) {
+      return item[valueField];
+    });
+    emit('update:modelValue', keys);
+    emit('change', keys, state.selected);
+  };
+};
+export var getcheckedData = function getcheckedData(_ref56) {
+  var props = _ref56.props,
+    state = _ref56.state;
+  return function () {
+    var checkedKey = [];
+    if (!Array.isArray(state.selected)) {
+      return props.modelValue ? [props.modelValue] : [state.selected[props.valueField]];
+    } else {
+      state.selected.length > 0 && state.selected.forEach(function (item) {
+        checkedKey.push(item[props.valueField]);
+      });
+      return checkedKey;
+    }
+  };
+};
+export var radioChange = function radioChange(_ref57) {
+  var emit = _ref57.emit,
+    props = _ref57.props,
+    state = _ref57.state;
+  return function (_ref58) {
+    var row = _ref58.row;
+    row.value = row[props.valueField];
+    row.currentLabel = row[props.textField];
+    state.selected = row;
+    state.visible = false;
+    state.currentKey = row[props.valueField];
+    emit('update:modelValue', row.value);
+    emit('change', row);
+  };
+};
+export var getTreeData = function getTreeData(props) {
+  return function (data) {
+    var nodes = [];
+    var getChild = function getChild(data, pId) {
+      data.forEach(function (node) {
+        node.pId = pId;
+        nodes.push(node);
+        if (node.children && node.children.length > 0) {
+          getChild(node.children, node[props.valueField]);
+        }
+      });
+    };
+    getChild(data, null);
+    return nodes;
+  };
+};
+export var treeNodeClick = function treeNodeClick(_ref59) {
+  var emit = _ref59.emit,
+    props = _ref59.props,
+    state = _ref59.state;
+  return function (data) {
+    if (!props.multiple) {
+      data.currentLabel = data[props.textField];
+      data.value = data[props.valueField];
+      state.selected = data;
+      state.visible = false;
+      emit('update:modelValue', data.value);
+      emit('change', data);
+    }
+  };
+};
+export var nodeCheckClick = function nodeCheckClick(_ref60) {
+  var emit = _ref60.emit,
+    props = _ref60.props,
+    state = _ref60.state;
+  return function (data, _ref61) {
+    var checkedKeys = _ref61.checkedKeys,
+      checkedNodes = _ref61.checkedNodes;
+    checkedNodes.forEach(function (node) {
+      node.currentLabel = node[props.textField];
+      node.value = node[props.valueField];
+    });
+    emit('update:modelValue', checkedKeys);
+    emit('change', checkedKeys, checkedNodes);
+  };
+};
+export var nodeCollapse = function nodeCollapse(_ref62) {
+  var state = _ref62.state,
+    constants = _ref62.constants;
+  return function () {
+    setTimeout(function () {
+      state.selectEmitter.emit(constants.EVENT_NAME.updatePopper);
+    }, 310);
+  };
+};
+export var nodeExpand = function nodeExpand(_ref63) {
+  var state = _ref63.state,
+    constants = _ref63.constants;
+  return function () {
+    setTimeout(function () {
+      state.selectEmitter.emit(constants.EVENT_NAME.updatePopper);
+    }, 310);
+  };
+};
+export var debouncRquest = function debouncRquest(_ref64) {
+  var api = _ref64.api,
+    state = _ref64.state,
+    props = _ref64.props;
+  return debounce(props.delay, function () {
+    if (props.filterable && state.query !== state.selectedLabel) {
+      state.query = state.selectedLabel;
+      api.handleQueryChange(state.query);
+    }
+  });
+};
+export var getChildValue = function getChildValue() {
+  return function (data, key) {
+    var ids = [];
+    var getChild = function getChild(nodes) {
+      nodes.forEach(function (node) {
+        ids.push(node.data[key]);
+        if (node.childNodes.length > 0) {
+          getChild(node.childNodes);
+        }
+      });
+    };
+    getChild(data);
+    return ids;
+  };
+};
+export var watchPropsOption = function watchPropsOption(_ref65) {
+  var constants = _ref65.constants,
+    parent = _ref65.parent,
+    props = _ref65.props,
+    state = _ref65.state;
+  return function () {
+    var renderType = props.renderType;
+    var _props$treeOp = props.treeOp,
+      key = _props$treeOp.key,
+      parentKey = _props$treeOp.parentKey;
+    var dataset = {
+      dataset: props.options || props.dataset,
+      service: parent.$service,
+      tree: {
+        key: key,
+        parentKey: parentKey
+      }
+    };
+    getDataset(dataset).then(function (data) {
+      if (renderType === constants.TYPE.Tree) {
+        state.treeData = data;
+      } else if (renderType === constants.TYPE.Grid) {
+        state.gridData = data;
+      } else {
+        if (props.cacheOp && props.cacheOp.key) {
+          state.memorize = new Memorize(props.cacheOp);
+          state.datas = state.memorize.assemble(data.slice());
+        } else {
+          state.datas = data;
+        }
+      }
+    });
+  };
+};
+export var buildSelectConfig = function buildSelectConfig(_ref66) {
+  var props = _ref66.props,
+    state = _ref66.state;
+  return function () {
+    var checkRowKeys = state.gridCheckedData;
+    var selectConfig = props.selectConfig;
+    return _objectSpread(_objectSpread({}, selectConfig), {}, {
+      checkRowKeys: checkRowKeys
+    });
+  };
+};
+export var buildRadioConfig = function buildRadioConfig(_ref67) {
+  var props = _ref67.props,
+    state = _ref67.state;
+  return function () {
+    var checkRowKey = state.currentKey;
+    var highlight = true;
+    var radioConfig = props.radioConfig;
+    return _objectSpread(_objectSpread({}, radioConfig), {
+      checkRowKey: checkRowKey,
+      highlight: highlight
+    });
+  };
+};
+export var onMouseenterNative = function onMouseenterNative(_ref68) {
+  var state = _ref68.state;
+  return function () {
+    state.inputHovering = true;
+    if (state.searchSingleCopy && state.selectedLabel) {
+      state.softFocus = true;
+    }
+  };
+};
+export var onMouseleaveNative = function onMouseleaveNative(_ref69) {
+  var state = _ref69.state;
+  return function () {
+    state.inputHovering = false;
+    if (state.searchSingleCopy && state.selectedLabel) {
+      state.softFocus = false;
+    }
+  };
+};
+export var onCopying = function onCopying(_ref70) {
+  var state = _ref70.state,
+    refs = _ref70.refs;
+  return function () {
+    return state.searchSingleCopy && state.selectedLabel && refs.reference && refs.reference.hasSelection && refs.reference.hasSelection();
+  };
+};
+export var watchHoverIndex = function watchHoverIndex(_ref71) {
+  var state = _ref71.state;
+  return function (value) {
+    if (typeof value === 'number' && value > -1) {
+      state.hoverOption = state.options[value] || {};
+    } else if (value === -9) {
+      state.hoverOption = {};
+    }
+    state.options.forEach(function (option) {
+      option.hover = state.hoverOption === option;
+    });
+  };
+};
+export var mounted = function mounted(_ref72) {
+  var api = _ref72.api,
+    parent = _ref72.parent,
+    state = _ref72.state,
+    props = _ref72.props,
+    refs = _ref72.refs;
+  return function () {
+    var parentEl = parent.$el;
+    var inputEl = parentEl.querySelector('input.tiny-input__inner');
+    var inputClientRect = inputEl.getBoundingClientRect();
+    if (inputEl === document.activeElement) {
+      document.activeElement.blur();
+    }
+    state.completed = true;
+    var sizeMap = {
+      mini: 28,
+      small: 32,
+      medium: 36
+    };
+    if (props.multiple && Array.isArray(props.modelValue) && props.modelValue.length > 0) {
+      state.currentPlaceholder = '';
+    }
+    state.initialInputHeight = inputClientRect.height || sizeMap[state.selectSize];
+    addResizeListener(parentEl, api.handleResize);
+    if (refs.tags) {
+      addResizeListener(refs.tags, api.resetInputHeight);
+    }
+    if (props.remote && props.multiple) {
+      api.resetInputHeight();
+    }
+    state.inputWidth = inputClientRect.width;
+    api.setSelected();
+    if (props.dataset) {
+      api.watchPropsOption();
+    }
+  };
+};
+export var unMount = function unMount(_ref73) {
+  var api = _ref73.api,
+    parent = _ref73.parent,
+    refs = _ref73.refs,
+    state = _ref73.state;
+  return function () {
+    if (parent.$el && api.handleResize) {
+      removeResizeListener(parent.$el, api.handleResize);
+    }
+    if (refs.tags) {
+      removeResizeListener(refs.tags, api.resetInputHeight);
+    }
+    state.popperElm = null;
+    state.optimizeStore.flag && optmzApis.removeScrollListener({
+      api: api,
+      refs: refs,
+      state: state
+    });
+  };
+};
+export var computeOptimizeOpts = function computeOptimizeOpts(_ref74) {
+  var props = _ref74.props,
+    state = _ref74.state;
+  return function () {
+    var optimization = props.optimization;
+    var baseOpts = {
+      gt: 20,
+      rSize: 10,
+      optionHeight: 30,
+      limit: 20
+    };
+    var optOpts;
+    if (optimization) {
+      if (typeof optimization === 'boolean') {
+        optOpts = extend(true, {}, baseOpts);
+      } else {
+        optOpts = extend(true, {}, baseOpts, optimization);
+      }
+      optOpts.virtualScroll = optOpts.gt > 0 && optOpts.gt <= state.datas.length;
+      return optOpts;
+    }
+  };
+};
+export var watchOptimizeOpts = function watchOptimizeOpts(_ref75) {
+  var api = _ref75.api,
+    props = _ref75.props,
+    refs = _ref75.refs,
+    state = _ref75.state;
+  return function () {
+    var optimizeOpts = state.optimizeOpts,
+      optimizeStore = state.optimizeStore;
+    if (optimizeOpts) {
+      var virtualScroll = optimizeOpts.virtualScroll,
+        optionHeight = optimizeOpts.optionHeight;
+      optimizeStore.flag = virtualScroll;
+      if (virtualScroll) {
+        optimizeStore.viewStyle = optmzApis.getViewStyle({
+          props: props,
+          state: state
+        });
+        optimizeStore.valueIndex = optmzApis.getValueIndex(props);
+        optmzApis.process({
+          props: props,
+          state: state
+        });
+        optmzApis.createMacro(function () {
+          var itemFn = function itemFn(i) {
+            return optionHeight * (optimizeStore.startIndex + i);
+          };
+          optmzApis.addScrollListener({
+            api: api,
+            refs: refs,
+            state: state
+          });
+          optmzApis.updateItems({
+            refs: refs,
+            state: state,
+            itemFn: itemFn
+          });
+        });
+      }
+    }
+  };
+};
+export var getScrollListener = function getScrollListener(_ref76) {
+  var props = _ref76.props,
+    refs = _ref76.refs,
+    state = _ref76.state;
+  var listener = function listener() {
+    var options = props.options;
+    var optimizeOpts = state.optimizeOpts;
+    var optionHeight = optimizeOpts.optionHeight;
+    var viewHeight = optionHeight * options.length;
+    var _optmzApis$queryWrap = optmzApis.queryWrap(refs),
+      clientHeight = _optmzApis$queryWrap.clientHeight,
+      scrollTop = _optmzApis$queryWrap.scrollTop;
+    var maxScrollTop = viewHeight - clientHeight;
+    var start = Math.floor(scrollTop / optionHeight);
+    if (scrollTop <= maxScrollTop) {
+      optmzApis.process({
+        props: props,
+        start: start,
+        state: state
+      });
+      optmzApis.createMacro(function () {
+        var itemFn = function itemFn(i) {
+          return scrollTop + optionHeight * i - scrollTop % optionHeight;
+        };
+        optmzApis.updateItems({
+          refs: refs,
+          state: state,
+          itemFn: itemFn
+        });
+      });
+    }
+  };
+  var optimization = props.optimization;
+  var delay = optmzApis.natural((optimization && _typeof(optimization) === 'object' ? optimization.delay : null) || 10);
+  return debounce(delay, listener);
+};
+export var computeCollapseTags = function computeCollapseTags(props) {
+  return function () {
+    return props.collapseTags;
+  };
+};
+export var computeMultipleLimit = function computeMultipleLimit(_ref77) {
+  var props = _ref77.props,
+    state = _ref77.state;
+  return function () {
+    var multipleLimit = props.multipleLimit,
+      multiple = props.multiple;
+    var optimizeOpts = state.optimizeOpts,
+      optimizeStore = state.optimizeStore;
+    return optmzApis.natural(multiple && optimizeStore.flag ? multipleLimit || optimizeOpts.limit : multipleLimit);
+  };
+};