rsuite/cjs/utils/treeUtils.js

A suite of react components

"use strict";

var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

exports.__esModule = true;
exports.shouldShowNodeByParentExpanded = shouldShowNodeByParentExpanded;
exports.flattenTree = flattenTree;
exports.getNodeParents = getNodeParents;
exports.getNodeParentKeys = getNodeParentKeys;
exports.hasVisibleChildren = hasVisibleChildren;
exports.compareArray = compareArray;
exports.getDefaultExpandItemValues = getDefaultExpandItemValues;
exports.getExpandItemValues = getExpandItemValues;
exports.getDragNodeKeys = getDragNodeKeys;
exports.calDropNodePosition = calDropNodePosition;
exports.removeDragNode = removeDragNode;
exports.createUpdateTreeDataFunction = createUpdateTreeDataFunction;
exports.findNodeOfTree = findNodeOfTree;
exports.filterNodesOfTree = filterNodesOfTree;
exports.leftArrowHandler = leftArrowHandler;
exports.rightArrowHandler = rightArrowHandler;
exports.getExpandWhenSearching = getExpandWhenSearching;
exports.getTreeActiveNode = getTreeActiveNode;
exports.toggleExpand = toggleExpand;
exports.getTreeNodeTitle = getTreeNodeTitle;
exports.getChildrenByFlattenNodes = getChildrenByFlattenNodes;
exports.useTreeDrag = useTreeDrag;
exports.useFlattenTreeData = useFlattenTreeData;
exports.useTreeNodeRefs = useTreeNodeRefs;
exports.useTreeSearch = useTreeSearch;
exports.useGetTreeNodeChildren = useGetTreeNodeChildren;
exports.focusToActiveTreeNode = focusToActiveTreeNode;
exports.isSearching = isSearching;
exports.getTreeNodeIndent = getTreeNodeIndent;
exports.getNodeFormattedRefKey = getNodeFormattedRefKey;
exports.getScrollToIndex = exports.focusPreviousItem = exports.focusNextItem = exports.focusTreeNode = exports.getElementByDataKey = exports.getActiveItem = exports.getActiveIndex = exports.getFocusableItems = void 0;

var _extends3 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));

var _isEmpty2 = _interopRequireDefault(require("lodash/isEmpty"));

var _clone2 = _interopRequireDefault(require("lodash/clone"));

var _isNil2 = _interopRequireDefault(require("lodash/isNil"));

var _isArray2 = _interopRequireDefault(require("lodash/isArray"));

var _omit2 = _interopRequireDefault(require("lodash/omit"));

var _isUndefined2 = _interopRequireDefault(require("lodash/isUndefined"));

var _intersection2 = _interopRequireDefault(require("lodash/intersection"));

var _react = _interopRequireWildcard(require("react"));

var _shallowEqualArray = _interopRequireDefault(require("../utils/shallowEqualArray"));

var _utils = require("../CheckTreePicker/utils");

var _utils2 = require("../utils");

var _Picker = require("../Picker");

var _reactToString = _interopRequireDefault(require("./reactToString"));

var _constants = require("./constants");

var _attachParent = require("./attachParent");

// gap of tree node
var TREE_NODE_GAP = 4;
/**
 * according node parentNode expand state decide node whether to show
 * @param {*} expandItemValues
 * @param {*} parentKeys
 */

function shouldShowNodeByParentExpanded(expandItemValues, parentKeys) {
  if (expandItemValues === void 0) {
    expandItemValues = [];
  }

  if (parentKeys === void 0) {
    parentKeys = [];
  }

  var intersectionKeys = (0, _intersection2.default)(expandItemValues, parentKeys);

  if (intersectionKeys.length === parentKeys.length) {
    return true;
  }

  return false;
}
/**
 * flatten tree structure to array
 * @param {*} tree
 * @param {*} childrenKey
 * @param {*} executor
 */


function flattenTree(tree, childrenKey, executor) {
  if (childrenKey === void 0) {
    childrenKey = 'children';
  }

  var flattenData = [];

  var traverse = function traverse(data, parent) {
    if (!(0, _isArray2.default)(data)) {
      return;
    }

    data.forEach(function (item, index) {
      var node = typeof executor === 'function' ? executor(item, index) : item;
      flattenData.push((0, _attachParent.attachParent)(node, parent));

      if (item[childrenKey]) {
        traverse(item[childrenKey], item);
      }
    });
  };

  traverse(tree, null);
  return flattenData;
}
/**
 * get all ancestor nodes of given node
 * @param {*} node
 */


