add all frontend files

node_modules/rc-tree/es/utils/conductUtil.d.ts

@@ -0,0 +1,17 @@
+import type { BasicDataNode, DataNode, GetCheckDisabled, Key, KeyEntities } from '../interface';
+interface ConductReturnType {
+    checkedKeys: Key[];
+    halfCheckedKeys: Key[];
+}
+export declare function isCheckDisabled<TreeDataType>(node: TreeDataType): boolean;
+/**
+ * Conduct with keys.
+ * @param keyList current key list
+ * @param keyEntities key - dataEntity map
+ * @param mode `fill` to fill missing key, `clean` to remove useless key
+ */
+export declare function conductCheck<TreeDataType extends BasicDataNode = DataNode>(keyList: Key[], checked: true | {
+    checked: false;
+    halfCheckedKeys: Key[];
+}, keyEntities: KeyEntities<TreeDataType>, getCheckDisabled?: GetCheckDisabled<TreeDataType>): ConductReturnType;
+export {};

node_modules/rc-tree/es/utils/conductUtil.js

@@ -0,0 +1,209 @@
+import warning from "rc-util/es/warning";
+import getEntity from "./keyUtil";
+function removeFromCheckedKeys(halfCheckedKeys, checkedKeys) {
+  var filteredKeys = new Set();
+  halfCheckedKeys.forEach(function (key) {
+    if (!checkedKeys.has(key)) {
+      filteredKeys.add(key);
+    }
+  });
+  return filteredKeys;
+}
+export function isCheckDisabled(node) {
+  var _ref = node || {},
+    disabled = _ref.disabled,
+    disableCheckbox = _ref.disableCheckbox,
+    checkable = _ref.checkable;
+  return !!(disabled || disableCheckbox) || checkable === false;
+}
+
+// Fill miss keys
+function fillConductCheck(keys, levelEntities, maxLevel, syntheticGetCheckDisabled) {
+  var checkedKeys = new Set(keys);
+  var halfCheckedKeys = new Set();
+
+  // Add checked keys top to bottom
+  for (var level = 0; level <= maxLevel; level += 1) {
+    var entities = levelEntities.get(level) || new Set();
+    entities.forEach(function (entity) {
+      var key = entity.key,
+        node = entity.node,
+        _entity$children = entity.children,
+        children = _entity$children === void 0 ? [] : _entity$children;
+      if (checkedKeys.has(key) && !syntheticGetCheckDisabled(node)) {
+        children.filter(function (childEntity) {
+          return !syntheticGetCheckDisabled(childEntity.node);
+        }).forEach(function (childEntity) {
+          checkedKeys.add(childEntity.key);
+        });
+      }
+    });
+  }
+
+  // Add checked keys from bottom to top
+  var visitedKeys = new Set();
+  for (var _level = maxLevel; _level >= 0; _level -= 1) {
+    var _entities = levelEntities.get(_level) || new Set();
+    _entities.forEach(function (entity) {
+      var parent = entity.parent,
+        node = entity.node;
+
+      // Skip if no need to check
+      if (syntheticGetCheckDisabled(node) || !entity.parent || visitedKeys.has(entity.parent.key)) {
+        return;
+      }
+
+      // Skip if parent is disabled
+      if (syntheticGetCheckDisabled(entity.parent.node)) {
+        visitedKeys.add(parent.key);
+        return;
+      }
+      var allChecked = true;
+      var partialChecked = false;
+      (parent.children || []).filter(function (childEntity) {
+        return !syntheticGetCheckDisabled(childEntity.node);
+      }).forEach(function (_ref2) {
+        var key = _ref2.key;
+        var checked = checkedKeys.has(key);
+        if (allChecked && !checked) {
+          allChecked = false;
+        }
+        if (!partialChecked && (checked || halfCheckedKeys.has(key))) {
+          partialChecked = true;
+        }
+      });
+      if (allChecked) {
+        checkedKeys.add(parent.key);
+      }
+      if (partialChecked) {
+        halfCheckedKeys.add(parent.key);
+      }
+      visitedKeys.add(parent.key);
+    });
+  }
+  return {
+    checkedKeys: Array.from(checkedKeys),
+    halfCheckedKeys: Array.from(removeFromCheckedKeys(halfCheckedKeys, checkedKeys))
+  };
+}
+
+// Remove useless key
+function cleanConductCheck(keys, halfKeys, levelEntities, maxLevel, syntheticGetCheckDisabled) {
+  var checkedKeys = new Set(keys);
+  var halfCheckedKeys = new Set(halfKeys);
+
+  // Remove checked keys from top to bottom
+  for (var level = 0; level <= maxLevel; level += 1) {
+    var entities = levelEntities.get(level) || new Set();
+    entities.forEach(function (entity) {
+      var key = entity.key,
+        node = entity.node,
+        _entity$children2 = entity.children,
+        children = _entity$children2 === void 0 ? [] : _entity$children2;
+      if (!checkedKeys.has(key) && !halfCheckedKeys.has(key) && !syntheticGetCheckDisabled(node)) {
+        children.filter(function (childEntity) {
+          return !syntheticGetCheckDisabled(childEntity.node);
+        }).forEach(function (childEntity) {
+          checkedKeys.delete(childEntity.key);
+        });
+      }
+    });
+  }
+
+  // Remove checked keys form bottom to top
+  halfCheckedKeys = new Set();
+  var visitedKeys = new Set();
+  for (var _level2 = maxLevel; _level2 >= 0; _level2 -= 1) {
+    var _entities2 = levelEntities.get(_level2) || new Set();
+    _entities2.forEach(function (entity) {
+      var parent = entity.parent,
+        node = entity.node;
+
+      // Skip if no need to check
+      if (syntheticGetCheckDisabled(node) || !entity.parent || visitedKeys.has(entity.parent.key)) {
+        return;
+      }
+
+      // Skip if parent is disabled
+      if (syntheticGetCheckDisabled(entity.parent.node)) {
+        visitedKeys.add(parent.key);
+        return;
+      }
+      var allChecked = true;
+      var partialChecked = false;
+      (parent.children || []).filter(function (childEntity) {
+        return !syntheticGetCheckDisabled(childEntity.node);
+      }).forEach(function (_ref3) {
+        var key = _ref3.key;
+        var checked = checkedKeys.has(key);
+        if (allChecked && !checked) {
+          allChecked = false;
+        }
+        if (!partialChecked && (checked || halfCheckedKeys.has(key))) {
+          partialChecked = true;
+        }
+      });
+      if (!allChecked) {
+        checkedKeys.delete(parent.key);
+      }
+      if (partialChecked) {
+        halfCheckedKeys.add(parent.key);
+      }
+      visitedKeys.add(parent.key);
+    });
+  }
+  return {
+    checkedKeys: Array.from(checkedKeys),
+    halfCheckedKeys: Array.from(removeFromCheckedKeys(halfCheckedKeys, checkedKeys))
+  };
+}
+
+/**
+ * Conduct with keys.
+ * @param keyList current key list
+ * @param keyEntities key - dataEntity map
+ * @param mode `fill` to fill missing key, `clean` to remove useless key
+ */
+export function conductCheck(keyList, checked, keyEntities, getCheckDisabled) {
+  var warningMissKeys = [];
+  var syntheticGetCheckDisabled;
+  if (getCheckDisabled) {
+    syntheticGetCheckDisabled = getCheckDisabled;
+  } else {
+    syntheticGetCheckDisabled = isCheckDisabled;
+  }
+
+  // We only handle exist keys
+  var keys = new Set(keyList.filter(function (key) {
+    var hasEntity = !!getEntity(keyEntities, key);
+    if (!hasEntity) {
+      warningMissKeys.push(key);
+    }
+    return hasEntity;
+  }));
+  var levelEntities = new Map();
+  var maxLevel = 0;
+
+  // Convert entities by level for calculation
+  Object.keys(keyEntities).forEach(function (key) {
+    var entity = keyEntities[key];
+    var level = entity.level;
+    var levelSet = levelEntities.get(level);
+    if (!levelSet) {
+      levelSet = new Set();
+      levelEntities.set(level, levelSet);
+    }
+    levelSet.add(entity);
+    maxLevel = Math.max(maxLevel, level);
+  });
+  warning(!warningMissKeys.length, "Tree missing follow keys: ".concat(warningMissKeys.slice(0, 100).map(function (key) {
+    return "'".concat(key, "'");
+  }).join(', ')));
+  var result;
+  if (checked === true) {
+    result = fillConductCheck(keys, levelEntities, maxLevel, syntheticGetCheckDisabled);
+  } else {
+    result = cleanConductCheck(keys, checked.halfCheckedKeys, levelEntities, maxLevel, syntheticGetCheckDisabled);
+  }
+  return result;
+}

