@gobolt/genesis 0.2.14 → 0.2.16

package/dist/node_modules/rc-tree/es/Tree.js

@@ -1,307 +1,948 @@
-import ge from "../../@babel/runtime/helpers/esm/extends.js";
-import ve from "../../@babel/runtime/helpers/esm/typeof.js";
-import S from "../../@babel/runtime/helpers/esm/objectSpread2.js";
-import Y from "../../@babel/runtime/helpers/esm/toConsumableArray.js";
-import he from "../../@babel/runtime/helpers/esm/classCallCheck.js";
-import Ke from "../../@babel/runtime/helpers/esm/createClass.js";
-import p from "../../@babel/runtime/helpers/esm/assertThisInitialized.js";
-import Ne from "../../@babel/runtime/helpers/esm/inherits.js";
-import ke from "../../@babel/runtime/helpers/esm/createSuper.js";
-import l from "../../@babel/runtime/helpers/esm/defineProperty.js";
-import me from "../../../_virtual/index.js";
-import M from "../../rc-util/es/KeyCode.js";
-import Ee from "../../rc-util/es/pickAttrs.js";
-import { warningOnce as F } from "../../rc-util/es/warning.js";
-import * as W from "react";
-import { TreeContext as De } from "./contextTypes.js";
-import Ce from "./DropIndicator.js";
-import xe, { MotionEntity as Pe, MOTION_KEY as _ } from "./NodeList.js";
-import Se from "./TreeNode.js";
-import { arrDel as w, getDragChildrenKeys as Te, calcDropPosition as V, arrAdd as b, posToArr as we, conductExpandParent as X, calcSelectedKeys as z, parseCheckedKeys as B } from "./util.js";
-import { conductCheck as j } from "./utils/conductUtil.js";
-import R from "./utils/keyUtil.js";
-import { fillFieldNames as J, convertNodePropsToEventData as T, getTreeNodeProps as q, flattenTreeData as H, convertTreeToData as be, convertDataToEntities as Oe, warningWithoutKey as Le } from "./utils/treeUtil.js";
-var Q = function(Z) {
-  Ne(I, Z);
-  var G = ke(I);
-  function I() {
-    var e;
-    he(this, I);
-    for (var h = arguments.length, m = new Array(h), E = 0; E < h; E++) m[E] = arguments[E];
-    return e = G.call.apply(G, [this].concat(m)), l(p(e), "destroyed", !1), l(p(e), "delayedDragEnterLogic", void 0), l(p(e), "loadingRetryTimes", {}), l(p(e), "state", { keyEntities: {}, indent: null, selectedKeys: [], checkedKeys: [], halfCheckedKeys: [], loadedKeys: [], loadingKeys: [], expandedKeys: [], draggingNodeKey: null, dragChildrenKeys: [], dropTargetKey: null, dropPosition: null, dropContainerKey: null, dropLevelOffset: null, dropTargetPos: null, dropAllowed: !0, dragOverNodeKey: null, treeData: [], flattenNodes: [], focused: !1, activeKey: null, listChanging: !1, prevProps: null, fieldNames: J() }), l(p(e), "dragStartMousePosition", null), l(p(e), "dragNodeProps", null), l(p(e), "currentMouseOverDroppableNodeKey", null), l(p(e), "listRef", W.createRef()), l(p(e), "onNodeDragStart", function(t, n) {
-      var o = e.state, a = o.expandedKeys, d = o.keyEntities, i = e.props.onDragStart, s = n.eventKey;
-      e.dragNodeProps = n, e.dragStartMousePosition = { x: t.clientX, y: t.clientY };
-      var y = w(a, s);
-      e.setState({ draggingNodeKey: s, dragChildrenKeys: Te(s, d), indent: e.listRef.current.getIndentWidth() }), e.setExpandedKeys(y), window.addEventListener("dragend", e.onWindowDragEnd), i == null || i({ event: t, node: T(n) });
-    }), l(p(e), "onNodeDragEnter", function(t, n) {
-      var o = e.state, a = o.expandedKeys, d = o.keyEntities, i = o.dragChildrenKeys, s = o.flattenNodes, y = o.indent, v = e.props, r = v.onDragEnter, c = v.onExpand, K = v.allowDrop, u = v.direction, f = n.pos, N = n.eventKey;
-      if (e.currentMouseOverDroppableNodeKey !== N && (e.currentMouseOverDroppableNodeKey = N), e.dragNodeProps) {
-        var g = V(t, e.dragNodeProps, n, y, e.dragStartMousePosition, K, s, d, a, u), k = g.dropPosition, D = g.dropLevelOffset, C = g.dropTargetKey, x = g.dropContainerKey, O = g.dropTargetPos, P = g.dropAllowed, A = g.dragOverNodeKey;
-        !i.includes(C) && P ? (e.delayedDragEnterLogic || (e.delayedDragEnterLogic = {}), Object.keys(e.delayedDragEnterLogic).forEach(function(L) {
-          clearTimeout(e.delayedDragEnterLogic[L]);
-        }), e.dragNodeProps.eventKey !== n.eventKey && (t.persist(), e.delayedDragEnterLogic[f] = window.setTimeout(function() {
-          if (e.state.draggingNodeKey !== null) {
-            var L = Y(a), U = R(d, n.eventKey);
-            U && (U.children || []).length && (L = b(a, n.eventKey)), e.props.hasOwnProperty("expandedKeys") || e.setExpandedKeys(L), c == null || c(L, { node: T(n), expanded: !0, nativeEvent: t.nativeEvent });
+import _extends from "../../@babel/runtime/helpers/esm/extends.js";
+import _typeof from "../../@babel/runtime/helpers/esm/typeof.js";
+import _objectSpread2 from "../../@babel/runtime/helpers/esm/objectSpread2.js";
+import _toConsumableArray from "../../@babel/runtime/helpers/esm/toConsumableArray.js";
+import _classCallCheck from "../../@babel/runtime/helpers/esm/classCallCheck.js";
+import _createClass from "../../@babel/runtime/helpers/esm/createClass.js";
+import _assertThisInitialized from "../../@babel/runtime/helpers/esm/assertThisInitialized.js";
+import _inherits from "../../@babel/runtime/helpers/esm/inherits.js";
+import _createSuper from "../../@babel/runtime/helpers/esm/createSuper.js";
+import _defineProperty from "../../@babel/runtime/helpers/esm/defineProperty.js";
+import classNames from "../../../_virtual/index.js";
+import KeyCode from "../../rc-util/es/KeyCode.js";
+import pickAttrs from "../../rc-util/es/pickAttrs.js";
+import { warningOnce } from "../../rc-util/es/warning.js";
+import * as React from "react";
+import { TreeContext } from "./contextTypes.js";
+import DropIndicator from "./DropIndicator.js";
+import NodeList, { MotionEntity, MOTION_KEY } from "./NodeList.js";
+import TreeNode from "./TreeNode.js";
+import { arrDel, getDragChildrenKeys, calcDropPosition, arrAdd, posToArr, conductExpandParent, calcSelectedKeys, parseCheckedKeys } from "./util.js";
+import { conductCheck } from "./utils/conductUtil.js";
+import getEntity from "./utils/keyUtil.js";
+import { fillFieldNames, convertNodePropsToEventData, getTreeNodeProps, flattenTreeData, convertTreeToData, convertDataToEntities, warningWithoutKey } from "./utils/treeUtil.js";
+var MAX_RETRY_TIMES = 10;
+var Tree = /* @__PURE__ */ function(_React$Component) {
+  _inherits(Tree2, _React$Component);
+  var _super = _createSuper(Tree2);
+  function Tree2() {
+    var _this;
+    _classCallCheck(this, Tree2);
+    for (var _len = arguments.length, _args = new Array(_len), _key = 0; _key < _len; _key++) {
+      _args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(_args));
+    _defineProperty(_assertThisInitialized(_this), "destroyed", false);
+    _defineProperty(_assertThisInitialized(_this), "delayedDragEnterLogic", void 0);
+    _defineProperty(_assertThisInitialized(_this), "loadingRetryTimes", {});
+    _defineProperty(_assertThisInitialized(_this), "state", {
+      keyEntities: {},
+      indent: null,
+      selectedKeys: [],
+      checkedKeys: [],
+      halfCheckedKeys: [],
+      loadedKeys: [],
+      loadingKeys: [],
+      expandedKeys: [],
+      draggingNodeKey: null,
+      dragChildrenKeys: [],
+      // dropTargetKey is the key of abstract-drop-node
+      // the abstract-drop-node is the real drop node when drag and drop
+      // not the DOM drag over node
+      dropTargetKey: null,
+      dropPosition: null,
+      // the drop position of abstract-drop-node, inside 0, top -1, bottom 1
+      dropContainerKey: null,
+      // the container key of abstract-drop-node if dropPosition is -1 or 1
+      dropLevelOffset: null,
+      // the drop level offset of abstract-drag-over-node
+      dropTargetPos: null,
+      // the pos of abstract-drop-node
+      dropAllowed: true,
+      // if drop to abstract-drop-node is allowed
+      // the abstract-drag-over-node
+      // if mouse is on the bottom of top dom node or no the top of the bottom dom node
+      // abstract-drag-over-node is the top node
+      dragOverNodeKey: null,
+      treeData: [],
+      flattenNodes: [],
+      focused: false,
+      activeKey: null,
+      listChanging: false,
+      prevProps: null,
+      fieldNames: fillFieldNames()
+    });
+    _defineProperty(_assertThisInitialized(_this), "dragStartMousePosition", null);
+    _defineProperty(_assertThisInitialized(_this), "dragNodeProps", null);
+    _defineProperty(_assertThisInitialized(_this), "currentMouseOverDroppableNodeKey", null);
+    _defineProperty(_assertThisInitialized(_this), "listRef", /* @__PURE__ */ React.createRef());
+    _defineProperty(_assertThisInitialized(_this), "onNodeDragStart", function(event, nodeProps) {
+      var _this$state = _this.state, expandedKeys = _this$state.expandedKeys, keyEntities = _this$state.keyEntities;
+      var onDragStart = _this.props.onDragStart;
+      var eventKey = nodeProps.eventKey;
+      _this.dragNodeProps = nodeProps;
+      _this.dragStartMousePosition = {
+        x: event.clientX,
+        y: event.clientY
+      };
+      var newExpandedKeys = arrDel(expandedKeys, eventKey);
+      _this.setState({
+        draggingNodeKey: eventKey,
+        dragChildrenKeys: getDragChildrenKeys(eventKey, keyEntities),
+        indent: _this.listRef.current.getIndentWidth()
+      });
+      _this.setExpandedKeys(newExpandedKeys);
+      window.addEventListener("dragend", _this.onWindowDragEnd);
+      onDragStart === null || onDragStart === void 0 || onDragStart({
+        event,
+        node: convertNodePropsToEventData(nodeProps)
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "onNodeDragEnter", function(event, nodeProps) {
+      var _this$state2 = _this.state, expandedKeys = _this$state2.expandedKeys, keyEntities = _this$state2.keyEntities, dragChildrenKeys = _this$state2.dragChildrenKeys, flattenNodes = _this$state2.flattenNodes, indent = _this$state2.indent;
+      var _this$props = _this.props, onDragEnter = _this$props.onDragEnter, onExpand = _this$props.onExpand, allowDrop2 = _this$props.allowDrop, direction = _this$props.direction;
+      var pos = nodeProps.pos, eventKey = nodeProps.eventKey;
+      if (_this.currentMouseOverDroppableNodeKey !== eventKey) {
+        _this.currentMouseOverDroppableNodeKey = eventKey;
+      }
+      if (!_this.dragNodeProps) {
+        _this.resetDragState();
+        return;
+      }
+      var _calcDropPosition = calcDropPosition(event, _this.dragNodeProps, nodeProps, indent, _this.dragStartMousePosition, allowDrop2, flattenNodes, keyEntities, expandedKeys, direction), dropPosition = _calcDropPosition.dropPosition, dropLevelOffset = _calcDropPosition.dropLevelOffset, dropTargetKey = _calcDropPosition.dropTargetKey, dropContainerKey = _calcDropPosition.dropContainerKey, dropTargetPos = _calcDropPosition.dropTargetPos, dropAllowed = _calcDropPosition.dropAllowed, dragOverNodeKey = _calcDropPosition.dragOverNodeKey;
+      if (
+        // don't allow drop inside its children
+        dragChildrenKeys.includes(dropTargetKey) || // don't allow drop when drop is not allowed caculated by calcDropPosition
+        !dropAllowed
+      ) {
+        _this.resetDragState();
+        return;
+      }
+      if (!_this.delayedDragEnterLogic) {
+        _this.delayedDragEnterLogic = {};
+      }
+      Object.keys(_this.delayedDragEnterLogic).forEach(function(key) {
+        clearTimeout(_this.delayedDragEnterLogic[key]);
+      });
+      if (_this.dragNodeProps.eventKey !== nodeProps.eventKey) {
+        event.persist();
+        _this.delayedDragEnterLogic[pos] = window.setTimeout(function() {
+          if (_this.state.draggingNodeKey === null) {
+            return;
+          }
+          var newExpandedKeys = _toConsumableArray(expandedKeys);
+          var entity = getEntity(keyEntities, nodeProps.eventKey);
+          if (entity && (entity.children || []).length) {
+            newExpandedKeys = arrAdd(expandedKeys, nodeProps.eventKey);
           }
-        }, 800)), e.dragNodeProps.eventKey !== C || D !== 0 ? (e.setState({ dragOverNodeKey: A, dropPosition: k, dropLevelOffset: D, dropTargetKey: C, dropContainerKey: x, dropTargetPos: O, dropAllowed: P }), r == null || r({ event: t, node: T(n), expandedKeys: a })) : e.resetDragState()) : e.resetDragState();
-      } else e.resetDragState();
-    }), l(p(e), "onNodeDragOver", function(t, n) {
-      var o = e.state, a = o.dragChildrenKeys, d = o.flattenNodes, i = o.keyEntities, s = o.expandedKeys, y = o.indent, v = e.props, r = v.onDragOver, c = v.allowDrop, K = v.direction;
-      if (e.dragNodeProps) {
-        var u = V(t, e.dragNodeProps, n, y, e.dragStartMousePosition, c, d, i, s, K), f = u.dropPosition, N = u.dropLevelOffset, g = u.dropTargetKey, k = u.dropContainerKey, D = u.dropTargetPos, C = u.dropAllowed, x = u.dragOverNodeKey;
-        !a.includes(g) && C && (e.dragNodeProps.eventKey === g && N === 0 ? e.state.dropPosition === null && e.state.dropLevelOffset === null && e.state.dropTargetKey === null && e.state.dropContainerKey === null && e.state.dropTargetPos === null && e.state.dropAllowed === !1 && e.state.dragOverNodeKey === null || e.resetDragState() : f === e.state.dropPosition && N === e.state.dropLevelOffset && g === e.state.dropTargetKey && k === e.state.dropContainerKey && D === e.state.dropTargetPos && C === e.state.dropAllowed && x === e.state.dragOverNodeKey || e.setState({ dropPosition: f, dropLevelOffset: N, dropTargetKey: g, dropContainerKey: k, dropTargetPos: D, dropAllowed: C, dragOverNodeKey: x }), r == null || r({ event: t, node: T(n) }));
-      }
-    }), l(p(e), "onNodeDragLeave", function(t, n) {
-      e.currentMouseOverDroppableNodeKey !== n.eventKey || t.currentTarget.contains(t.relatedTarget) || (e.resetDragState(), e.currentMouseOverDroppableNodeKey = null);
-      var o = e.props.onDragLeave;
-      o == null || o({ event: t, node: T(n) });
-    }), l(p(e), "onWindowDragEnd", function(t) {
-      e.onNodeDragEnd(t, null, !0), window.removeEventListener("dragend", e.onWindowDragEnd);
-    }), l(p(e), "onNodeDragEnd", function(t, n) {
-      var o = e.props.onDragEnd;
-      e.setState({ dragOverNodeKey: null }), e.cleanDragState(), o == null || o({ event: t, node: T(n) }), e.dragNodeProps = null, window.removeEventListener("dragend", e.onWindowDragEnd);
-    }), l(p(e), "onNodeDrop", function(t, n) {
-      var o, a = arguments.length > 2 && arguments[2] !== void 0 && arguments[2], d = e.state, i = d.dragChildrenKeys, s = d.dropPosition, y = d.dropTargetKey, v = d.dropTargetPos;
-      if (d.dropAllowed) {
-        var r = e.props.onDrop;
-        if (e.setState({ dragOverNodeKey: null }), e.cleanDragState(), y !== null) {
-          var c = S(S({}, q(y, e.getTreeNodeRequiredProps())), {}, { active: ((o = e.getActiveItem()) === null || o === void 0 ? void 0 : o.key) === y, data: R(e.state.keyEntities, y).node }), K = i.includes(y);
-          F(!K, "Can not drop to dragNode's children node. This is a bug of rc-tree. Please report an issue.");
-          var u = we(v), f = { event: t, node: T(c), dragNode: e.dragNodeProps ? T(e.dragNodeProps) : null, dragNodesKeys: [e.dragNodeProps.eventKey].concat(i), dropToGap: s !== 0, dropPosition: s + Number(u[u.length - 1]) };
-          a || r == null || r(f), e.dragNodeProps = null;
+          if (!_this.props.hasOwnProperty("expandedKeys")) {
+            _this.setExpandedKeys(newExpandedKeys);
+          }
+          onExpand === null || onExpand === void 0 || onExpand(newExpandedKeys, {
+            node: convertNodePropsToEventData(nodeProps),
+            expanded: true,
+            nativeEvent: event.nativeEvent
+          });
+        }, 800);
+      }
+      if (_this.dragNodeProps.eventKey === dropTargetKey && dropLevelOffset === 0) {
+        _this.resetDragState();
+        return;
+      }
+      _this.setState({
+        dragOverNodeKey,
+        dropPosition,
+        dropLevelOffset,
+        dropTargetKey,
+        dropContainerKey,
+        dropTargetPos,
+        dropAllowed
+      });
+      onDragEnter === null || onDragEnter === void 0 || onDragEnter({
+        event,
+        node: convertNodePropsToEventData(nodeProps),
+        expandedKeys
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "onNodeDragOver", function(event, nodeProps) {
+      var _this$state3 = _this.state, dragChildrenKeys = _this$state3.dragChildrenKeys, flattenNodes = _this$state3.flattenNodes, keyEntities = _this$state3.keyEntities, expandedKeys = _this$state3.expandedKeys, indent = _this$state3.indent;
+      var _this$props2 = _this.props, onDragOver = _this$props2.onDragOver, allowDrop2 = _this$props2.allowDrop, direction = _this$props2.direction;
+      if (!_this.dragNodeProps) {
+        return;
+      }
+      var _calcDropPosition2 = calcDropPosition(event, _this.dragNodeProps, nodeProps, indent, _this.dragStartMousePosition, allowDrop2, flattenNodes, keyEntities, expandedKeys, direction), dropPosition = _calcDropPosition2.dropPosition, dropLevelOffset = _calcDropPosition2.dropLevelOffset, dropTargetKey = _calcDropPosition2.dropTargetKey, dropContainerKey = _calcDropPosition2.dropContainerKey, dropTargetPos = _calcDropPosition2.dropTargetPos, dropAllowed = _calcDropPosition2.dropAllowed, dragOverNodeKey = _calcDropPosition2.dragOverNodeKey;
+      if (dragChildrenKeys.includes(dropTargetKey) || !dropAllowed) {
+        return;
+      }
+      if (_this.dragNodeProps.eventKey === dropTargetKey && dropLevelOffset === 0) {
+        if (!(_this.state.dropPosition === null && _this.state.dropLevelOffset === null && _this.state.dropTargetKey === null && _this.state.dropContainerKey === null && _this.state.dropTargetPos === null && _this.state.dropAllowed === false && _this.state.dragOverNodeKey === null)) {
+          _this.resetDragState();
         }
+      } else if (!(dropPosition === _this.state.dropPosition && dropLevelOffset === _this.state.dropLevelOffset && dropTargetKey === _this.state.dropTargetKey && dropContainerKey === _this.state.dropContainerKey && dropTargetPos === _this.state.dropTargetPos && dropAllowed === _this.state.dropAllowed && dragOverNodeKey === _this.state.dragOverNodeKey)) {
+        _this.setState({
+          dropPosition,
+          dropLevelOffset,
+          dropTargetKey,
+          dropContainerKey,
+          dropTargetPos,
+          dropAllowed,
+          dragOverNodeKey
+        });
+      }
+      onDragOver === null || onDragOver === void 0 || onDragOver({
+        event,
+        node: convertNodePropsToEventData(nodeProps)
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "onNodeDragLeave", function(event, nodeProps) {
+      if (_this.currentMouseOverDroppableNodeKey === nodeProps.eventKey && !event.currentTarget.contains(event.relatedTarget)) {
+        _this.resetDragState();
+        _this.currentMouseOverDroppableNodeKey = null;
+      }
+      var onDragLeave = _this.props.onDragLeave;
+      onDragLeave === null || onDragLeave === void 0 || onDragLeave({
+        event,
+        node: convertNodePropsToEventData(nodeProps)
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "onWindowDragEnd", function(event) {
+      _this.onNodeDragEnd(event, null, true);
+      window.removeEventListener("dragend", _this.onWindowDragEnd);
+    });
+    _defineProperty(_assertThisInitialized(_this), "onNodeDragEnd", function(event, nodeProps) {
+      var onDragEnd = _this.props.onDragEnd;
+      _this.setState({
+        dragOverNodeKey: null
+      });
+      _this.cleanDragState();
+      onDragEnd === null || onDragEnd === void 0 || onDragEnd({
+        event,
+        node: convertNodePropsToEventData(nodeProps)
+      });
+      _this.dragNodeProps = null;
+      window.removeEventListener("dragend", _this.onWindowDragEnd);
+    });
+    _defineProperty(_assertThisInitialized(_this), "onNodeDrop", function(event, _) {
+      var _this$getActiveItem;
+      var outsideTree = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+      var _this$state4 = _this.state, dragChildrenKeys = _this$state4.dragChildrenKeys, dropPosition = _this$state4.dropPosition, dropTargetKey = _this$state4.dropTargetKey, dropTargetPos = _this$state4.dropTargetPos, dropAllowed = _this$state4.dropAllowed;
+      if (!dropAllowed) {
+        return;
+      }
+      var onDrop = _this.props.onDrop;
+      _this.setState({
+        dragOverNodeKey: null
+      });
+      _this.cleanDragState();
+      if (dropTargetKey === null) return;
+      var abstractDropNodeProps = _objectSpread2(_objectSpread2({}, getTreeNodeProps(dropTargetKey, _this.getTreeNodeRequiredProps())), {}, {
+        active: ((_this$getActiveItem = _this.getActiveItem()) === null || _this$getActiveItem === void 0 ? void 0 : _this$getActiveItem.key) === dropTargetKey,
+        data: getEntity(_this.state.keyEntities, dropTargetKey).node
+      });
+      var dropToChild = dragChildrenKeys.includes(dropTargetKey);
+      warningOnce(!dropToChild, "Can not drop to dragNode's children node. This is a bug of rc-tree. Please report an issue.");
+      var posArr = posToArr(dropTargetPos);
+      var dropResult = {
+        event,
+        node: convertNodePropsToEventData(abstractDropNodeProps),
+        dragNode: _this.dragNodeProps ? convertNodePropsToEventData(_this.dragNodeProps) : null,
+        dragNodesKeys: [_this.dragNodeProps.eventKey].concat(dragChildrenKeys),
+        dropToGap: dropPosition !== 0,
+        dropPosition: dropPosition + Number(posArr[posArr.length - 1])
+      };
+      if (!outsideTree) {
+        onDrop === null || onDrop === void 0 || onDrop(dropResult);
       }
-    }), l(p(e), "cleanDragState", function() {
-      e.state.draggingNodeKey !== null && e.setState({ draggingNodeKey: null, dropPosition: null, dropContainerKey: null, dropTargetKey: null, dropLevelOffset: null, dropAllowed: !0, dragOverNodeKey: null }), e.dragStartMousePosition = null, e.currentMouseOverDroppableNodeKey = null;
-    }), l(p(e), "triggerExpandActionExpand", function(t, n) {
-      var o = e.state, a = o.expandedKeys, d = o.flattenNodes, i = n.expanded, s = n.key;
-      if (!(n.isLeaf || t.shiftKey || t.metaKey || t.ctrlKey)) {
-        var y = d.filter(function(r) {
-          return r.key === s;
-        })[0], v = T(S(S({}, q(s, e.getTreeNodeRequiredProps())), {}, { data: y.data }));
-        e.setExpandedKeys(i ? w(a, s) : b(a, s)), e.onNodeExpand(t, v);
-      }
-    }), l(p(e), "onNodeClick", function(t, n) {
-      var o = e.props, a = o.onClick;
-      o.expandAction === "click" && e.triggerExpandActionExpand(t, n), a == null || a(t, n);
-    }), l(p(e), "onNodeDoubleClick", function(t, n) {
-      var o = e.props, a = o.onDoubleClick;
-      o.expandAction === "doubleClick" && e.triggerExpandActionExpand(t, n), a == null || a(t, n);
-    }), l(p(e), "onNodeSelect", function(t, n) {
-      var o = e.state.selectedKeys, a = e.state, d = a.keyEntities, i = a.fieldNames, s = e.props, y = s.onSelect, v = s.multiple, r = n.selected, c = n[i.key], K = !r, u = (o = K ? v ? b(o, c) : [c] : w(o, c)).map(function(f) {
-        var N = R(d, f);
-        return N ? N.node : null;
+      _this.dragNodeProps = null;
+    });
+    _defineProperty(_assertThisInitialized(_this), "cleanDragState", function() {
+      var draggingNodeKey = _this.state.draggingNodeKey;
+      if (draggingNodeKey !== null) {
+        _this.setState({
+          draggingNodeKey: null,
+          dropPosition: null,
+          dropContainerKey: null,
+          dropTargetKey: null,
+          dropLevelOffset: null,
+          dropAllowed: true,
+          dragOverNodeKey: null
+        });
+      }
+      _this.dragStartMousePosition = null;
+      _this.currentMouseOverDroppableNodeKey = null;
+    });
+    _defineProperty(_assertThisInitialized(_this), "triggerExpandActionExpand", function(e, treeNode) {
+      var _this$state5 = _this.state, expandedKeys = _this$state5.expandedKeys, flattenNodes = _this$state5.flattenNodes;
+      var expanded = treeNode.expanded, key = treeNode.key, isLeaf = treeNode.isLeaf;
+      if (isLeaf || e.shiftKey || e.metaKey || e.ctrlKey) {
+        return;
+      }
+      var node = flattenNodes.filter(function(nodeItem) {
+        return nodeItem.key === key;
+      })[0];
+      var eventNode = convertNodePropsToEventData(_objectSpread2(_objectSpread2({}, getTreeNodeProps(key, _this.getTreeNodeRequiredProps())), {}, {
+        data: node.data
+      }));
+      _this.setExpandedKeys(expanded ? arrDel(expandedKeys, key) : arrAdd(expandedKeys, key));
+      _this.onNodeExpand(e, eventNode);
+    });
+    _defineProperty(_assertThisInitialized(_this), "onNodeClick", function(e, treeNode) {
+      var _this$props3 = _this.props, onClick = _this$props3.onClick, expandAction = _this$props3.expandAction;
+      if (expandAction === "click") {
+        _this.triggerExpandActionExpand(e, treeNode);
+      }
+      onClick === null || onClick === void 0 || onClick(e, treeNode);
+    });
+    _defineProperty(_assertThisInitialized(_this), "onNodeDoubleClick", function(e, treeNode) {
+      var _this$props4 = _this.props, onDoubleClick = _this$props4.onDoubleClick, expandAction = _this$props4.expandAction;
+      if (expandAction === "doubleClick") {
+        _this.triggerExpandActionExpand(e, treeNode);
+      }
+      onDoubleClick === null || onDoubleClick === void 0 || onDoubleClick(e, treeNode);
+    });
+    _defineProperty(_assertThisInitialized(_this), "onNodeSelect", function(e, treeNode) {
+      var selectedKeys = _this.state.selectedKeys;
+      var _this$state6 = _this.state, keyEntities = _this$state6.keyEntities, fieldNames = _this$state6.fieldNames;
+      var _this$props5 = _this.props, onSelect = _this$props5.onSelect, multiple = _this$props5.multiple;
+      var selected = treeNode.selected;
+      var key = treeNode[fieldNames.key];
+      var targetSelected = !selected;
+      if (!targetSelected) {
+        selectedKeys = arrDel(selectedKeys, key);
+      } else if (!multiple) {
+        selectedKeys = [key];
+      } else {
+        selectedKeys = arrAdd(selectedKeys, key);
+      }
+      var selectedNodes = selectedKeys.map(function(selectedKey) {
+        var entity = getEntity(keyEntities, selectedKey);
+        return entity ? entity.node : null;
       }).filter(Boolean);
-      e.setUncontrolledState({ selectedKeys: o }), y == null || y(o, { event: "select", selected: K, node: n, selectedNodes: u, nativeEvent: t.nativeEvent });
-    }), l(p(e), "onNodeCheck", function(t, n, o) {
-      var a, d = e.state, i = d.keyEntities, s = d.checkedKeys, y = d.halfCheckedKeys, v = e.props, r = v.checkStrictly, c = v.onCheck, K = n.key, u = { event: "check", node: n, checked: o, nativeEvent: t.nativeEvent };
-      if (r) {
-        var f = o ? b(s, K) : w(s, K);
-        a = { checked: f, halfChecked: w(y, K) }, u.checkedNodes = f.map(function(x) {
-          return R(i, x);
-        }).filter(Boolean).map(function(x) {
-          return x.node;
-        }), e.setUncontrolledState({ checkedKeys: f });
+      _this.setUncontrolledState({
+        selectedKeys
+      });
+      onSelect === null || onSelect === void 0 || onSelect(selectedKeys, {
+        event: "select",
+        selected: targetSelected,
+        node: treeNode,
+        selectedNodes,
+        nativeEvent: e.nativeEvent
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "onNodeCheck", function(e, treeNode, checked) {
+      var _this$state7 = _this.state, keyEntities = _this$state7.keyEntities, oriCheckedKeys = _this$state7.checkedKeys, oriHalfCheckedKeys = _this$state7.halfCheckedKeys;
+      var _this$props6 = _this.props, checkStrictly = _this$props6.checkStrictly, onCheck = _this$props6.onCheck;
+      var key = treeNode.key;
+      var checkedObj;
+      var eventObj = {
+        event: "check",
+        node: treeNode,
+        checked,
+        nativeEvent: e.nativeEvent
+      };
+      if (checkStrictly) {
+        var checkedKeys = checked ? arrAdd(oriCheckedKeys, key) : arrDel(oriCheckedKeys, key);
+        var halfCheckedKeys = arrDel(oriHalfCheckedKeys, key);
+        checkedObj = {
+          checked: checkedKeys,
+          halfChecked: halfCheckedKeys
+        };
+        eventObj.checkedNodes = checkedKeys.map(function(checkedKey) {
+          return getEntity(keyEntities, checkedKey);
+        }).filter(Boolean).map(function(entity) {
+          return entity.node;
+        });
+        _this.setUncontrolledState({
+          checkedKeys
+        });
       } else {
-        var N = j([].concat(Y(s), [K]), !0, i), g = N.checkedKeys, k = N.halfCheckedKeys;
-        if (!o) {
-          var D = new Set(g);
-          D.delete(K);
-          var C = j(Array.from(D), { halfCheckedKeys: k }, i);
-          g = C.checkedKeys, k = C.halfCheckedKeys;
+        var _conductCheck = conductCheck([].concat(_toConsumableArray(oriCheckedKeys), [key]), true, keyEntities), _checkedKeys = _conductCheck.checkedKeys, _halfCheckedKeys = _conductCheck.halfCheckedKeys;
+        if (!checked) {
+          var keySet = new Set(_checkedKeys);
+          keySet.delete(key);
+          var _conductCheck2 = conductCheck(Array.from(keySet), {
+            halfCheckedKeys: _halfCheckedKeys
+          }, keyEntities);
+          _checkedKeys = _conductCheck2.checkedKeys;
+          _halfCheckedKeys = _conductCheck2.halfCheckedKeys;
         }
-        a = g, u.checkedNodes = [], u.checkedNodesPositions = [], u.halfCheckedKeys = k, g.forEach(function(x) {
-          var O = R(i, x);
-          if (O) {
-            var P = O.node, A = O.pos;
-            u.checkedNodes.push(P), u.checkedNodesPositions.push({ node: P, pos: A });
+        checkedObj = _checkedKeys;
+        eventObj.checkedNodes = [];
+        eventObj.checkedNodesPositions = [];
+        eventObj.halfCheckedKeys = _halfCheckedKeys;
+        _checkedKeys.forEach(function(checkedKey) {
+          var entity = getEntity(keyEntities, checkedKey);
+          if (!entity) return;
+          var node = entity.node, pos = entity.pos;
+          eventObj.checkedNodes.push(node);
+          eventObj.checkedNodesPositions.push({
+            node,
+            pos
+          });
+        });
+        _this.setUncontrolledState({
+          checkedKeys: _checkedKeys
+        }, false, {
+          halfCheckedKeys: _halfCheckedKeys
+        });
+      }
+      onCheck === null || onCheck === void 0 || onCheck(checkedObj, eventObj);
+    });
+    _defineProperty(_assertThisInitialized(_this), "onNodeLoad", function(treeNode) {
+      var _entity$children;
+      var key = treeNode.key;
+      var keyEntities = _this.state.keyEntities;
+      var entity = getEntity(keyEntities, key);
+      if (entity !== null && entity !== void 0 && (_entity$children = entity.children) !== null && _entity$children !== void 0 && _entity$children.length) {
+        return;
+      }
+      var loadPromise = new Promise(function(resolve, reject) {
+        _this.setState(function(_ref) {
+          var _ref$loadedKeys = _ref.loadedKeys, loadedKeys = _ref$loadedKeys === void 0 ? [] : _ref$loadedKeys, _ref$loadingKeys = _ref.loadingKeys, loadingKeys = _ref$loadingKeys === void 0 ? [] : _ref$loadingKeys;
+          var _this$props7 = _this.props, loadData = _this$props7.loadData, onLoad = _this$props7.onLoad;
+          if (!loadData || loadedKeys.includes(key) || loadingKeys.includes(key)) {
+            return null;
           }
-        }), e.setUncontrolledState({ checkedKeys: g }, !1, { halfCheckedKeys: k });
-      }
-      c == null || c(a, u);
-    }), l(p(e), "onNodeLoad", function(t) {
-      var n, o = t.key, a = e.state.keyEntities, d = R(a, o);
-      if (d == null || (n = d.children) === null || n === void 0 || !n.length) {
-        var i = new Promise(function(s, y) {
-          e.setState(function(v) {
-            var r = v.loadedKeys, c = r === void 0 ? [] : r, K = v.loadingKeys, u = K === void 0 ? [] : K, f = e.props, N = f.loadData, g = f.onLoad;
-            return !N || c.includes(o) || u.includes(o) ? null : (N(t).then(function() {
-              var k = e.state.loadedKeys, D = b(k, o);
-              g == null || g(D, { event: "load", node: t }), e.setUncontrolledState({ loadedKeys: D }), e.setState(function(C) {
-                return { loadingKeys: w(C.loadingKeys, o) };
-              }), s();
-            }).catch(function(k) {
-              if (e.setState(function(C) {
-                return { loadingKeys: w(C.loadingKeys, o) };
-              }), e.loadingRetryTimes[o] = (e.loadingRetryTimes[o] || 0) + 1, e.loadingRetryTimes[o] >= 10) {
-                var D = e.state.loadedKeys;
-                F(!1, "Retry for `loadData` many times but still failed. No more retry."), e.setUncontrolledState({ loadedKeys: b(D, o) }), s();
-              }
-              y(k);
-            }), { loadingKeys: b(u, o) });
+          var promise = loadData(treeNode);
+          promise.then(function() {
+            var currentLoadedKeys = _this.state.loadedKeys;
+            var newLoadedKeys = arrAdd(currentLoadedKeys, key);
+            onLoad === null || onLoad === void 0 || onLoad(newLoadedKeys, {
+              event: "load",
+              node: treeNode
+            });
+            _this.setUncontrolledState({
+              loadedKeys: newLoadedKeys
+            });
+            _this.setState(function(prevState) {
+              return {
+                loadingKeys: arrDel(prevState.loadingKeys, key)
+              };
+            });
+            resolve();
+          }).catch(function(e) {
+            _this.setState(function(prevState) {
+              return {
+                loadingKeys: arrDel(prevState.loadingKeys, key)
+              };
+            });
+            _this.loadingRetryTimes[key] = (_this.loadingRetryTimes[key] || 0) + 1;
+            if (_this.loadingRetryTimes[key] >= MAX_RETRY_TIMES) {
+              var currentLoadedKeys = _this.state.loadedKeys;
+              warningOnce(false, "Retry for `loadData` many times but still failed. No more retry.");
+              _this.setUncontrolledState({
+                loadedKeys: arrAdd(currentLoadedKeys, key)
+              });
+              resolve();
+            }
+            reject(e);
           });
+          return {
+            loadingKeys: arrAdd(loadingKeys, key)
+          };
         });
-        return i.catch(function() {
-        }), i;
-      }
-    }), l(p(e), "onNodeMouseEnter", function(t, n) {
-      var o = e.props.onMouseEnter;
-      o == null || o({ event: t, node: n });
-    }), l(p(e), "onNodeMouseLeave", function(t, n) {
-      var o = e.props.onMouseLeave;
-      o == null || o({ event: t, node: n });
-    }), l(p(e), "onNodeContextMenu", function(t, n) {
-      var o = e.props.onRightClick;
-      o && (t.preventDefault(), o({ event: t, node: n }));
-    }), l(p(e), "onFocus", function() {
-      var t = e.props.onFocus;
-      e.setState({ focused: !0 });
-      for (var n = arguments.length, o = new Array(n), a = 0; a < n; a++) o[a] = arguments[a];
-      t == null || t.apply(void 0, o);
-    }), l(p(e), "onBlur", function() {
-      var t = e.props.onBlur;
-      e.setState({ focused: !1 }), e.onActiveChange(null);
-      for (var n = arguments.length, o = new Array(n), a = 0; a < n; a++) o[a] = arguments[a];
-      t == null || t.apply(void 0, o);
-    }), l(p(e), "getTreeNodeRequiredProps", function() {
-      var t = e.state;
-      return { expandedKeys: t.expandedKeys || [], selectedKeys: t.selectedKeys || [], loadedKeys: t.loadedKeys || [], loadingKeys: t.loadingKeys || [], checkedKeys: t.checkedKeys || [], halfCheckedKeys: t.halfCheckedKeys || [], dragOverNodeKey: t.dragOverNodeKey, dropPosition: t.dropPosition, keyEntities: t.keyEntities };
-    }), l(p(e), "setExpandedKeys", function(t) {
-      var n = e.state, o = n.treeData, a = n.fieldNames, d = H(o, t, a);
-      e.setUncontrolledState({ expandedKeys: t, flattenNodes: d }, !0);
-    }), l(p(e), "onNodeExpand", function(t, n) {
-      var o = e.state.expandedKeys, a = e.state, d = a.listChanging, i = a.fieldNames, s = e.props, y = s.onExpand, v = s.loadData, r = n.expanded, c = n[i.key];
-      if (!d) {
-        var K = o.includes(c), u = !r;
-        if (F(r && K || !r && !K, "Expand state not sync with index check"), o = u ? b(o, c) : w(o, c), e.setExpandedKeys(o), y == null || y(o, { node: n, expanded: u, nativeEvent: t.nativeEvent }), u && v) {
-          var f = e.onNodeLoad(n);
-          f && f.then(function() {
-            var N = H(e.state.treeData, o, i);
-            e.setUncontrolledState({ flattenNodes: N });
+      });
+      loadPromise.catch(function() {
+      });
+      return loadPromise;
+    });
+    _defineProperty(_assertThisInitialized(_this), "onNodeMouseEnter", function(event, node) {
+      var onMouseEnter = _this.props.onMouseEnter;
+      onMouseEnter === null || onMouseEnter === void 0 || onMouseEnter({
+        event,
+        node
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "onNodeMouseLeave", function(event, node) {
+      var onMouseLeave = _this.props.onMouseLeave;
+      onMouseLeave === null || onMouseLeave === void 0 || onMouseLeave({
+        event,
+        node
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "onNodeContextMenu", function(event, node) {
+      var onRightClick = _this.props.onRightClick;
+      if (onRightClick) {
+        event.preventDefault();
+        onRightClick({
+          event,
+          node
+        });
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "onFocus", function() {
+      var onFocus = _this.props.onFocus;
+      _this.setState({
+        focused: true
+      });
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      onFocus === null || onFocus === void 0 || onFocus.apply(void 0, args);
+    });
+    _defineProperty(_assertThisInitialized(_this), "onBlur", function() {
+      var onBlur = _this.props.onBlur;
+      _this.setState({
+        focused: false
+      });
+      _this.onActiveChange(null);
+      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+        args[_key3] = arguments[_key3];
+      }
+      onBlur === null || onBlur === void 0 || onBlur.apply(void 0, args);
+    });
+    _defineProperty(_assertThisInitialized(_this), "getTreeNodeRequiredProps", function() {
+      var _this$state8 = _this.state, expandedKeys = _this$state8.expandedKeys, selectedKeys = _this$state8.selectedKeys, loadedKeys = _this$state8.loadedKeys, loadingKeys = _this$state8.loadingKeys, checkedKeys = _this$state8.checkedKeys, halfCheckedKeys = _this$state8.halfCheckedKeys, dragOverNodeKey = _this$state8.dragOverNodeKey, dropPosition = _this$state8.dropPosition, keyEntities = _this$state8.keyEntities;
+      return {
+        expandedKeys: expandedKeys || [],
+        selectedKeys: selectedKeys || [],
+        loadedKeys: loadedKeys || [],
+        loadingKeys: loadingKeys || [],
+        checkedKeys: checkedKeys || [],
+        halfCheckedKeys: halfCheckedKeys || [],
+        dragOverNodeKey,
+        dropPosition,
+        keyEntities
+      };
+    });
+    _defineProperty(_assertThisInitialized(_this), "setExpandedKeys", function(expandedKeys) {
+      var _this$state9 = _this.state, treeData = _this$state9.treeData, fieldNames = _this$state9.fieldNames;
+      var flattenNodes = flattenTreeData(treeData, expandedKeys, fieldNames);
+      _this.setUncontrolledState({
+        expandedKeys,
+        flattenNodes
+      }, true);
+    });
+    _defineProperty(_assertThisInitialized(_this), "onNodeExpand", function(e, treeNode) {
+      var expandedKeys = _this.state.expandedKeys;
+      var _this$state10 = _this.state, listChanging = _this$state10.listChanging, fieldNames = _this$state10.fieldNames;
+      var _this$props8 = _this.props, onExpand = _this$props8.onExpand, loadData = _this$props8.loadData;
+      var expanded = treeNode.expanded;
+      var key = treeNode[fieldNames.key];
+      if (listChanging) {
+        return;
+      }
+      var certain = expandedKeys.includes(key);
+      var targetExpanded = !expanded;
+      warningOnce(expanded && certain || !expanded && !certain, "Expand state not sync with index check");
+      expandedKeys = targetExpanded ? arrAdd(expandedKeys, key) : arrDel(expandedKeys, key);
+      _this.setExpandedKeys(expandedKeys);
+      onExpand === null || onExpand === void 0 || onExpand(expandedKeys, {
+        node: treeNode,
+        expanded: targetExpanded,
+        nativeEvent: e.nativeEvent
+      });
+      if (targetExpanded && loadData) {
+        var loadPromise = _this.onNodeLoad(treeNode);
+        if (loadPromise) {
+          loadPromise.then(function() {
+            var newFlattenTreeData = flattenTreeData(_this.state.treeData, expandedKeys, fieldNames);
+            _this.setUncontrolledState({
+              flattenNodes: newFlattenTreeData
+            });
           }).catch(function() {
-            var N = e.state.expandedKeys, g = w(N, c);
-            e.setExpandedKeys(g);
+            var currentExpandedKeys = _this.state.expandedKeys;
+            var expandedKeysToRestore = arrDel(currentExpandedKeys, key);
+            _this.setExpandedKeys(expandedKeysToRestore);
           });
         }
       }
-    }), l(p(e), "onListChangeStart", function() {
-      e.setUncontrolledState({ listChanging: !0 });
-    }), l(p(e), "onListChangeEnd", function() {
+    });
+    _defineProperty(_assertThisInitialized(_this), "onListChangeStart", function() {
+      _this.setUncontrolledState({
+        listChanging: true
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "onListChangeEnd", function() {
       setTimeout(function() {
-        e.setUncontrolledState({ listChanging: !1 });
+        _this.setUncontrolledState({
+          listChanging: false
+        });
       });
-    }), l(p(e), "onActiveChange", function(t) {
-      var n = e.state.activeKey, o = e.props, a = o.onActiveChange, d = o.itemScrollOffset, i = d === void 0 ? 0 : d;
-      n !== t && (e.setState({ activeKey: t }), t !== null && e.scrollTo({ key: t, offset: i }), a == null || a(t));
-    }), l(p(e), "getActiveItem", function() {
-      var t = e.state, n = t.activeKey, o = t.flattenNodes;
-      return n === null ? null : o.find(function(a) {
-        return a.key === n;
+    });
+    _defineProperty(_assertThisInitialized(_this), "onActiveChange", function(newActiveKey) {
+      var activeKey = _this.state.activeKey;
+      var _this$props9 = _this.props, onActiveChange = _this$props9.onActiveChange, _this$props9$itemScro = _this$props9.itemScrollOffset, itemScrollOffset = _this$props9$itemScro === void 0 ? 0 : _this$props9$itemScro;
+      if (activeKey === newActiveKey) {
+        return;
+      }
+      _this.setState({
+        activeKey: newActiveKey
+      });
+      if (newActiveKey !== null) {
+        _this.scrollTo({
+          key: newActiveKey,
+          offset: itemScrollOffset
+        });
+      }
+      onActiveChange === null || onActiveChange === void 0 || onActiveChange(newActiveKey);
+    });
+    _defineProperty(_assertThisInitialized(_this), "getActiveItem", function() {
+      var _this$state11 = _this.state, activeKey = _this$state11.activeKey, flattenNodes = _this$state11.flattenNodes;
+      if (activeKey === null) {
+        return null;
+      }
+      return flattenNodes.find(function(_ref2) {
+        var key = _ref2.key;
+        return key === activeKey;
       }) || null;
-    }), l(p(e), "offsetActiveKey", function(t) {
-      var n = e.state, o = n.flattenNodes, a = n.activeKey, d = o.findIndex(function(y) {
-        return y.key === a;
+    });
+    _defineProperty(_assertThisInitialized(_this), "offsetActiveKey", function(offset) {
+      var _this$state12 = _this.state, flattenNodes = _this$state12.flattenNodes, activeKey = _this$state12.activeKey;
+      var index = flattenNodes.findIndex(function(_ref3) {
+        var key = _ref3.key;
+        return key === activeKey;
       });
-      d === -1 && t < 0 && (d = o.length);
-      var i = o[d = (d + t + o.length) % o.length];
-      if (i) {
-        var s = i.key;
-        e.onActiveChange(s);
-      } else e.onActiveChange(null);
-    }), l(p(e), "onKeyDown", function(t) {
-      var n = e.state, o = n.activeKey, a = n.expandedKeys, d = n.checkedKeys, i = n.fieldNames, s = e.props, y = s.onKeyDown, v = s.checkable, r = s.selectable;
-      switch (t.which) {
-        case M.UP:
-          e.offsetActiveKey(-1), t.preventDefault();
+      if (index === -1 && offset < 0) {
+        index = flattenNodes.length;
+      }
+      index = (index + offset + flattenNodes.length) % flattenNodes.length;
+      var item = flattenNodes[index];
+      if (item) {
+        var _key4 = item.key;
+        _this.onActiveChange(_key4);
+      } else {
+        _this.onActiveChange(null);
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "onKeyDown", function(event) {
+      var _this$state13 = _this.state, activeKey = _this$state13.activeKey, expandedKeys = _this$state13.expandedKeys, checkedKeys = _this$state13.checkedKeys, fieldNames = _this$state13.fieldNames;
+      var _this$props10 = _this.props, onKeyDown = _this$props10.onKeyDown, checkable = _this$props10.checkable, selectable = _this$props10.selectable;
+      switch (event.which) {
+        case KeyCode.UP: {
+          _this.offsetActiveKey(-1);
+          event.preventDefault();
+          break;
+        }
+        case KeyCode.DOWN: {
+          _this.offsetActiveKey(1);
+          event.preventDefault();
           break;
-        case M.DOWN:
-          e.offsetActiveKey(1), t.preventDefault();
-      }
-      var c = e.getActiveItem();
-      if (c && c.data) {
-        var K = e.getTreeNodeRequiredProps(), u = c.data.isLeaf === !1 || !!(c.data[i.children] || []).length, f = T(S(S({}, q(o, K)), {}, { data: c.data, active: !0 }));
-        switch (t.which) {
-          case M.LEFT:
-            u && a.includes(o) ? e.onNodeExpand({}, f) : c.parent && e.onActiveChange(c.parent.key), t.preventDefault();
+        }
+      }
+      var activeItem = _this.getActiveItem();
+      if (activeItem && activeItem.data) {
+        var treeNodeRequiredProps = _this.getTreeNodeRequiredProps();
+        var expandable = activeItem.data.isLeaf === false || !!(activeItem.data[fieldNames.children] || []).length;
+        var eventNode = convertNodePropsToEventData(_objectSpread2(_objectSpread2({}, getTreeNodeProps(activeKey, treeNodeRequiredProps)), {}, {
+          data: activeItem.data,
+          active: true
+        }));
+        switch (event.which) {
+          // >>> Expand
+          case KeyCode.LEFT: {
+            if (expandable && expandedKeys.includes(activeKey)) {
+              _this.onNodeExpand({}, eventNode);
+            } else if (activeItem.parent) {
+              _this.onActiveChange(activeItem.parent.key);
+            }
+            event.preventDefault();
             break;
-          case M.RIGHT:
-            u && !a.includes(o) ? e.onNodeExpand({}, f) : c.children && c.children.length && e.onActiveChange(c.children[0].key), t.preventDefault();
+          }
+          case KeyCode.RIGHT: {
+            if (expandable && !expandedKeys.includes(activeKey)) {
+              _this.onNodeExpand({}, eventNode);
+            } else if (activeItem.children && activeItem.children.length) {
+              _this.onActiveChange(activeItem.children[0].key);
+            }
+            event.preventDefault();
             break;
-          case M.ENTER:
-          case M.SPACE:
-            !v || f.disabled || f.checkable === !1 || f.disableCheckbox ? v || !r || f.disabled || f.selectable === !1 || e.onNodeSelect({}, f) : e.onNodeCheck({}, f, !d.includes(o));
+          }
+          // Selection
+          case KeyCode.ENTER:
+          case KeyCode.SPACE: {
+            if (checkable && !eventNode.disabled && eventNode.checkable !== false && !eventNode.disableCheckbox) {
+              _this.onNodeCheck({}, eventNode, !checkedKeys.includes(activeKey));
+            } else if (!checkable && selectable && !eventNode.disabled && eventNode.selectable !== false) {
+              _this.onNodeSelect({}, eventNode);
+            }
+            break;
+          }
         }
       }
-      y == null || y(t);
-    }), l(p(e), "setUncontrolledState", function(t) {
-      var n = arguments.length > 1 && arguments[1] !== void 0 && arguments[1], o = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : null;
-      if (!e.destroyed) {
-        var a = !1, d = !0, i = {};
-        Object.keys(t).forEach(function(s) {
-          e.props.hasOwnProperty(s) ? d = !1 : (a = !0, i[s] = t[s]);
-        }), !a || n && !d || e.setState(S(S({}, i), o));
-      }
-    }), l(p(e), "scrollTo", function(t) {
-      e.listRef.current.scrollTo(t);
-    }), e;
+      onKeyDown === null || onKeyDown === void 0 || onKeyDown(event);
+    });
+    _defineProperty(_assertThisInitialized(_this), "setUncontrolledState", function(state) {
+      var atomic = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+      var forceState = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : null;
+      if (!_this.destroyed) {
+        var needSync = false;
+        var allPassed = true;
+        var newState = {};
+        Object.keys(state).forEach(function(name) {
+          if (_this.props.hasOwnProperty(name)) {
+            allPassed = false;
+            return;
+          }
+          needSync = true;
+          newState[name] = state[name];
+        });
+        if (needSync && (!atomic || allPassed)) {
+          _this.setState(_objectSpread2(_objectSpread2({}, newState), forceState));
+        }
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "scrollTo", function(scroll) {
+      _this.listRef.current.scrollTo(scroll);
+    });
+    return _this;
   }
-  return Ke(I, [{ key: "componentDidMount", value: function() {
-    this.destroyed = !1, this.onUpdated();
-  } }, { key: "componentDidUpdate", value: function() {
-    this.onUpdated();
-  } }, { key: "onUpdated", value: function() {
-    var e = this.props, h = e.activeKey, m = e.itemScrollOffset, E = m === void 0 ? 0 : m;
-    h !== void 0 && h !== this.state.activeKey && (this.setState({ activeKey: h }), h !== null && this.scrollTo({ key: h, offset: E }));
-  } }, { key: "componentWillUnmount", value: function() {
-    window.removeEventListener("dragend", this.onWindowDragEnd), this.destroyed = !0;
-  } }, { key: "resetDragState", value: function() {
-    this.setState({ dragOverNodeKey: null, dropPosition: null, dropLevelOffset: null, dropTargetKey: null, dropContainerKey: null, dropTargetPos: null, dropAllowed: !1 });
-  } }, { key: "render", value: function() {
-    var e, h = this.state, m = h.focused, E = h.flattenNodes, t = h.keyEntities, n = h.draggingNodeKey, o = h.activeKey, a = h.dropLevelOffset, d = h.dropContainerKey, i = h.dropTargetKey, s = h.dropPosition, y = h.dragOverNodeKey, v = h.indent, r = this.props, c = r.prefixCls, K = r.className, u = r.style, f = r.showLine, N = r.focusable, g = r.tabIndex, k = g === void 0 ? 0 : g, D = r.selectable, C = r.showIcon, x = r.icon, O = r.switcherIcon, P = r.draggable, A = r.checkable, L = r.checkStrictly, U = r.disabled, $ = r.motion, ee = r.loadData, te = r.filterTreeNode, oe = r.height, ne = r.itemHeight, ae = r.scrollWidth, re = r.virtual, de = r.titleRender, se = r.dropIndicatorRender, le = r.onContextMenu, ie = r.onScroll, ce = r.direction, pe = r.rootClassName, ue = r.rootStyle, ye = Ee(this.props, { aria: !0, data: !0 });
-    P && (e = ve(P) === "object" ? P : typeof P == "function" ? { nodeDraggable: P } : {});
-    var fe = { prefixCls: c, selectable: D, showIcon: C, icon: x, switcherIcon: O, draggable: e, draggingNodeKey: n, checkable: A, checkStrictly: L, disabled: U, keyEntities: t, dropLevelOffset: a, dropContainerKey: d, dropTargetKey: i, dropPosition: s, dragOverNodeKey: y, indent: v, direction: ce, dropIndicatorRender: se, loadData: ee, filterTreeNode: te, titleRender: de, onNodeClick: this.onNodeClick, onNodeDoubleClick: this.onNodeDoubleClick, onNodeExpand: this.onNodeExpand, onNodeSelect: this.onNodeSelect, onNodeCheck: this.onNodeCheck, onNodeLoad: this.onNodeLoad, onNodeMouseEnter: this.onNodeMouseEnter, onNodeMouseLeave: this.onNodeMouseLeave, onNodeContextMenu: this.onNodeContextMenu, onNodeDragStart: this.onNodeDragStart, onNodeDragEnter: this.onNodeDragEnter, onNodeDragOver: this.onNodeDragOver, onNodeDragLeave: this.onNodeDragLeave, onNodeDragEnd: this.onNodeDragEnd, onNodeDrop: this.onNodeDrop };
-    return W.createElement(De.Provider, { value: fe }, W.createElement("div", { className: me(c, K, pe, l(l(l({}, "".concat(c, "-show-line"), f), "".concat(c, "-focused"), m), "".concat(c, "-active-focused"), o !== null)), style: ue }, W.createElement(xe, ge({ ref: this.listRef, prefixCls: c, style: u, data: E, disabled: U, selectable: D, checkable: !!A, motion: $, dragging: n !== null, height: oe, itemHeight: ne, virtual: re, focusable: N, focused: m, tabIndex: k, activeItem: this.getActiveItem(), onFocus: this.onFocus, onBlur: this.onBlur, onKeyDown: this.onKeyDown, onActiveChange: this.onActiveChange, onListChangeStart: this.onListChangeStart, onListChangeEnd: this.onListChangeEnd, onContextMenu: le, onScroll: ie, scrollWidth: ae }, this.getTreeNodeRequiredProps(), ye))));
-  } }], [{ key: "getDerivedStateFromProps", value: function(e, h) {
-    var m, E = h.prevProps, t = { prevProps: e };
-    function n(g) {
-      return !E && e.hasOwnProperty(g) || E && E[g] !== e[g];
+  _createClass(Tree2, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.destroyed = false;
+      this.onUpdated();
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate() {
+      this.onUpdated();
+    }
+  }, {
+    key: "onUpdated",
+    value: function onUpdated() {
+      var _this$props11 = this.props, activeKey = _this$props11.activeKey, _this$props11$itemScr = _this$props11.itemScrollOffset, itemScrollOffset = _this$props11$itemScr === void 0 ? 0 : _this$props11$itemScr;
+      if (activeKey !== void 0 && activeKey !== this.state.activeKey) {
+        this.setState({
+          activeKey
+        });
+        if (activeKey !== null) {
+          this.scrollTo({
+            key: activeKey,
+            offset: itemScrollOffset
+          });
+        }
+      }
     }
-    var o = h.fieldNames;
-    if (n("fieldNames") && (o = J(e.fieldNames), t.fieldNames = o), n("treeData") ? m = e.treeData : n("children") && (F(!1, "`children` of Tree is deprecated. Please use `treeData` instead."), m = be(e.children)), m) {
-      t.treeData = m;
-      var a = Oe(m, { fieldNames: o });
-      t.keyEntities = S(l({}, _, Pe), a.keyEntities), process.env.NODE_ENV !== "production" && Le(m, o);
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      window.removeEventListener("dragend", this.onWindowDragEnd);
+      this.destroyed = true;
     }
-    var d, i = t.keyEntities || h.keyEntities;
-    if (n("expandedKeys") || E && n("autoExpandParent")) t.expandedKeys = e.autoExpandParent || !E && e.defaultExpandParent ? X(e.expandedKeys, i) : e.expandedKeys;
-    else if (!E && e.defaultExpandAll) {
-      var s = S({}, i);
-      delete s[_];
-      var y = [];
-      Object.keys(s).forEach(function(g) {
-        var k = s[g];
-        k.children && k.children.length && y.push(k.key);
-      }), t.expandedKeys = y;
-    } else !E && e.defaultExpandedKeys && (t.expandedKeys = e.autoExpandParent || e.defaultExpandParent ? X(e.defaultExpandedKeys, i) : e.defaultExpandedKeys);
-    if (t.expandedKeys || delete t.expandedKeys, m || t.expandedKeys) {
-      var v = H(m || h.treeData, t.expandedKeys || h.expandedKeys, o);
-      t.flattenNodes = v;
+  }, {
+    key: "resetDragState",
+    value: function resetDragState() {
+      this.setState({
+        dragOverNodeKey: null,
+        dropPosition: null,
+        dropLevelOffset: null,
+        dropTargetKey: null,
+        dropContainerKey: null,
+        dropTargetPos: null,
+        dropAllowed: false
+      });
     }
-    if (e.selectable && (n("selectedKeys") ? t.selectedKeys = z(e.selectedKeys, e) : !E && e.defaultSelectedKeys && (t.selectedKeys = z(e.defaultSelectedKeys, e))), e.checkable && (n("checkedKeys") ? d = B(e.checkedKeys) || {} : !E && e.defaultCheckedKeys ? d = B(e.defaultCheckedKeys) || {} : m && (d = B(e.checkedKeys) || { checkedKeys: h.checkedKeys, halfCheckedKeys: h.halfCheckedKeys }), d)) {
-      var r = d, c = r.checkedKeys, K = c === void 0 ? [] : c, u = r.halfCheckedKeys, f = u === void 0 ? [] : u;
-      if (!e.checkStrictly) {
-        var N = j(K, !0, i);
-        K = N.checkedKeys, f = N.halfCheckedKeys;
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$state14 = this.state, focused = _this$state14.focused, flattenNodes = _this$state14.flattenNodes, keyEntities = _this$state14.keyEntities, draggingNodeKey = _this$state14.draggingNodeKey, activeKey = _this$state14.activeKey, dropLevelOffset = _this$state14.dropLevelOffset, dropContainerKey = _this$state14.dropContainerKey, dropTargetKey = _this$state14.dropTargetKey, dropPosition = _this$state14.dropPosition, dragOverNodeKey = _this$state14.dragOverNodeKey, indent = _this$state14.indent;
+      var _this$props12 = this.props, prefixCls = _this$props12.prefixCls, className = _this$props12.className, style = _this$props12.style, showLine = _this$props12.showLine, focusable = _this$props12.focusable, _this$props12$tabInde = _this$props12.tabIndex, tabIndex = _this$props12$tabInde === void 0 ? 0 : _this$props12$tabInde, selectable = _this$props12.selectable, showIcon = _this$props12.showIcon, icon = _this$props12.icon, switcherIcon = _this$props12.switcherIcon, draggable = _this$props12.draggable, checkable = _this$props12.checkable, checkStrictly = _this$props12.checkStrictly, disabled = _this$props12.disabled, motion = _this$props12.motion, loadData = _this$props12.loadData, filterTreeNode = _this$props12.filterTreeNode, height = _this$props12.height, itemHeight = _this$props12.itemHeight, scrollWidth = _this$props12.scrollWidth, virtual = _this$props12.virtual, titleRender = _this$props12.titleRender, dropIndicatorRender = _this$props12.dropIndicatorRender, onContextMenu = _this$props12.onContextMenu, onScroll = _this$props12.onScroll, direction = _this$props12.direction, rootClassName = _this$props12.rootClassName, rootStyle = _this$props12.rootStyle;
+      var domProps = pickAttrs(this.props, {
+        aria: true,
+        data: true
+      });
+      var draggableConfig;
+      if (draggable) {
+        if (_typeof(draggable) === "object") {
+          draggableConfig = draggable;
+        } else if (typeof draggable === "function") {
+          draggableConfig = {
+            nodeDraggable: draggable
+          };
+        } else {
+          draggableConfig = {};
+        }
+      }
+      var contextValue = {
+        prefixCls,
+        selectable,
+        showIcon,
+        icon,
+        switcherIcon,
+        draggable: draggableConfig,
+        draggingNodeKey,
+        checkable,
+        checkStrictly,
+        disabled,
+        keyEntities,
+        dropLevelOffset,
+        dropContainerKey,
+        dropTargetKey,
+        dropPosition,
+        dragOverNodeKey,
+        indent,
+        direction,
+        dropIndicatorRender,
+        loadData,
+        filterTreeNode,
+        titleRender,
+        onNodeClick: this.onNodeClick,
+        onNodeDoubleClick: this.onNodeDoubleClick,
+        onNodeExpand: this.onNodeExpand,
+        onNodeSelect: this.onNodeSelect,
+        onNodeCheck: this.onNodeCheck,
+        onNodeLoad: this.onNodeLoad,
+        onNodeMouseEnter: this.onNodeMouseEnter,
+        onNodeMouseLeave: this.onNodeMouseLeave,
+        onNodeContextMenu: this.onNodeContextMenu,
+        onNodeDragStart: this.onNodeDragStart,
+        onNodeDragEnter: this.onNodeDragEnter,
+        onNodeDragOver: this.onNodeDragOver,
+        onNodeDragLeave: this.onNodeDragLeave,
+        onNodeDragEnd: this.onNodeDragEnd,
+        onNodeDrop: this.onNodeDrop
+      };
+      return /* @__PURE__ */ React.createElement(TreeContext.Provider, {
+        value: contextValue
+      }, /* @__PURE__ */ React.createElement("div", {
+        className: classNames(prefixCls, className, rootClassName, _defineProperty(_defineProperty(_defineProperty({}, "".concat(prefixCls, "-show-line"), showLine), "".concat(prefixCls, "-focused"), focused), "".concat(prefixCls, "-active-focused"), activeKey !== null)),
+        style: rootStyle
+      }, /* @__PURE__ */ React.createElement(NodeList, _extends({
+        ref: this.listRef,
+        prefixCls,
+        style,
+        data: flattenNodes,
+        disabled,
+        selectable,
+        checkable: !!checkable,
+        motion,
+        dragging: draggingNodeKey !== null,
+        height,
+        itemHeight,
+        virtual,
+        focusable,
+        focused,
+        tabIndex,
+        activeItem: this.getActiveItem(),
+        onFocus: this.onFocus,
+        onBlur: this.onBlur,
+        onKeyDown: this.onKeyDown,
+        onActiveChange: this.onActiveChange,
+        onListChangeStart: this.onListChangeStart,
+        onListChangeEnd: this.onListChangeEnd,
+        onContextMenu,
+        onScroll,
+        scrollWidth
+      }, this.getTreeNodeRequiredProps(), domProps))));
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(props, prevState) {
+      var prevProps = prevState.prevProps;
+      var newState = {
+        prevProps: props
+      };
+      function needSync(name) {
+        return !prevProps && props.hasOwnProperty(name) || prevProps && prevProps[name] !== props[name];
+      }
+      var treeData;
+      var fieldNames = prevState.fieldNames;
+      if (needSync("fieldNames")) {
+        fieldNames = fillFieldNames(props.fieldNames);
+        newState.fieldNames = fieldNames;
+      }
+      if (needSync("treeData")) {
+        treeData = props.treeData;
+      } else if (needSync("children")) {
+        warningOnce(false, "`children` of Tree is deprecated. Please use `treeData` instead.");
+        treeData = convertTreeToData(props.children);
+      }
+      if (treeData) {
+        newState.treeData = treeData;
+        var entitiesMap = convertDataToEntities(treeData, {
+          fieldNames
+        });
+        newState.keyEntities = _objectSpread2(_defineProperty({}, MOTION_KEY, MotionEntity), entitiesMap.keyEntities);
+        if (process.env.NODE_ENV !== "production") {
+          warningWithoutKey(treeData, fieldNames);
+        }
+      }
+      var keyEntities = newState.keyEntities || prevState.keyEntities;
+      if (needSync("expandedKeys") || prevProps && needSync("autoExpandParent")) {
+        newState.expandedKeys = props.autoExpandParent || !prevProps && props.defaultExpandParent ? conductExpandParent(props.expandedKeys, keyEntities) : props.expandedKeys;
+      } else if (!prevProps && props.defaultExpandAll) {
+        var cloneKeyEntities = _objectSpread2({}, keyEntities);
+        delete cloneKeyEntities[MOTION_KEY];
+        var nextExpandedKeys = [];
+        Object.keys(cloneKeyEntities).forEach(function(key) {
+          var entity = cloneKeyEntities[key];
+          if (entity.children && entity.children.length) {
+            nextExpandedKeys.push(entity.key);
+          }
+        });
+        newState.expandedKeys = nextExpandedKeys;
+      } else if (!prevProps && props.defaultExpandedKeys) {
+        newState.expandedKeys = props.autoExpandParent || props.defaultExpandParent ? conductExpandParent(props.defaultExpandedKeys, keyEntities) : props.defaultExpandedKeys;
+      }
+      if (!newState.expandedKeys) {
+        delete newState.expandedKeys;
+      }
+      if (treeData || newState.expandedKeys) {
+        var flattenNodes = flattenTreeData(treeData || prevState.treeData, newState.expandedKeys || prevState.expandedKeys, fieldNames);
+        newState.flattenNodes = flattenNodes;
+      }
+      if (props.selectable) {
+        if (needSync("selectedKeys")) {
+          newState.selectedKeys = calcSelectedKeys(props.selectedKeys, props);
+        } else if (!prevProps && props.defaultSelectedKeys) {
+          newState.selectedKeys = calcSelectedKeys(props.defaultSelectedKeys, props);
+        }
+      }
+      if (props.checkable) {
+        var checkedKeyEntity;
+        if (needSync("checkedKeys")) {
+          checkedKeyEntity = parseCheckedKeys(props.checkedKeys) || {};
+        } else if (!prevProps && props.defaultCheckedKeys) {
+          checkedKeyEntity = parseCheckedKeys(props.defaultCheckedKeys) || {};
+        } else if (treeData) {
+          checkedKeyEntity = parseCheckedKeys(props.checkedKeys) || {
+            checkedKeys: prevState.checkedKeys,
+            halfCheckedKeys: prevState.halfCheckedKeys
+          };
+        }
+        if (checkedKeyEntity) {
+          var _checkedKeyEntity = checkedKeyEntity, _checkedKeyEntity$che = _checkedKeyEntity.checkedKeys, checkedKeys = _checkedKeyEntity$che === void 0 ? [] : _checkedKeyEntity$che, _checkedKeyEntity$hal = _checkedKeyEntity.halfCheckedKeys, halfCheckedKeys = _checkedKeyEntity$hal === void 0 ? [] : _checkedKeyEntity$hal;
+          if (!props.checkStrictly) {
+            var conductKeys = conductCheck(checkedKeys, true, keyEntities);
+            checkedKeys = conductKeys.checkedKeys;
+            halfCheckedKeys = conductKeys.halfCheckedKeys;
+          }
+          newState.checkedKeys = checkedKeys;
+          newState.halfCheckedKeys = halfCheckedKeys;
+        }
+      }
+      if (needSync("loadedKeys")) {
+        newState.loadedKeys = props.loadedKeys;
       }
-      t.checkedKeys = K, t.halfCheckedKeys = f;
+      return newState;
     }
-    return n("loadedKeys") && (t.loadedKeys = e.loadedKeys), t;
-  } }]), I;
-}(W.Component);
-l(Q, "defaultProps", { prefixCls: "rc-tree", showLine: !1, showIcon: !0, selectable: !0, multiple: !1, checkable: !1, disabled: !1, checkStrictly: !1, draggable: !1, defaultExpandParent: !0, autoExpandParent: !1, defaultExpandAll: !1, defaultExpandedKeys: [], defaultCheckedKeys: [], defaultSelectedKeys: [], dropIndicatorRender: Ce, allowDrop: function() {
-  return !0;
-}, expandAction: !1 }), l(Q, "TreeNode", Se);
+  }]);
+  return Tree2;
+}(React.Component);
+_defineProperty(Tree, "defaultProps", {
+  prefixCls: "rc-tree",
+  showLine: false,
+  showIcon: true,
+  selectable: true,
+  multiple: false,
+  checkable: false,
+  disabled: false,
+  checkStrictly: false,
+  draggable: false,
+  defaultExpandParent: true,
+  autoExpandParent: false,
+  defaultExpandAll: false,
+  defaultExpandedKeys: [],
+  defaultCheckedKeys: [],
+  defaultSelectedKeys: [],
+  dropIndicatorRender: DropIndicator,
+  allowDrop: function allowDrop() {
+    return true;
+  },
+  expandAction: false
+});
+_defineProperty(Tree, "TreeNode", TreeNode);
 export {
-  Q as default
+  Tree as default
 };