function getNodeParents(node, parentKey, valueKey) {
  if (parentKey === void 0) {
    parentKey = 'parent';
  }

  var parents = [];

  var traverse = function traverse(node) {
    if (node !== null && node !== void 0 && node[parentKey]) {
      traverse(node[parentKey]);

      if (valueKey) {
        parents.push(node[parentKey][valueKey]);
      } else {
        parents.push(node[parentKey]);
      }
    }
  };

  traverse(node);
  return parents;
}
/**
 * get all parentKeys of given node
 * @param nodes
 * @param node
 * @param valueKey
 */


function getNodeParentKeys(nodes, node, valueKey) {
  var parentKeys = [];

  var traverse = function traverse(node) {
    var _node$parent;

    if (node !== null && node !== void 0 && (_node$parent = node.parent) !== null && _node$parent !== void 0 && _node$parent.refKey) {
      var _node$parent2;

      traverse(nodes[node.parent.refKey]);
      parentKeys.push(node === null || node === void 0 ? void 0 : (_node$parent2 = node.parent) === null || _node$parent2 === void 0 ? void 0 : _node$parent2[valueKey]);
    }
  };

  traverse(node);
  return parentKeys;
}

function hasVisibleChildren(node, childrenKey) {
  if (!Array.isArray(node[childrenKey])) {
    return false;
  }

  return node[childrenKey].some(function (child) {
    return child.visible;
  });
}
/**
 * shallow equal array
 * @param a
 * @param b
 */


function compareArray(a, b) {
  return (0, _isArray2.default)(a) && (0, _isArray2.default)(b) && !(0, _shallowEqualArray.default)(a, b);
}

function getDefaultExpandItemValues(data, props) {
  var valueKey = props.valueKey,
      defaultExpandAll = props.defaultExpandAll,
      childrenKey = props.childrenKey,
      _props$defaultExpandI = props.defaultExpandItemValues,
      defaultExpandItemValues = _props$defaultExpandI === void 0 ? [] : _props$defaultExpandI;

  if (defaultExpandAll) {
    return flattenTree(data, childrenKey).filter(function (item) {
      return Array.isArray(item[childrenKey]) && item[childrenKey].length > 0;
    }).map(function (item) {
      return item[valueKey];
    });
  }

  return defaultExpandItemValues;
}
/**
 * 获取 expandItemValues 的 value
 * @param props
 */


function getExpandItemValues(props) {
  var expandItemValues = props.expandItemValues,
      defaultExpandItemValues = props.defaultExpandItemValues;

  if (!(0, _isUndefined2.default)(expandItemValues) && Array.isArray(expandItemValues)) {
    return expandItemValues;
  }

  if (!(0, _isUndefined2.default)(defaultExpandItemValues) && Array.isArray(defaultExpandItemValues)) {
    return defaultExpandItemValues;
  }

  return [];
}
/**
 * get dragNode and it's children node keys
 * @param node
 * @param childrenKey
 * @param valueKey
 */


function getDragNodeKeys(dragNode, childrenKey, valueKey) {
  var dragNodeKeys = [dragNode[valueKey]];

  var traverse = function traverse(data) {
    if ((data === null || data === void 0 ? void 0 : data.length) > 0) {
      data.forEach(function (node) {
        dragNodeKeys = dragNodeKeys.concat([node[valueKey]]);

        if (node[childrenKey]) {
          traverse(node[childrenKey]);
        }
      });
    }
  };

  traverse(dragNode[childrenKey]);
  return dragNodeKeys;
}

function calDropNodePosition(event, treeNodeElement) {
  var clientY = event.clientY;

  var _treeNodeElement$getB = treeNodeElement.getBoundingClientRect(),
      top = _treeNodeElement$getB.top,
      bottom = _treeNodeElement$getB.bottom;

  var gap = TREE_NODE_GAP; // bottom of node

  if (clientY >= bottom - gap && clientY <= bottom) {
    return _utils2.TREE_NODE_DROP_POSITION.DRAG_OVER_BOTTOM;
  } // top of node


  if (clientY <= top + gap && clientY >= top) {
    return _utils2.TREE_NODE_DROP_POSITION.DRAG_OVER_TOP;
  }

  if (clientY >= top + gap && clientY <= bottom - gap) {
    return _utils2.TREE_NODE_DROP_POSITION.DRAG_OVER;
  }

  return -1;
}