node_modules/rc-tree/es/utils/diffUtil.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import type { Key, FlattenNode } from '../interface';
+export declare function findExpandedKeys(prev?: Key[], next?: Key[]): {
+    add: boolean;
+    key: import("react").Key;
+};
+export declare function getExpandRange(shorter: FlattenNode[], longer: FlattenNode[], key: Key): FlattenNode<import("../interface").DataNode>[];

node_modules/rc-tree/es/utils/diffUtil.js

@@ -0,0 +1,48 @@
+export function findExpandedKeys() {
+  var prev = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var next = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var prevLen = prev.length;
+  var nextLen = next.length;
+  if (Math.abs(prevLen - nextLen) !== 1) {
+    return {
+      add: false,
+      key: null
+    };
+  }
+  function find(shorter, longer) {
+    var cache = new Map();
+    shorter.forEach(function (key) {
+      cache.set(key, true);
+    });
+    var keys = longer.filter(function (key) {
+      return !cache.has(key);
+    });
+    return keys.length === 1 ? keys[0] : null;
+  }
+  if (prevLen < nextLen) {
+    return {
+      add: true,
+      key: find(prev, next)
+    };
+  }
+  return {
+    add: false,
+    key: find(next, prev)
+  };
+}
+export function getExpandRange(shorter, longer, key) {
+  var shorterStartIndex = shorter.findIndex(function (data) {
+    return data.key === key;
+  });
+  var shorterEndNode = shorter[shorterStartIndex + 1];
+  var longerStartIndex = longer.findIndex(function (data) {
+    return data.key === key;
+  });
+  if (shorterEndNode) {
+    var longerEndIndex = longer.findIndex(function (data) {
+      return data.key === shorterEndNode.key;
+    });
+    return longer.slice(longerStartIndex + 1, longerEndIndex);
+  }
+  return longer.slice(longerStartIndex + 1);
+}

