@douyinfe/semi-foundation 2.1.1 → 2.1.5

package/lib/cjs/tree/treeUtil.js

@@ -0,0 +1,804 @@
+"use strict";
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.calcCheckedKeys = calcCheckedKeys;
+exports.calcCheckedKeysForChecked = calcCheckedKeysForChecked;
+exports.calcCheckedKeysForUnchecked = calcCheckedKeysForUnchecked;
+exports.calcDisabledKeys = calcDisabledKeys;
+exports.calcDropActualPosition = calcDropActualPosition;
+exports.calcDropRelativePosition = calcDropRelativePosition;
+exports.calcExpandedKeys = calcExpandedKeys;
+exports.calcExpandedKeysForValues = calcExpandedKeysForValues;
+exports.calcMotionKeys = calcMotionKeys;
+exports.convertDataToEntities = convertDataToEntities;
+exports.convertJsonToData = convertJsonToData;
+exports.filter = filter;
+exports.filterTreeData = filterTreeData;
+exports.findAncestorKeys = findAncestorKeys;
+exports.findChildKeys = findChildKeys;
+exports.findDescendantKeys = findDescendantKeys;
+exports.findKeysForValues = findKeysForValues;
+exports.findLeafKeys = findLeafKeys;
+exports.findSiblingKeys = findSiblingKeys;
+exports.flattenTreeData = flattenTreeData;
+exports.getDragNodesKeys = getDragNodesKeys;
+exports.getMotionKeys = getMotionKeys;
+exports.getValueOrKey = getValueOrKey;
+exports.normalizeKeyList = normalizeKeyList;
+exports.normalizeValue = normalizeValue;
+exports.normalizedArr = normalizedArr;
+exports.traverseDataNodes = traverseDataNodes;
+exports.updateKeys = updateKeys;
+
+var _concat = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/concat"));
+
+var _map = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/map"));
+
+var _assign = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/assign"));
+
+var _forEach = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/for-each"));
+
+var _entries = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/entries"));
+
+var _isArray = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/array/is-array"));
+
+var _includes = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/includes"));
+
+var _set = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/set"));
+
+var _every = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/every"));
+
+var _keys = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/keys"));
+
+var _filter = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/filter"));
+
+var _from = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/array/from"));
+
+var _some = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/some"));
+
+var _values = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/values"));
+
+var _get2 = _interopRequireDefault(require("lodash/get"));
+
+var _pick2 = _interopRequireDefault(require("lodash/pick"));
+
+var _isEmpty2 = _interopRequireDefault(require("lodash/isEmpty"));
+
+var _isUndefined2 = _interopRequireDefault(require("lodash/isUndefined"));
+
+var _isNull2 = _interopRequireDefault(require("lodash/isNull"));
+
+var _isObject2 = _interopRequireDefault(require("lodash/isObject"));
+
+var _max2 = _interopRequireDefault(require("lodash/max"));
+
+var _uniq2 = _interopRequireDefault(require("lodash/uniq"));
+
+var _difference2 = _interopRequireDefault(require("lodash/difference"));
+
+const DRAG_OFFSET = 0.45;
+
+function getPosition(level, index) {
+  var _context;
+
+  return (0, _concat.default)(_context = "".concat(level, "-")).call(_context, index);
+}
+
+function isValid(val) {
+  return !(0, _isNull2.default)(val) && !(0, _isUndefined2.default)(val);
+}
+/**
+ * Flat nest tree data into flatten list. This is used for virtual list render.
+ * @param treeNodeList Origin data node list
+ * @param expandedKeys
+ * @param filteredShownKeys
+ * need expanded keys, provides `true` means all expanded
+ */
+// eslint-disable-next-line max-len
+
+
+function flattenTreeData(treeNodeList, expandedKeys) {
+  let filteredShownKeys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  const flattenList = [];
+  const filterSearch = Boolean(filteredShownKeys);
+
+  function flatten(list) {
+    let parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    return (0, _map.default)(list).call(list, (treeNode, index) => {
+      const pos = getPosition(parent ? parent.pos : '0', index);
+      const mergedKey = treeNode.key; // Add FlattenDataNode into list
+
+      const flattenNode = (0, _assign.default)((0, _assign.default)({}, (0, _pick2.default)(treeNode, ['key', 'label', 'value', 'icon', 'disabled', 'isLeaf'])), {
+        parent,
+        pos,
+        children: null,
+        data: treeNode,
+        _innerDataTag: true
+      });
+      const isBooleanFilteredShownKeys = typeof filteredShownKeys === 'boolean';
+
+      if (!filterSearch || !isBooleanFilteredShownKeys && filteredShownKeys.has(mergedKey)) {
+        flattenList.push(flattenNode);
+      } // Loop treeNode children
+      // eslint-disable-next-line max-len
+
+
+      if (expandedKeys.has(mergedKey) && (!filterSearch || !isBooleanFilteredShownKeys && filteredShownKeys.has(mergedKey))) {
+        flattenNode.children = flatten(treeNode.children || [], flattenNode);
+      } else {
+        flattenNode.children = [];
+      }
+
+      return flattenNode;
+    });
+  }
+
+  flatten(treeNodeList);
+  return flattenList;
+}
+
+function convertJsonToData(treeJson) {
+  var _context3;
+
+  const treeData = [];
+
+  const traverseNode = (key, children, path, res) => {
+    const currPath = [...path, key];
+    const itemKey = currPath.join('-');
+    const newNode = {
+      key: itemKey,
+      label: key,
+      value: children
+    };
+
+    if ((0, _isObject2.default)(children)) {
+      var _context2;
+
+      const childres = [];
+      (0, _forEach.default)(_context2 = (0, _entries.default)(children)).call(_context2, c => {
+        traverseNode(c[0], c[1], currPath, childres);
+      });
+      newNode.children = childres;
+    }
+
+    res.push(newNode);
+  };
+
+  (0, _forEach.default)(_context3 = (0, _entries.default)(treeJson)).call(_context3, item => traverseNode(item[0], item[1], [], treeData));
+  return treeData;
+}
+/**
+ * Traverse all the data by `treeData`.
+ */
+
+
+function traverseDataNodes(treeNodes, callback) {
+  const processNode = (node, ind, parent) => {
+    const children = node ? node.children : treeNodes;
+    const pos = node ? getPosition(parent.pos, ind) : '0'; // Process node if is not root
+
+    if (node) {
+      const data = {
+        data: (0, _assign.default)({}, node),
+        ind,
+        pos,
+        key: node.key !== null ? node.key : pos,
+        parentPos: parent.node ? parent.pos : null,
+        level: Number(parent.level) + 1
+      };
+      callback(data);
+    } // Process children node
+
+
+    if (children) {
+      (0, _forEach.default)(children).call(children, (subNode, subIndex) => {
+        processNode(subNode, subIndex, {
+          node,
+          pos,
+          level: parent ? Number(parent.level) + 1 : -1
+        });
+      });
+    }
+  };
+
+  processNode(null);
+}
+/* Convert data to entities map */
+
+
+function convertDataToEntities(dataNodes) {
+  const posEntities = {};
+  const keyEntities = {};
+  const valueEntities = {};
+  const wrapper = {
+    posEntities,
+    keyEntities,
+    valueEntities
+  };
+  traverseDataNodes(dataNodes, data => {
+    const {
+      pos,
+      key,
+      parentPos
+    } = data;
+    const entity = (0, _assign.default)({}, data);
+    const value = (0, _get2.default)(entity, 'data.value', null);
+
+    if (value !== null) {
+      valueEntities[value] = key;
+    }
+
+    posEntities[pos] = entity;
+    keyEntities[key] = entity; // Fill children
+
+    entity.parent = posEntities[parentPos];
+
+    if (entity.parent) {
+      entity.parent.children = entity.parent.children || [];
+      entity.parent.children.push(entity);
+    }
+  });
+  return wrapper;
+}
+/* Get key by value */
+
+
+function findKeysForValues(valueList, valueEntities) {
+  let isMultiple = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+
+  if (!isValid(valueList)) {
+    return [];
+  }
+
+  if (!isMultiple && (0, _isArray.default)(valueList)) {
+    valueList = valueList.length ? [valueList[0]] : [];
+  } else if (!(0, _isArray.default)(valueList)) {
+    valueList = [valueList];
+  }
+
+  if ((0, _isEmpty2.default)(valueEntities)) {
+    return valueList;
+  }
+
+  const res = [];
+  (0, _forEach.default)(valueList).call(valueList, val => {
+    if (val in valueEntities) {
+      res.push(valueEntities[val]);
+    }
+  });
+  return res;
+}
+
+function findDescendantKeys(selectedKeys, options) {
+  let self = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  const res = [];
+
+  const findChild = item => {
+    if (!item) {
+      return;
+    }
+
+    const {
+      children
+    } = item;
+    const hasChildren = isValid(children);
+
+    if (hasChildren) {
+      (0, _forEach.default)(children).call(children, child => {
+        res.push(child.key);
+        findChild(options[child.key]);
+      });
+    }
+  };
+
+  (0, _forEach.default)(selectedKeys).call(selectedKeys, item => {
+    if (self) {
+      res.push(item);
+    }
+
+    findChild(options[item]);
+  });
+  return res;
+}
+
+function findChildKeys(keys, options) {
+  let omitKeys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  const res = [];
+  keys && (0, _forEach.default)(keys).call(keys, key => {
+    var _context4;
+
+    const opts = options[key];
+    opts && opts.children && (0, _forEach.default)(_context4 = opts.children).call(_context4, child => {
+      if (!omitKeys.length || !(0, _includes.default)(omitKeys).call(omitKeys, child.key)) {
+        res.push(child.key);
+      }
+    });
+  });
+  return res;
+}
+
+function findLeafKeys(keys, options) {
+  const res = [];
+
+  const findChild = item => {
+    if (!item) {
+      return;
+    }
+
+    const {
+      children
+    } = item;
+    const isLeaf = !isValid(children);
+
+    if (isLeaf) {
+      res.push(item.key);
+    } else {
+      (0, _forEach.default)(children).call(children, child => {
+        findChild(options[child.key]);
+      });
+    }
+  };
+
+  (0, _forEach.default)(keys).call(keys, item => {
+    findChild(options[item]);
+  });
+  return res;
+}
+
+function findSiblingKeys(selectedKeys, options) {
+  let self = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  const par = [];
+  (0, _forEach.default)(selectedKeys).call(selectedKeys, item => {
+    if (options[item] && options[item].parent) {
+      par.push(options[item].parent.key);
+    }
+  });
+  const res = findChildKeys((0, _uniq2.default)(par), options, self ? [] : selectedKeys);
+  return res;
+}
+
+function findAncestorKeys(selectedKeys, options) {
+  let self = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  const res = []; // Recursively find the parent element
+
+  const findPar = item => {
+    if (item.parent) {
+      res.push(item.parent.key);
+      findPar(item.parent);
+    }
+  };
+
+  (0, _forEach.default)(selectedKeys).call(selectedKeys, item => {
+    options[item] && findPar(options[item]);
+
+    if (self) {
+      res.push(item);
+    }
+  });
+  return res;
+}
+
+function getSortedKeyList(keyList, keyEntities) {
+  const levelMap = {};
+  (0, _forEach.default)(keyList).call(keyList, key => {
+    if (!keyEntities[key]) {
+      return;
+    }
+
+    const {
+      level
+    } = keyEntities[key];
+
+    if (levelMap[level]) {
+      levelMap[level].push(key);
+    } else {
+      levelMap[level] = [key];
+    }
+  });
+  return levelMap;
+}
+
+function calcCheckedKeys(values, keyEntities) {
+  const keyList = (0, _isArray.default)(values) ? values : [values];
+  const descendantKeys = findDescendantKeys(keyList, keyEntities, true);
+  /**
+   * Recursively find the parent element. Because the incoming nodes are all checked,
+   * their descendants must be checked. That is to say, if the descendant nodes have
+   *  disabled+unchecked nodes, their ancestor nodes will definitely not be checked
+   */
+
+  const checkedKeys = new _set.default([...descendantKeys]);
+  let halfCheckedKeys = new _set.default([]);
+  let visited = [];
+  const levelMap = getSortedKeyList(keyList, keyEntities);
+
+  const calcCurrLevel = node => {
+    const {
+      key,
+      parent,
+      level
+    } = node; // If the node does not have a parent node, or the node has been processed just now, no processing is done
+
+    if (!parent || (0, _includes.default)(visited).call(visited, key)) {
+      return;
+    }
+
+    const siblingKeys = findSiblingKeys([key], keyEntities); // visited for caching to avoid double counting
+
+    visited = [...visited, ...siblingKeys];
+    const allChecked = (0, _every.default)(siblingKeys).call(siblingKeys, siblingKey => checkedKeys.has(siblingKey));
+
+    if (!allChecked) {
+      const ancesterKeys = findAncestorKeys([key], keyEntities, false);
+      halfCheckedKeys = new _set.default([...halfCheckedKeys, ...ancesterKeys]);
+    } else {
+      checkedKeys.add(parent.key); // IMPORTANT! parent level may not exist in original level map; if add to the end directly may destroy the hierarchical order
+
+      if (level - 1 in levelMap && level) {
+        levelMap[level - 1].push(parent.key);
+      } else {
+        levelMap[level - 1] = [parent.key];
+      }
+    }
+  }; // Loop keyList from deepest Level to topLevel, bottom up
+
+
+  while (!(0, _isEmpty2.default)(levelMap)) {
+    var _context5, _context6;
+
+    const maxLevel = (0, _max2.default)((0, _map.default)(_context5 = (0, _keys.default)(levelMap)).call(_context5, key => Number(key)));
+    (0, _forEach.default)(_context6 = levelMap[maxLevel]).call(_context6, key => calcCurrLevel(keyEntities[key]));
+    delete levelMap[maxLevel];
+  }
+
+  return {
+    checkedKeys,
+    halfCheckedKeys
+  };
+}
+/* Calculate the expanded node by key */
+
+
+function calcExpandedKeys() {
+  let keyList = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  let keyEntities = arguments.length > 1 ? arguments[1] : undefined;
+  let autoExpandParent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+
+  if (!(0, _isArray.default)(keyList)) {
+    keyList = [keyList];
+  }
+
+  if (autoExpandParent) {
+    const ancesterKeys = findAncestorKeys(keyList, keyEntities, true);
+    return new _set.default(ancesterKeys);
+  }
+
+  return new _set.default(keyList);
+}
+/* Calculate the expanded node by value */
+// eslint-disable-next-line max-len
+
+
+function calcExpandedKeysForValues(value, keyEntities, isMultiple, valueEntities) {
+  const keys = findKeysForValues(value, valueEntities, isMultiple);
+  return new _set.default(findAncestorKeys(keys, keyEntities, false));
+}
+
+function calcMotionKeys(oldKeySet, newKeySet, keyEntities) {
+  let motionType = 'show';
+  const oldKeys = [...oldKeySet];
+  const newKeys = [...newKeySet];
+
+  if (Math.abs(oldKeys.length - newKeys.length) !== 1) {
+    return {
+      motionType,
+      motionKeys: []
+    };
+  }
+
+  let diffKeys = [];
+
+  if (oldKeys.length > newKeys.length) {
+    motionType = 'hide';
+    diffKeys = (0, _difference2.default)(oldKeys, newKeys);
+  } else {
+    diffKeys = (0, _difference2.default)(newKeys, oldKeys);
+  }
+
+  return {
+    motionType: diffKeys.length === 1 ? motionType : 'show',
+    motionKeys: diffKeys.length === 1 ? findDescendantKeys(diffKeys, keyEntities, false) : []
+  };
+}
+/**
+ * @returns whether option includes sugInput.
+ * When filterTreeNode is a function,returns the result of filterTreeNode which called with (sugInput, option).
+ */
+
+
+function filter(sugInput, option, filterTreeNode, filterProps) {
+  if (!filterTreeNode) {
+    return true;
+  }
+
+  let filterFn = filterTreeNode;
+  let target = option;
+
+  if (typeof filterTreeNode === 'boolean') {
+    filterFn = (targetVal, val) => {
+      var _context7;
+
+      const input = targetVal.toLowerCase();
+      return (0, _includes.default)(_context7 = val.toString().toLowerCase()).call(_context7, input);
+    };
+  }
+
+  if (filterProps) {
+    target = option[filterProps];
+  }
+
+  return filterFn(sugInput, target);
+}
+
+function normalizedArr(val) {
+  if (!(0, _isArray.default)(val)) {
+    return [val];
+  } else {
+    return val;
+  }
+}
+
+function normalizeKeyList(keyList, keyEntities) {
+  let leafOnly = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  let res = [];
+  const keyListSet = new _set.default(keyList);
+
+  if (!leafOnly) {
+    (0, _forEach.default)(keyList).call(keyList, key => {
+      if (!keyEntities[key]) {
+        return;
+      }
+
+      const {
+        parent
+      } = keyEntities[key];
+
+      if (parent && keyListSet.has(parent.key)) {
+        return;
+      }
+
+      res.push(key);
+    });
+  } else {
+    var _context8;
+
+    res = (0, _filter.default)(_context8 = (0, _from.default)(keyList)).call(_context8, key => keyEntities[key] && !isValid(keyEntities[key].children));
+  }
+
+  return res;
+}
+
+function getMotionKeys(eventKey, expandedKeys, keyEntities) {
+  const res = [];
+
+  const getChild = itemKey => {
+    var _context9;
+
+    keyEntities[itemKey].children && (0, _forEach.default)(_context9 = keyEntities[itemKey].children).call(_context9, item => {
+      const {
+        key
+      } = item;
+      res.push(key);
+
+      if (expandedKeys.has(key)) {
+        getChild(key);
+      }
+    });
+  };
+
+  getChild(eventKey);
+  return res;
+} // eslint-disable-next-line max-len
+
+
+function calcCheckedKeysForChecked(key, keyEntities, checkedKeys, halfCheckedKeys) {
+  const descendantKeys = findDescendantKeys([key], keyEntities, true);
+  const nodeItem = keyEntities[key];
+  checkedKeys = new _set.default([...checkedKeys, key]);
+
+  const calcCurrLevel = node => {
+    if (!node.parent) {
+      return;
+    } // eslint-disable-next-line @typescript-eslint/no-shadow
+
+
+    const {
+      key
+    } = node;
+    const siblingKeys = findSiblingKeys([key], keyEntities); // eslint-disable-next-line @typescript-eslint/no-shadow
+
+    const allChecked = (0, _every.default)(siblingKeys).call(siblingKeys, key => checkedKeys.has(key));
+
+    if (!allChecked) {
+      const ancesterKeys = findAncestorKeys([key], keyEntities, false);
+      halfCheckedKeys = new _set.default([...halfCheckedKeys, ...ancesterKeys]);
+    } else {
+      const par = node.parent;
+      checkedKeys.add(par.key);
+      calcCurrLevel(par);
+    }
+  };
+
+  calcCurrLevel(nodeItem);
+  return {
+    checkedKeys: new _set.default([...checkedKeys, ...descendantKeys]),
+    halfCheckedKeys
+  };
+} // eslint-disable-next-line max-len
+
+
+function calcCheckedKeysForUnchecked(key, keyEntities, checkedKeys, halfCheckedKeys) {
+  const descendantKeys = findDescendantKeys([key], keyEntities, true);
+  const nodeItem = keyEntities[key];
+  (0, _forEach.default)(descendantKeys).call(descendantKeys, descendantKey => {
+    if (checkedKeys.has(descendantKey)) {
+      checkedKeys.delete(descendantKey);
+    }
+
+    if (halfCheckedKeys.has(descendantKey)) {
+      halfCheckedKeys.delete(descendantKey);
+    }
+  });
+
+  const calcCurrLevel = node => {
+    const par = node.parent; // no parent
+
+    if (!par) {
+      return;
+    } // Has a parent node, and the parent node is not checked or halfChecked
+
+
+    if (!checkedKeys.has(par.key) && !halfCheckedKeys.has(par.key)) {
+      return;
+    } // Has a parent node, and the parent node is checked or halfChecked
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+
+
+    const {
+      key
+    } = node;
+    const siblingKeys = findSiblingKeys([key], keyEntities); // eslint-disable-next-line @typescript-eslint/no-shadow
+
+    const anyChecked = (0, _some.default)(siblingKeys).call(siblingKeys, key => checkedKeys.has(key) || halfCheckedKeys.has(key));
+    const ancesterKeys = findAncestorKeys([key], keyEntities, false); // If there is checked or halfChecked in the sibling node, you need to change the parent node to halfChecked
+
+    if (anyChecked) {
+      (0, _forEach.default)(ancesterKeys).call(ancesterKeys, itemKey => {
+        if (checkedKeys.has(itemKey)) {
+          checkedKeys.delete(itemKey);
+          halfCheckedKeys.add(itemKey);
+        }
+      }); // If there is no checked or halfChecked in the sibling node, you need to change the parent node to unchecked
+    } else {
+      if (checkedKeys.has(par.key)) {
+        checkedKeys.delete(par.key);
+      }
+
+      if (halfCheckedKeys.has(par.key)) {
+        halfCheckedKeys.delete(par.key);
+      }
+
+      calcCurrLevel(par);
+    }
+  };
+
+  calcCurrLevel(nodeItem);
+  return {
+    checkedKeys,
+    halfCheckedKeys
+  };
+}
+
+function filterTreeData(info) {
+  var _context10, _context11;
+
+  const {
+    showFilteredOnly,
+    keyEntities,
+    inputValue,
+    treeData,
+    filterTreeNode,
+    filterProps,
+    prevExpandedKeys
+  } = info;
+  let filteredOptsKeys = [];
+  filteredOptsKeys = (0, _map.default)(_context10 = (0, _filter.default)(_context11 = (0, _values.default)(keyEntities)).call(_context11, item => filter(inputValue, item.data, filterTreeNode, filterProps))).call(_context10, item => item.key);
+  let expandedOptsKeys = findAncestorKeys(filteredOptsKeys, keyEntities, false);
+
+  if (prevExpandedKeys.length) {
+    const prevExpandedValidKeys = (0, _filter.default)(prevExpandedKeys).call(prevExpandedKeys, key => Boolean(keyEntities[key]));
+    expandedOptsKeys = (0, _concat.default)(expandedOptsKeys).call(expandedOptsKeys, prevExpandedValidKeys);
+  }
+
+  const shownChildKeys = findDescendantKeys(filteredOptsKeys, keyEntities, true);
+  const filteredShownKeys = new _set.default([...shownChildKeys, ...expandedOptsKeys]);
+  const flattenNodes = flattenTreeData(treeData, new _set.default(expandedOptsKeys), showFilteredOnly && filteredShownKeys);
+  return {
+    flattenNodes,
+    filteredKeys: new _set.default(filteredOptsKeys),
+    filteredExpandedKeys: new _set.default(expandedOptsKeys),
+    filteredShownKeys
+  };
+} // return data.value if data.value exist else fall back to key
+
+
+function getValueOrKey(data) {
+  if ((0, _isArray.default)(data)) {
+    return (0, _map.default)(data).call(data, item => (0, _get2.default)(item, 'value', item.key));
+  }
+
+  return (0, _get2.default)(data, 'value', data.key);
+}
+/* Convert value to string */
+
+
+function normalizeValue(value, withObject) {
+  if (withObject && isValid(value)) {
+    return getValueOrKey(value);
+  } else {
+    return value;
+  }
+}
+
+function updateKeys(keySet, keyEntities) {
+  const keyArr = [...keySet];
+  return (0, _filter.default)(keyArr).call(keyArr, key => key in keyEntities);
+}
+
+function calcDisabledKeys(keyEntities) {
+  var _context12;
+
+  const disabledKeys = (0, _filter.default)(_context12 = (0, _keys.default)(keyEntities)).call(_context12, key => keyEntities[key].data.disabled);
+  const {
+    checkedKeys
+  } = calcCheckedKeys(disabledKeys, keyEntities);
+  return checkedKeys;
+}
+
+function calcDropRelativePosition(event, treeNode) {
+  const {
+    clientY
+  } = event;
+  const {
+    top,
+    bottom,
+    height
+  } = treeNode.nodeInstance.getBoundingClientRect(); // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
+
+  if (clientY <= top + height * DRAG_OFFSET) {
+    return -1;
+  }
+
+  if (clientY >= bottom - height * DRAG_OFFSET) {
+    return 1;
+  }
+
+  return 0;
+}
+
+function getDragNodesKeys(key, keyEntities) {
+  return findDescendantKeys([key], keyEntities, true);
+}
+
+function calcDropActualPosition(pos, relativeDropPos) {
+  const posArr = pos.split('-'); // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
+
+  return relativeDropPos + Number(posArr[posArr.length - 1]);
+}