function removeDragNode(data, params, _ref) {
  var valueKey = _ref.valueKey,
      childrenKey = _ref.childrenKey;
  var dragNode = params.dragNode;

  var traverse = function traverse(items, parent) {
    for (var _index = 0; _index < items.length; _index += 1) {
      var _item = items[_index];

      if ((0, _utils2.shallowEqual)(_item[valueKey], dragNode[valueKey])) {
        items.splice(_index, 1); // when children is empty, delete children prop for hidden anchor

        if (items.length === 0 && parent) {
          delete parent.children;
        }

        break;
      }

      if (Array.isArray(_item[childrenKey])) {
        traverse(_item[childrenKey], _item);
      }
    }
  };

  traverse(data);
}

function createUpdateTreeDataFunction(params, _ref2) {
  var valueKey = _ref2.valueKey,
      childrenKey = _ref2.childrenKey;
  return function (tree) {
    var data = [].concat(tree);
    var dragNode = params.dragNode,
        dropNode = params.dropNode,
        dropNodePosition = params.dropNodePosition;
    var cloneDragNode = (0, _extends3.default)({}, dragNode);
    removeDragNode(data, params, {
      valueKey: valueKey,
      childrenKey: childrenKey
    });

    var updateTree = function updateTree(items) {
      for (var _index2 = 0; _index2 < items.length; _index2 += 1) {
        var _item2 = items[_index2];

        if ((0, _utils2.shallowEqual)(_item2[valueKey], dropNode[valueKey])) {
          // drag to node inside
          if (dropNodePosition === _utils2.TREE_NODE_DROP_POSITION.DRAG_OVER) {
            _item2[childrenKey] = (0, _isNil2.default)(_item2[childrenKey]) ? [] : _item2[childrenKey];

            _item2[childrenKey].push(cloneDragNode);

            break;
          } else if (dropNodePosition === _utils2.TREE_NODE_DROP_POSITION.DRAG_OVER_TOP) {
            // drag to top of node
            items.splice(_index2, 0, cloneDragNode);
            break;
          } else if (dropNodePosition === _utils2.TREE_NODE_DROP_POSITION.DRAG_OVER_BOTTOM) {
            // drag to bottom of node
            items.splice(_index2 + 1, 0, cloneDragNode);
            break;
          }
        }

        if (Array.isArray(_item2[childrenKey]) && _item2[childrenKey].length > 0) {
          updateTree(_item2[childrenKey]);
        }
      }
    };

    updateTree(data);
    return [].concat(data);
  };
}

function findNodeOfTree(data, check) {
  var findNode = function findNode(nodes) {
    if (nodes === void 0) {
      nodes = [];
    }

    for (var i = 0; i < nodes.length; i += 1) {
      var _item3 = nodes[i];

      if ((0, _isArray2.default)(_item3.children)) {
        var _node = findNode(_item3.children);

        if (_node) {
          return _node;
        }
      }

      if (check(_item3)) {
        return _item3;
      }
    }

    return undefined;
  };

  return findNode(data);
}

function filterNodesOfTree(data, check) {
  var findNodes = function findNodes(nodes) {
    if (nodes === void 0) {
      nodes = [];
    }

    var nextNodes = [];

    for (var i = 0; i < nodes.length; i += 1) {
      if ((0, _isArray2.default)(nodes[i].children)) {
        var nextChildren = findNodes(nodes[i].children);

        if (nextChildren.length) {
          var _item4 = (0, _clone2.default)(nodes[i]);

          _item4.children = nextChildren;
          nextNodes.push(_item4);
          continue;
        }
      }

      if (check(nodes[i])) {
        nextNodes.push(nodes[i]);
      }
    }

    return nextNodes;
  };

  return findNodes(data);
}
/**
 * get all focusable items
 * exclude not visible and disabled node
 * @param filteredData - filtered tree data
 * @param props - TreeProps
 * @param isSearching - component is in Searching
 * @returns
 */