node_modules/rc-tree/es/utils/keyUtil.d.ts

@@ -0,0 +1,2 @@
+import type { Key, KeyEntities } from '../interface';
+export default function getEntity<T = any>(keyEntities: KeyEntities<T>, key: Key): import("../interface").DataEntity<T>;

node_modules/rc-tree/es/utils/keyUtil.js

@@ -0,0 +1,3 @@
+export default function getEntity(keyEntities, key) {
+  return keyEntities[key];
+}

node_modules/rc-tree/es/utils/treeUtil.d.ts

@@ -0,0 +1,86 @@
+import * as React from 'react';
+import type { BasicDataNode, DataEntity, DataNode, EventDataNode, FieldNames, FlattenNode, GetKey, Key, KeyEntities, NodeElement, TreeNodeProps } from '../interface';
+export declare function getPosition(level: string | number, index: number): string;
+export declare function isTreeNode(node: NodeElement): boolean;
+export declare function getKey(key: Key, pos: string): React.Key;
+export declare function fillFieldNames(fieldNames?: FieldNames): Required<FieldNames>;
+/**
+ * Warning if TreeNode do not provides key
+ */
+export declare function warningWithoutKey(treeData: DataNode[], fieldNames: FieldNames): void;
+/**
+ * Convert `children` of Tree into `treeData` structure.
+ */
+export declare function convertTreeToData(rootNodes: React.ReactNode): DataNode[];
+/**
+ * Flat nest tree data into flatten list. This is used for virtual list render.
+ * @param treeNodeList Origin data node list
+ * @param expandedKeys
+ * need expanded keys, provides `true` means all expanded (used in `rc-tree-select`).
+ */
+export declare function flattenTreeData<TreeDataType extends BasicDataNode = DataNode>(treeNodeList: TreeDataType[], expandedKeys: Key[] | true, fieldNames: FieldNames): FlattenNode<TreeDataType>[];
+type ExternalGetKey = GetKey<DataNode> | string;
+interface TraverseDataNodesConfig {
+    childrenPropName?: string;
+    externalGetKey?: ExternalGetKey;
+    fieldNames?: FieldNames;
+}
+/**
+ * Traverse all the data by `treeData`.
+ * Please not use it out of the `rc-tree` since we may refactor this code.
+ */
+export declare function traverseDataNodes(dataNodes: DataNode[], callback: (data: {
+    node: DataNode;
+    index: number;
+    pos: string;
+    key: Key;
+    parentPos: string | number;
+    level: number;
+    nodes: DataNode[];
+}) => void, config?: TraverseDataNodesConfig | string): void;
+interface Wrapper {
+    posEntities: Record<string, DataEntity>;
+    keyEntities: KeyEntities;
+}
+/**
+ * Convert `treeData` into entity records.
+ */
+export declare function convertDataToEntities(dataNodes: DataNode[], { initWrapper, processEntity, onProcessFinished, externalGetKey, childrenPropName, fieldNames, }?: {
+    initWrapper?: (wrapper: Wrapper) => Wrapper;
+    processEntity?: (entity: DataEntity, wrapper: Wrapper) => void;
+    onProcessFinished?: (wrapper: Wrapper) => void;
+    externalGetKey?: ExternalGetKey;
+    childrenPropName?: string;
+    fieldNames?: FieldNames;
+}, 
+/** @deprecated Use `config.externalGetKey` instead */
+legacyExternalGetKey?: ExternalGetKey): Wrapper;
+export interface TreeNodeRequiredProps<TreeDataType extends BasicDataNode = DataNode> {
+    expandedKeys: Key[];
+    selectedKeys: Key[];
+    loadedKeys: Key[];
+    loadingKeys: Key[];
+    checkedKeys: Key[];
+    halfCheckedKeys: Key[];
+    dragOverNodeKey: Key;
+    dropPosition: number;
+    keyEntities: KeyEntities<TreeDataType>;
+}
+/**
+ * Get TreeNode props with Tree props.
+ */
+export declare function getTreeNodeProps<TreeDataType extends BasicDataNode = DataNode>(key: Key, { expandedKeys, selectedKeys, loadedKeys, loadingKeys, checkedKeys, halfCheckedKeys, dragOverNodeKey, dropPosition, keyEntities, }: TreeNodeRequiredProps<TreeDataType>): {
+    eventKey: React.Key;
+    expanded: boolean;
+    selected: boolean;
+    loaded: boolean;
+    loading: boolean;
+    checked: boolean;
+    halfChecked: boolean;
+    pos: string;
+    dragOver: boolean;
+    dragOverGapTop: boolean;
+    dragOverGapBottom: boolean;
+};
+export declare function convertNodePropsToEventData<TreeDataType extends BasicDataNode = DataNode>(props: TreeNodeProps<TreeDataType>): EventDataNode<TreeDataType>;
+export {};