var getFocusableItems = function getFocusableItems(filteredData, props, isSearching) {
  var disabledItemValues = props.disabledItemValues,
      valueKey = props.valueKey,
      childrenKey = props.childrenKey,
      expandItemValues = props.expandItemValues;
  var items = [];

  var loop = function loop(nodes) {
    nodes.forEach(function (node) {
      var disabled = disabledItemValues.some(function (disabledItem) {
        return (0, _utils2.shallowEqual)(disabledItem, node[valueKey]);
      });

      if (!disabled && node.visible) {
        items.push(node);
      } // always expand when searching


      var expand = isSearching ? true : expandItemValues.includes(node[valueKey]);

      if (node[childrenKey] && expand) {
        loop(node[childrenKey]);
      }
    });
  };

  loop(filteredData);
  return items;
};
/**
 * return all focusable Item and active Element index
 * @param focusItemValue
 * @param focusableItems items
 */


exports.getFocusableItems = getFocusableItems;

var getActiveIndex = function getActiveIndex(focusItemValue, focusItems, valueKey) {
  var activeIndex = -1;
  focusItems.forEach(function (item, index) {
    if ((0, _utils2.shallowEqual)(item[valueKey], focusItemValue)) {
      activeIndex = index;
    }
  });
  return activeIndex;
};
/**
 * get current active element and node data
 * @param flattenNodes - flattenData
 */


exports.getActiveIndex = getActiveIndex;

var getActiveItem = function getActiveItem(focusItemValue, flattenNodes, valueKey) {
  var nodeData = null;
  var activeNode = Object.values(flattenNodes).find(function (node) {
    return (0, _utils2.shallowEqual)(node[valueKey], focusItemValue);
  });

  if (activeNode) {
    nodeData = activeNode;
  }

  return nodeData;
};

exports.getActiveItem = getActiveItem;

var getElementByDataKey = function getElementByDataKey(dataKey, treeNodesRefs, selector) {
  var ele = treeNodesRefs[dataKey];

  if (ele instanceof Element) {
    return ele.querySelector(selector);
  }

  return null;
};
/**
 * focus to specify tree node
 * @param refKey - target node refKey
 * @param treeNodeRefs - all tree node refs object
 * @param selector - node css selector
 */


exports.getElementByDataKey = getElementByDataKey;

var focusTreeNode = function focusTreeNode(refKey, treeNodeRefs, selector) {
  var _node$focus;

  var node = getElementByDataKey(refKey, treeNodeRefs, selector);
  node === null || node === void 0 ? void 0 : (_node$focus = node.focus) === null || _node$focus === void 0 ? void 0 : _node$focus.call(node);
};

exports.focusTreeNode = focusTreeNode;

/**
 * focus next item with keyboard
 * @param param
 */
var focusNextItem = function focusNextItem(_ref3) {
  var focusItemValue = _ref3.focusItemValue,
      focusableItems = _ref3.focusableItems,
      treeNodesRefs = _ref3.treeNodesRefs,
      selector = _ref3.selector,
      valueKey = _ref3.valueKey,
      callback = _ref3.callback;
  var activeIndex = getActiveIndex(focusItemValue, focusableItems, valueKey);

  if (focusableItems.length === 0) {
    return;
  }

  var nextIndex = activeIndex === focusableItems.length - 1 ? 0 : activeIndex + 1;
  var nextFocusItemValue = focusableItems[nextIndex][valueKey];
  callback === null || callback === void 0 ? void 0 : callback(nextFocusItemValue);
  focusTreeNode(focusableItems[nextIndex].refKey, treeNodesRefs, selector);
};
/**
 * focus prev item with keyboard
 * @param param
 */


exports.focusNextItem = focusNextItem;

var focusPreviousItem = function focusPreviousItem(_ref4) {
  var focusItemValue = _ref4.focusItemValue,
      focusableItems = _ref4.focusableItems,
      treeNodesRefs = _ref4.treeNodesRefs,
      selector = _ref4.selector,
      valueKey = _ref4.valueKey,
      callback = _ref4.callback;
  var activeIndex = getActiveIndex(focusItemValue, focusableItems, valueKey);

  if (focusableItems.length === 0) {
    return;
  }

  var prevIndex = activeIndex === 0 ? focusableItems.length - 1 : activeIndex - 1;
  prevIndex = prevIndex >= 0 ? prevIndex : 0;
  var prevFocusItemValue = focusableItems[prevIndex][valueKey];
  callback === null || callback === void 0 ? void 0 : callback(prevFocusItemValue);
  focusTreeNode(focusableItems[prevIndex].refKey, treeNodesRefs, selector);
};

exports.focusPreviousItem = focusPreviousItem;