node_modules/rc-tree/es/utils/treeUtil.js

@@ -0,0 +1,354 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["children"];
+import toArray from "rc-util/es/Children/toArray";
+import omit from "rc-util/es/omit";
+import warning from "rc-util/es/warning";
+import getEntity from "./keyUtil";
+export function getPosition(level, index) {
+  return "".concat(level, "-").concat(index);
+}
+export function isTreeNode(node) {
+  return node && node.type && node.type.isTreeNode;
+}
+export function getKey(key, pos) {
+  if (key !== null && key !== undefined) {
+    return key;
+  }
+  return pos;
+}
+export function fillFieldNames(fieldNames) {
+  var _ref = fieldNames || {},
+    title = _ref.title,
+    _title = _ref._title,
+    key = _ref.key,
+    children = _ref.children;
+  var mergedTitle = title || 'title';
+  return {
+    title: mergedTitle,
+    _title: _title || [mergedTitle],
+    key: key || 'key',
+    children: children || 'children'
+  };
+}
+
+/**
+ * Warning if TreeNode do not provides key
+ */
+export function warningWithoutKey(treeData, fieldNames) {
+  var keys = new Map();
+  function dig(list) {
+    var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+    (list || []).forEach(function (treeNode) {
+      var key = treeNode[fieldNames.key];
+      var children = treeNode[fieldNames.children];
+      warning(key !== null && key !== undefined, "Tree node must have a certain key: [".concat(path).concat(key, "]"));
+      var recordKey = String(key);
+      warning(!keys.has(recordKey) || key === null || key === undefined, "Same 'key' exist in the Tree: ".concat(recordKey));
+      keys.set(recordKey, true);
+      dig(children, "".concat(path).concat(recordKey, " > "));
+    });
+  }
+  dig(treeData);
+}
+
+/**
+ * Convert `children` of Tree into `treeData` structure.
+ */
+export function convertTreeToData(rootNodes) {
+  function dig(node) {
+    var treeNodes = toArray(node);
+    return treeNodes.map(function (treeNode) {
+      // Filter invalidate node
+      if (!isTreeNode(treeNode)) {
+        warning(!treeNode, 'Tree/TreeNode can only accept TreeNode as children.');
+        return null;
+      }
+      var key = treeNode.key;
+      var _treeNode$props = treeNode.props,
+        children = _treeNode$props.children,
+        rest = _objectWithoutProperties(_treeNode$props, _excluded);
+      var dataNode = _objectSpread({
+        key: key
+      }, rest);
+      var parsedChildren = dig(children);
+      if (parsedChildren.length) {
+        dataNode.children = parsedChildren;
+      }
+      return dataNode;
+    }).filter(function (dataNode) {
+      return dataNode;
+    });
+  }
+  return dig(rootNodes);
+}
+
+/**
+ * Flat nest tree data into flatten list. This is used for virtual list render.
+ * @param treeNodeList Origin data node list
+ * @param expandedKeys
+ * need expanded keys, provides `true` means all expanded (used in `rc-tree-select`).
+ */
+export function flattenTreeData(treeNodeList, expandedKeys, fieldNames) {
+  var _fillFieldNames = fillFieldNames(fieldNames),
+    fieldTitles = _fillFieldNames._title,
+    fieldKey = _fillFieldNames.key,
+    fieldChildren = _fillFieldNames.children;
+  var expandedKeySet = new Set(expandedKeys === true ? [] : expandedKeys);
+  var flattenList = [];
+  function dig(list) {
+    var parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    return list.map(function (treeNode, index) {
+      var pos = getPosition(parent ? parent.pos : '0', index);
+      var mergedKey = getKey(treeNode[fieldKey], pos);
+
+      // Pick matched title in field title list
+      var mergedTitle;
+      for (var i = 0; i < fieldTitles.length; i += 1) {
+        var fieldTitle = fieldTitles[i];
+        if (treeNode[fieldTitle] !== undefined) {
+          mergedTitle = treeNode[fieldTitle];
+          break;
+        }
+      }
+
+      // Add FlattenDataNode into list
+      // We use `Object.assign` here to save perf since babel's `objectSpread` has perf issue
+      var flattenNode = Object.assign(omit(treeNode, [].concat(_toConsumableArray(fieldTitles), [fieldKey, fieldChildren])), {
+        title: mergedTitle,
+        key: mergedKey,
+        parent: parent,
+        pos: pos,
+        children: null,
+        data: treeNode,
+        isStart: [].concat(_toConsumableArray(parent ? parent.isStart : []), [index === 0]),
+        isEnd: [].concat(_toConsumableArray(parent ? parent.isEnd : []), [index === list.length - 1])
+      });
+      flattenList.push(flattenNode);
+
+      // Loop treeNode children
+      if (expandedKeys === true || expandedKeySet.has(mergedKey)) {
+        flattenNode.children = dig(treeNode[fieldChildren] || [], flattenNode);
+      } else {
+        flattenNode.children = [];
+      }
+      return flattenNode;
+    });
+  }
+  dig(treeNodeList);
+  return flattenList;
+}
+/**
+ * Traverse all the data by `treeData`.
+ * Please not use it out of the `rc-tree` since we may refactor this code.
+ */
+export function traverseDataNodes(dataNodes, callback,
+// To avoid too many params, let use config instead of origin param
+config) {
+  var mergedConfig = {};
+  if (_typeof(config) === 'object') {
+    mergedConfig = config;
+  } else {
+    mergedConfig = {
+      externalGetKey: config
+    };
+  }
+  mergedConfig = mergedConfig || {};
+
+  // Init config
+  var _mergedConfig = mergedConfig,
+    childrenPropName = _mergedConfig.childrenPropName,
+    externalGetKey = _mergedConfig.externalGetKey,
+    fieldNames = _mergedConfig.fieldNames;
+  var _fillFieldNames2 = fillFieldNames(fieldNames),
+    fieldKey = _fillFieldNames2.key,
+    fieldChildren = _fillFieldNames2.children;
+  var mergeChildrenPropName = childrenPropName || fieldChildren;
+
+  // Get keys
+  var syntheticGetKey;
+  if (externalGetKey) {
+    if (typeof externalGetKey === 'string') {
+      syntheticGetKey = function syntheticGetKey(node) {
+        return node[externalGetKey];
+      };
+    } else if (typeof externalGetKey === 'function') {
+      syntheticGetKey = function syntheticGetKey(node) {
+        return externalGetKey(node);
+      };
+    }
+  } else {
+    syntheticGetKey = function syntheticGetKey(node, pos) {
+      return getKey(node[fieldKey], pos);
+    };
+  }
+
+  // Process
+  function processNode(node, index, parent, pathNodes) {
+    var children = node ? node[mergeChildrenPropName] : dataNodes;
+    var pos = node ? getPosition(parent.pos, index) : '0';
+    var connectNodes = node ? [].concat(_toConsumableArray(pathNodes), [node]) : [];
+
+    // Process node if is not root
+    if (node) {
+      var key = syntheticGetKey(node, pos);
+      var _data = {
+        node: node,
+        index: index,
+        pos: pos,
+        key: key,
+        parentPos: parent.node ? parent.pos : null,
+        level: parent.level + 1,
+        nodes: connectNodes
+      };
+      callback(_data);
+    }
+
+    // Process children node
+    if (children) {
+      children.forEach(function (subNode, subIndex) {
+        processNode(subNode, subIndex, {
+          node: node,
+          pos: pos,
+          level: parent ? parent.level + 1 : -1
+        }, connectNodes);
+      });
+    }
+  }
+  processNode(null);
+}
+/**
+ * Convert `treeData` into entity records.
+ */
+export function convertDataToEntities(dataNodes) {
+  var _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    initWrapper = _ref2.initWrapper,
+    processEntity = _ref2.processEntity,
+    onProcessFinished = _ref2.onProcessFinished,
+    externalGetKey = _ref2.externalGetKey,
+    childrenPropName = _ref2.childrenPropName,
+    fieldNames = _ref2.fieldNames;
+  var /** @deprecated Use `config.externalGetKey` instead */
+  legacyExternalGetKey = arguments.length > 2 ? arguments[2] : undefined;
+  // Init config
+  var mergedExternalGetKey = externalGetKey || legacyExternalGetKey;
+  var posEntities = {};
+  var keyEntities = {};
+  var wrapper = {
+    posEntities: posEntities,
+    keyEntities: keyEntities
+  };
+  if (initWrapper) {
+    wrapper = initWrapper(wrapper) || wrapper;
+  }
+  traverseDataNodes(dataNodes, function (item) {
+    var node = item.node,
+      index = item.index,
+      pos = item.pos,
+      key = item.key,
+      parentPos = item.parentPos,
+      level = item.level,
+      nodes = item.nodes;
+    var entity = {
+      node: node,
+      nodes: nodes,
+      index: index,
+      key: key,
+      pos: pos,
+      level: level
+    };
+    var mergedKey = getKey(key, pos);
+    posEntities[pos] = entity;
+    keyEntities[mergedKey] = entity;
+
+    // Fill children
+    entity.parent = posEntities[parentPos];
+    if (entity.parent) {
+      entity.parent.children = entity.parent.children || [];
+      entity.parent.children.push(entity);
+    }
+    if (processEntity) {
+      processEntity(entity, wrapper);
+    }
+  }, {
+    externalGetKey: mergedExternalGetKey,
+    childrenPropName: childrenPropName,
+    fieldNames: fieldNames
+  });
+  if (onProcessFinished) {
+    onProcessFinished(wrapper);
+  }
+  return wrapper;
+}
+/**
+ * Get TreeNode props with Tree props.
+ */
+export function getTreeNodeProps(key, _ref3) {
+  var expandedKeys = _ref3.expandedKeys,
+    selectedKeys = _ref3.selectedKeys,
+    loadedKeys = _ref3.loadedKeys,
+    loadingKeys = _ref3.loadingKeys,
+    checkedKeys = _ref3.checkedKeys,
+    halfCheckedKeys = _ref3.halfCheckedKeys,
+    dragOverNodeKey = _ref3.dragOverNodeKey,
+    dropPosition = _ref3.dropPosition,
+    keyEntities = _ref3.keyEntities;
+  var entity = getEntity(keyEntities, key);
+  var treeNodeProps = {
+    eventKey: key,
+    expanded: expandedKeys.indexOf(key) !== -1,
+    selected: selectedKeys.indexOf(key) !== -1,
+    loaded: loadedKeys.indexOf(key) !== -1,
+    loading: loadingKeys.indexOf(key) !== -1,
+    checked: checkedKeys.indexOf(key) !== -1,
+    halfChecked: halfCheckedKeys.indexOf(key) !== -1,
+    pos: String(entity ? entity.pos : ''),
+    // [Legacy] Drag props
+    // Since the interaction of drag is changed, the semantic of the props are
+    // not accuracy, I think it should be finally removed
+    dragOver: dragOverNodeKey === key && dropPosition === 0,
+    dragOverGapTop: dragOverNodeKey === key && dropPosition === -1,
+    dragOverGapBottom: dragOverNodeKey === key && dropPosition === 1
+  };
+  return treeNodeProps;
+}
+export function convertNodePropsToEventData(props) {
+  var data = props.data,
+    expanded = props.expanded,
+    selected = props.selected,
+    checked = props.checked,
+    loaded = props.loaded,
+    loading = props.loading,
+    halfChecked = props.halfChecked,
+    dragOver = props.dragOver,
+    dragOverGapTop = props.dragOverGapTop,
+    dragOverGapBottom = props.dragOverGapBottom,
+    pos = props.pos,
+    active = props.active,
+    eventKey = props.eventKey;
+  var eventData = _objectSpread(_objectSpread({}, data), {}, {
+    expanded: expanded,
+    selected: selected,
+    checked: checked,
+    loaded: loaded,
+    loading: loading,
+    halfChecked: halfChecked,
+    dragOver: dragOver,
+    dragOverGapTop: dragOverGapTop,
+    dragOverGapBottom: dragOverGapBottom,
+    pos: pos,
+    active: active,
+    key: eventKey
+  });
+  if (!('props' in eventData)) {
+    Object.defineProperty(eventData, 'props', {
+      get: function get() {
+        warning(false, 'Second param return from event is node data instead of TreeNode instance. Please read value directly instead of reading from `props`.');
+        return props;
+      }
+    });
+  }
+  return eventData;
+}