/**
 * Left arrow keyboard event handler
 * When focus is on an open node, closes the node.
 * When focus is on a child node that is also either an end node or a closed node, moves focus to its parent node.
 * When focus is on a root node that is also either an end node or a closed node, does nothing.
 * @see https://www.w3.org/TR/wai-aria-practices/#TreeView
 */
function leftArrowHandler(_ref5) {
  var focusItem = _ref5.focusItem,
      expand = _ref5.expand,
      onExpand = _ref5.onExpand,
      onFocusItem = _ref5.onFocusItem;

  if ((0, _isEmpty2.default)(focusItem)) {
    return;
  }

  if (expand) {
    onExpand((0, _extends3.default)({}, focusItem, {
      expand: expand
    }));
  } else if (focusItem !== null && focusItem !== void 0 && focusItem.parent) {
    onFocusItem();
  }
}
/**
 * Right arrow keyboard event handler
 * When focus is on a closed node, opens the node; focus does not move.
 * When focus is on a open node, moves focus to the first child node.
 * When focus is on an end node, does nothing.
 * @see https://www.w3.org/TR/wai-aria-practices/#TreeView
 */


function rightArrowHandler(_ref6) {
  var focusItem = _ref6.focusItem,
      expand = _ref6.expand,
      childrenKey = _ref6.childrenKey,
      onExpand = _ref6.onExpand,
      onFocusItem = _ref6.onFocusItem;

  if ((0, _isEmpty2.default)(focusItem) || !Array.isArray(focusItem[childrenKey])) {
    return;
  }

  if (!expand) {
    onExpand((0, _extends3.default)({}, focusItem, {
      expand: expand
    }));
  } else {
    onFocusItem();
  }
}
/**
 * get scrollIndex in virtualized list
 * @param nodes - data
 * @param value - activeItem value
 * @param valueKey
 */


var getScrollToIndex = function getScrollToIndex(nodes, value, valueKey) {
  return nodes.filter(function (n) {
    return n.visible;
  }).findIndex(function (item) {
    return item[valueKey] === value;
  });
};
/**
 * when searching, expand state always return true
 * @param searchKeyword
 * @param expand
 */


exports.getScrollToIndex = getScrollToIndex;

function getExpandWhenSearching(searchKeyword, expand) {
  return isSearching(searchKeyword) ? true : expand;
}

function getTreeActiveNode(nodes, value, valueKey) {
  if ((0, _isUndefined2.default)(value)) {
    return undefined;
  }

  for (var refKey in nodes) {
    if ((0, _utils2.shallowEqual)(nodes[refKey][valueKey], value)) {
      return nodes[refKey];
    }
  }
}

/**
 * toggle tree node
 * @param param0
 */
function toggleExpand(_ref7) {
  var node = _ref7.node,
      isExpand = _ref7.isExpand,
      expandItemValues = _ref7.expandItemValues,
      valueKey = _ref7.valueKey;
  var newExpandItemValues = new Set(expandItemValues);

  if (isExpand) {
    newExpandItemValues.add(node[valueKey]);
  } else {
    newExpandItemValues.delete(node[valueKey]);
  }

  return Array.from(newExpandItemValues);
}

function getTreeNodeTitle(label) {
  if (typeof label === 'string') {
    return label;
  } else if ( /*#__PURE__*/_react.default.isValidElement(label)) {
    var _nodes = (0, _reactToString.default)(label);

    return _nodes.join('');
  }
}
/**
 * get all children from flattenNodes object by given parent node
 * @param nodes
 * @param parent
 */


function getChildrenByFlattenNodes(nodes, parent) {
  if (!(0, _isNil2.default)(parent.refKey) && (0, _isNil2.default)(nodes[parent.refKey])) {
    return [];
  }

  return Object.values(nodes).filter(function (item) {
    var _item$parent;

    return (item === null || item === void 0 ? void 0 : (_item$parent = item.parent) === null || _item$parent === void 0 ? void 0 : _item$parent.refKey) === parent.refKey && item.refKey && !nodes[item.refKey].uncheckable;
  });
}

function useTreeDrag() {
  // current dragging node
  var dragNode = (0, _react.useRef)(null);

  var _useState = (0, _react.useState)(null),
      dragOverNodeKey = _useState[0],
      setDragOverNodeKey = _useState[1]; // drag node and it's children nodes key


  var _useState2 = (0, _react.useState)([]),
      dragNodeKeys = _useState2[0],
      setDragNodeKeys = _useState2[1];

  var _useState3 = (0, _react.useState)(null),
      dropNodePosition = _useState3[0],
      setDropNodePosition = _useState3[1];

  var setDragNode = function setDragNode(node) {
    dragNode.current = node;
  };

  return {
    dragNode: dragNode === null || dragNode === void 0 ? void 0 : dragNode.current,
    dragOverNodeKey: dragOverNodeKey,
    dragNodeKeys: dragNodeKeys,
    dropNodePosition: dropNodePosition,
    setDragNode: setDragNode,
    setDragOverNodeKey: setDragOverNodeKey,
    setDragNodeKeys: setDragNodeKeys,
    setDropNodePosition: setDropNodePosition
  };
}

/**
 * hooks for flatten tree structure
 * @param param0
 */
function useFlattenTreeData(_ref8) {
  var data = _ref8.data,
      labelKey = _ref8.labelKey,
      valueKey = _ref8.valueKey,
      childrenKey = _ref8.childrenKey,
      _ref8$uncheckableItem = _ref8.uncheckableItemValues,
      uncheckableItemValues = _ref8$uncheckableItem === void 0 ? [] : _ref8$uncheckableItem,
      callback = _ref8.callback;

  var _useState4 = (0, _react.useState)(Object.create(null)),
      dispatch = _useState4[1];

  var forceUpdate = (0, _react.useCallback)(function () {
    dispatch(Object.create(null));
  }, [dispatch]);
  var flattenNodes = (0, _react.useRef)({});
  var flattenTreeData = (0, _react.useCallback)(function (treeData, parent, layer) {
    if (layer === void 0) {
      layer = 1;
    }

    if (!Array.isArray(treeData) || treeData.length === 0) {
      return [];
    }

    treeData.map(function (node) {
      var _extends2;

      var value = node[valueKey];
      /**
       * because the value of the node's type is string or number,
       * so it can used as the key of the object directly
       * to avoid number value is converted to string. 1 and '1' will be convert to '1'
       *  we used `String_` or `Number_` prefix
       */

      var refKey = getNodeFormattedRefKey(value);
      node.refKey = refKey;
      flattenNodes.current[refKey] = (0, _extends3.default)((_extends2 = {
        layer: layer
      }, _extends2[labelKey] = node[labelKey], _extends2[valueKey] = node[valueKey], _extends2.uncheckable = uncheckableItemValues.some(function (value) {
        return (0, _utils2.shallowEqual)(node[valueKey], value);
      }), _extends2), node);

      if (parent) {
        flattenNodes.current[refKey].parent = (0, _omit2.default)(parent, 'parent', 'children');
      }

      flattenTreeData(node[childrenKey], node, layer + 1);
    });
    callback === null || callback === void 0 ? void 0 : callback(flattenNodes.current);
  }, [childrenKey, valueKey, labelKey, callback, uncheckableItemValues]);
  var serializeListOnlyParent = (0, _react.useCallback)(function (nodes, key) {
    var list = [];
    Object.keys(nodes).forEach(function (refKey) {
      var currentNode = nodes[refKey];

      if (!(0, _isNil2.default)(currentNode.parent) && !(0, _isNil2.default)(currentNode.parent.refKey)) {
        var parentNode = nodes[currentNode.parent.refKey];

        if (currentNode[key]) {
          if (!(parentNode !== null && parentNode !== void 0 && parentNode.checkAll)) {
            list.push(nodes[refKey][valueKey]);
          } else if (parentNode !== null && parentNode !== void 0 && parentNode.uncheckable) {
            list.push(nodes[refKey][valueKey]);
          }
        }
      } else {
        if (currentNode[key]) {
          list.push(nodes[refKey][valueKey]);
        }
      }
    });
    return list;
  }, [valueKey]);
  /**
   * using in CheckTreePicker, to unSerializeList check property
   */

  var unSerializeList = (0, _react.useCallback)(function (_ref9) {
    var nodes = _ref9.nodes,
        key = _ref9.key,
        _ref9$value = _ref9.value,
        value = _ref9$value === void 0 ? [] : _ref9$value,
        cascade = _ref9.cascade,
        uncheckableItemValues = _ref9.uncheckableItemValues;
    // Reset values to false
    Object.keys(nodes).forEach(function (refKey) {
      var node = nodes[refKey];

      if (cascade && !(0, _isNil2.default)(node.parent) && !(0, _isNil2.default)(node.parent.refKey)) {
        node[key] = nodes[node.parent.refKey][key];
      } else {
        node[key] = false;
      }

      value.forEach(function (value) {
        if ((0, _utils2.shallowEqual)(nodes[refKey][valueKey], value) && !uncheckableItemValues.some(function (uncheckableValue) {
          return (0, _utils2.shallowEqual)(value, uncheckableValue);
        })) {
          nodes[refKey][key] = true;
        }
      });
    });
  }, [valueKey]);

  var formatVirtualizedTreeData = function formatVirtualizedTreeData(nodes, data, expandItemValues, options) {
    var cascade = options.cascade,
        searchKeyword = options.searchKeyword;
    return flattenTree(data, childrenKey, function (node) {
      var formatted = {};
      var curNode = nodes === null || nodes === void 0 ? void 0 : nodes[node.refKey];
      var parentKeys = getNodeParentKeys(nodes, curNode, valueKey);
      /**
       * When using virtualized,
       * if the parent node is collapsed, the child nodes should be hidden
       * avoid component height calculation errors
       */

      var visible = curNode !== null && curNode !== void 0 && curNode.parent ? shouldShowNodeByParentExpanded(expandItemValues, parentKeys) : true;
      /**
       * when searching, every node default expand
       * the node's visible should follow the original state
       */

      if (isSearching(searchKeyword)) {
        visible = node.visible;
      }

      if (curNode) {
        var checkState = !(0, _isUndefined2.default)(cascade) ? (0, _utils.getNodeCheckState)({
          node: curNode,
          cascade: cascade,
          nodes: nodes,
          childrenKey: childrenKey
        }) : undefined;
        formatted = (0, _extends3.default)({}, node, {
          check: curNode.check,
          uncheckable: curNode.uncheckable,
          hasChildren: !!node[childrenKey],
          layer: curNode.layer,
          parent: curNode.parent,
          checkState: checkState,
          visible: visible
        });
      }

      return formatted;
    });
  };

  (0, _react.useEffect)(function () {
    // when data is changed, should clear the flattenNodes, avoid duplicate keys
    flattenNodes.current = {};
    flattenTreeData(data);
  }, [data]); // eslint-disable-line react-hooks/exhaustive-deps

  return {
    forceUpdate: forceUpdate,
    flattenNodes: flattenNodes.current,
    flattenTreeData: flattenTreeData,
    serializeListOnlyParent: serializeListOnlyParent,
    unSerializeList: unSerializeList,
    formatVirtualizedTreeData: formatVirtualizedTreeData
  };
}
/**
 * A hook that saving every tree node ref
 */


function useTreeNodeRefs() {
  var treeNodeRefs = (0, _react.useRef)({});

  var saveTreeNodeRef = function saveTreeNodeRef(ref, refKey) {
    if (!(0, _isNil2.default)(refKey)) {
      treeNodeRefs.current[refKey] = ref;
    }
  };

  return {
    treeNodesRefs: treeNodeRefs.current,
    saveTreeNodeRef: saveTreeNodeRef
  };
}

/**
 * A hook that handles tree search filter options
 * @param props
 */
function useTreeSearch(props) {
  var labelKey = props.labelKey,
      childrenKey = props.childrenKey,
      searchKeyword = props.searchKeyword,
      data = props.data,
      searchBy = props.searchBy,
      callback = props.callback;
  var filterVisibleData = (0, _react.useCallback)(function (data, searchKeyword) {
    var setVisible = function setVisible(nodes) {
      return nodes.forEach(function (item) {
        item.visible = searchBy ? searchBy(searchKeyword, item[labelKey], item) : (0, _Picker.shouldDisplay)(item[labelKey], searchKeyword);

        if ((0, _isArray2.default)(item[childrenKey])) {
          filterVisibleData(item[childrenKey], searchKeyword);
          item[childrenKey].forEach(function (child) {
            if (child.visible) {
              item.visible = child.visible;
            }
          });
        }
      });
    };

    setVisible(data);
    return data;
  }, [childrenKey, labelKey, searchBy]); // Use search keywords to filter options.

  var _useState5 = (0, _react.useState)(function () {
    return searchKeyword !== null && searchKeyword !== void 0 ? searchKeyword : '';
  }),
      searchKeywordState = _useState5[0],
      setSearchKeyword = _useState5[1];

  var _useState6 = (0, _react.useState)(function () {
    return filterVisibleData(data, searchKeywordState);
  }),
      filteredData = _useState6[0],
      setFilteredData = _useState6[1];

  var handleSetFilteredData = (0, _react.useCallback)(function (data, searchKeyword) {
    setFilteredData(filterVisibleData(data, searchKeyword));
  }, [filterVisibleData]);

  var handleSearch = function handleSearch(searchKeyword, event) {
    var filteredData = filterVisibleData(data, searchKeyword);
    setFilteredData(filteredData);
    setSearchKeyword(searchKeyword);
    callback === null || callback === void 0 ? void 0 : callback(searchKeyword, filteredData, event);
  };

  return {
    searchKeywordState: searchKeywordState,
    filteredData: filteredData,
    setFilteredData: handleSetFilteredData,
    setSearchKeyword: setSearchKeyword,
    handleSearch: handleSearch
  };
}

function useGetTreeNodeChildren(treeData, valueKey, childrenKey) {
  var _useState7 = (0, _react.useState)([]),
      loadingNodeValues = _useState7[0],
      setLoadingNodeValues = _useState7[1];

  var _useState8 = (0, _react.useState)(treeData),
      data = _useState8[0],
      setData = _useState8[1];

  var concatChildren = (0, _react.useCallback)(function (treeNode, children) {
    var value = treeNode[valueKey];
    treeNode = findNodeOfTree(data, function (item) {
      return value === item[valueKey];
    });
    treeNode[childrenKey] = children;
    var newData = data.concat([]);
    setData(newData);
    return newData;
  }, [data, valueKey, childrenKey]);
  var loadChildren = (0, _react.useCallback)(function (node, getChildren) {
    setLoadingNodeValues(function (prev) {
      return prev.concat(node[valueKey]);
    });
    var children = getChildren(node);

    if (children instanceof Promise) {
      children.then(function (res) {
        var newData = concatChildren(node, res);
        setData(newData);
        setLoadingNodeValues(function (prev) {
          return prev.filter(function (item) {
            return !(0, _utils2.shallowEqual)(item, node[valueKey]);
          });
        });
      });
    } else {
      setData(concatChildren(node, children));
      setLoadingNodeValues(function (prev) {
        return prev.filter(function (item) {
          return !(0, _utils2.shallowEqual)(item, node[valueKey]);
        });
      });
    }
  }, [concatChildren, valueKey]);
  return {
    data: data,
    setData: setData,
    loadingNodeValues: loadingNodeValues,
    loadChildren: loadChildren
  };
}

/**
 * Focus to active tree node.
 * @param param0
 */
function focusToActiveTreeNode(_ref10) {
  var _activeItem$focus;

  var list = _ref10.list,
      valueKey = _ref10.valueKey,
      activeNode = _ref10.activeNode,
      virtualized = _ref10.virtualized,
      container = _ref10.container,
      selector = _ref10.selector,
      formattedNodes = _ref10.formattedNodes;
  if (!container) return;

  if (virtualized && activeNode) {
    var _list$scrollToRow;

    var scrollIndex = getScrollToIndex(formattedNodes, activeNode === null || activeNode === void 0 ? void 0 : activeNode[valueKey], valueKey);
    (_list$scrollToRow = list.scrollToRow) === null || _list$scrollToRow === void 0 ? void 0 : _list$scrollToRow.call(list, scrollIndex);
    return;
  }

  var activeItem = container.querySelector(selector);

  if (!activeItem) {
    return;
  }

  activeItem === null || activeItem === void 0 ? void 0 : (_activeItem$focus = activeItem.focus) === null || _activeItem$focus === void 0 ? void 0 : _activeItem$focus.call(activeItem);
}

function isSearching(searchKeyword) {
  return !(0, _isEmpty2.default)(searchKeyword);
}

function getTreeNodeIndent(rtl, layer, absolute) {
  var _ref12;

  if (absolute === void 0) {
    absolute = false;
  }

  // layer start from 1
  var offset = layer * _constants.TREE_NODE_PADDING + _constants.TREE_NODE_ROOT_PADDING;

  if (absolute) {
    var _ref11;

    return _ref11 = {}, _ref11[rtl ? 'right' : 'left'] = offset, _ref11;
  }

  return _ref12 = {}, _ref12[rtl ? 'paddingRight' : 'paddingLeft'] = offset, _ref12;
}
/**
 * according to the value type to get the formatted valueKey of the node
 * @param value
 * @returns
 */


function getNodeFormattedRefKey(value) {
  return "" + (typeof value === 'number' ? 'Number_' : 'String_') + value;
}