@qsxy/element-plus-react 1.0.0-next.1 → 1.0.0-next.10

package/dist/Tree/RCTree.js

@@ -33,19 +33,20 @@ __export(RCTree_exports, {
 });
 module.exports = __toCommonJS(RCTree_exports);
 var import_classnames = __toESM(require("classnames"));
-var import_react = __toESM(require("react"));
-var import_KeyCode = __toESM(require("./utils/KeyCode"));
-var import_pickAttrs = __toESM(require("./utils/pickAttrs"));
-var import_Util = require("../Util");
+var import_KeyCode = __toESM(require("rc-util/lib/KeyCode"));
+var import_pickAttrs = __toESM(require("rc-util/lib/pickAttrs"));
+var import_warning = __toESM(require("rc-util/lib/warning"));
+var React = __toESM(require("react"));
 var import_DropIndicator = __toESM(require("./DropIndicator"));
 var import_NodeList = __toESM(require("./NodeList"));
 var import_TreeNode = __toESM(require("./TreeNode"));
 var import_contextTypes = require("./contextTypes");
 var import_util = require("./util");
 var import_conductUtil = require("./utils/conductUtil");
+var import_keyUtil = __toESM(require("./utils/keyUtil"));
 var import_treeUtil = require("./utils/treeUtil");
 var MAX_RETRY_TIMES = 10;
-var RCTree = class extends import_react.Component {
+var Tree = class extends React.Component {
   constructor() {
     super(...arguments);
     this.destroyed = false;
@@ -88,13 +89,14 @@ var RCTree = class extends import_react.Component {
       fieldNames: (0, import_treeUtil.fillFieldNames)()
     };
     this.dragStartMousePosition = null;
+    this.dragNodeProps = null;
     this.currentMouseOverDroppableNodeKey = null;
-    this.listRef = (0, import_react.createRef)();
-    this.onNodeDragStart = (event, node) => {
+    this.listRef = React.createRef();
+    this.onNodeDragStart = (event, nodeProps) => {
       const { expandedKeys, keyEntities } = this.state;
       const { onDragStart } = this.props;
-      const { eventKey } = node.props;
-      this.dragNode = node;
+      const { eventKey } = nodeProps;
+      this.dragNodeProps = nodeProps;
       this.dragStartMousePosition = {
         x: event.clientX,
         y: event.clientY
@@ -107,7 +109,7 @@ var RCTree = class extends import_react.Component {
       });
       this.setExpandedKeys(newExpandedKeys);
       window.addEventListener("dragend", this.onWindowDragEnd);
-      onDragStart == null ? void 0 : onDragStart({ event, node: (0, import_treeUtil.convertNodePropsToEventData)(node.props) });
+      onDragStart == null ? void 0 : onDragStart({ event, node: (0, import_treeUtil.convertNodePropsToEventData)(nodeProps) });
     };
     /**
      * [Legacy] Select handler is smaller than node,
@@ -116,22 +118,21 @@ var RCTree = class extends import_react.Component {
      * Better for use mouse move event to refresh drag state.
      * But let's just keep it to avoid event trigger logic change.
      */
-    this.onNodeDragEnter = (event, node) => {
+    this.onNodeDragEnter = (event, nodeProps) => {
       const { expandedKeys, keyEntities, dragChildrenKeys, flattenNodes, indent } = this.state;
       const { onDragEnter, onExpand, allowDrop, direction } = this.props;
-      const { pos, eventKey } = node.props;
-      const { dragNode } = this;
+      const { pos, eventKey } = nodeProps;
       if (this.currentMouseOverDroppableNodeKey !== eventKey) {
         this.currentMouseOverDroppableNodeKey = eventKey;
       }
-      if (!dragNode) {
+      if (!this.dragNodeProps) {
         this.resetDragState();
         return;
       }
       const { dropPosition, dropLevelOffset, dropTargetKey, dropContainerKey, dropTargetPos, dropAllowed, dragOverNodeKey } = (0, import_util.calcDropPosition)(
         event,
-        dragNode,
-        node,
+        this.dragNodeProps,
+        nodeProps,
         indent,
         this.dragStartMousePosition,
         allowDrop,
@@ -142,7 +143,7 @@ var RCTree = class extends import_react.Component {
       );
       if (
         // don't allow drop inside its children
-        dragChildrenKeys.indexOf(dropTargetKey) !== -1 || // don't allow drop when drop is not allowed caculated by calcDropPosition
+        dragChildrenKeys.includes(dropTargetKey) || // don't allow drop when drop is not allowed caculated by calcDropPosition
         !dropAllowed
       ) {
         this.resetDragState();
@@ -154,28 +155,28 @@ var RCTree = class extends import_react.Component {
       Object.keys(this.delayedDragEnterLogic).forEach((key) => {
         clearTimeout(this.delayedDragEnterLogic[key]);
       });
-      if (dragNode.props.eventKey !== node.props.eventKey) {
+      if (this.dragNodeProps.eventKey !== nodeProps.eventKey) {
         event.persist();
         this.delayedDragEnterLogic[pos] = window.setTimeout(() => {
           if (this.state.draggingNodeKey === null) {
             return;
           }
           let newExpandedKeys = [...expandedKeys];
-          const entity = keyEntities[node.props.eventKey];
+          const entity = (0, import_keyUtil.default)(keyEntities, nodeProps.eventKey);
           if (entity && (entity.children || []).length) {
-            newExpandedKeys = (0, import_util.arrAdd)(expandedKeys, node.props.eventKey);
+            newExpandedKeys = (0, import_util.arrAdd)(expandedKeys, nodeProps.eventKey);
           }
-          if (!("expandedKeys" in this.props)) {
+          if (!Object.prototype.hasOwnProperty.call(this.props, "expandedKeys")) {
             this.setExpandedKeys(newExpandedKeys);
           }
           onExpand == null ? void 0 : onExpand(newExpandedKeys, {
-            node: (0, import_treeUtil.convertNodePropsToEventData)(node.props),
+            node: (0, import_treeUtil.convertNodePropsToEventData)(nodeProps),
             expanded: true,
             nativeEvent: event.nativeEvent
           });
         }, 800);
       }
-      if (dragNode.props.eventKey === dropTargetKey && dropLevelOffset === 0) {
+      if (this.dragNodeProps.eventKey === dropTargetKey && dropLevelOffset === 0) {
         this.resetDragState();
         return;
       }
@@ -190,21 +191,20 @@ var RCTree = class extends import_react.Component {
       });
       onDragEnter == null ? void 0 : onDragEnter({
         event,
-        node: (0, import_treeUtil.convertNodePropsToEventData)(node.props),
+        node: (0, import_treeUtil.convertNodePropsToEventData)(nodeProps),
         expandedKeys
       });
     };
-    this.onNodeDragOver = (event, node) => {
+    this.onNodeDragOver = (event, nodeProps) => {
       const { dragChildrenKeys, flattenNodes, keyEntities, expandedKeys, indent } = this.state;
       const { onDragOver, allowDrop, direction } = this.props;
-      const { dragNode } = this;
-      if (!dragNode) {
+      if (!this.dragNodeProps) {
         return;
       }
-      const { dropPosition, dropLevelOffset, dropTargetKey, dropContainerKey, dropAllowed, dropTargetPos, dragOverNodeKey } = (0, import_util.calcDropPosition)(
+      const { dropPosition, dropLevelOffset, dropTargetKey, dropContainerKey, dropTargetPos, dropAllowed, dragOverNodeKey } = (0, import_util.calcDropPosition)(
         event,
-        dragNode,
-        node,
+        this.dragNodeProps,
+        nodeProps,
         indent,
         this.dragStartMousePosition,
         allowDrop,
@@ -213,10 +213,10 @@ var RCTree = class extends import_react.Component {
         expandedKeys,
         direction
       );
-      if (dragChildrenKeys.indexOf(dropTargetKey) !== -1 || !dropAllowed) {
+      if (dragChildrenKeys.includes(dropTargetKey) || !dropAllowed) {
         return;
       }
-      if (dragNode.props.eventKey === dropTargetKey && dropLevelOffset === 0) {
+      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();
         }
@@ -231,15 +231,15 @@ var RCTree = class extends import_react.Component {
           dragOverNodeKey
         });
       }
-      onDragOver == null ? void 0 : onDragOver({ event, node: (0, import_treeUtil.convertNodePropsToEventData)(node.props) });
+      onDragOver == null ? void 0 : onDragOver({ event, node: (0, import_treeUtil.convertNodePropsToEventData)(nodeProps) });
     };
-    this.onNodeDragLeave = (event, node) => {
-      if (this.currentMouseOverDroppableNodeKey === node.props.eventKey && !event.currentTarget.contains(event.relatedTarget)) {
+    this.onNodeDragLeave = (event, nodeProps) => {
+      if (this.currentMouseOverDroppableNodeKey === nodeProps.eventKey && !event.currentTarget.contains(event.relatedTarget)) {
         this.resetDragState();
         this.currentMouseOverDroppableNodeKey = null;
       }
       const { onDragLeave } = this.props;
-      onDragLeave == null ? void 0 : onDragLeave({ event, node: (0, import_treeUtil.convertNodePropsToEventData)(node.props) });
+      onDragLeave == null ? void 0 : onDragLeave({ event, node: (0, import_treeUtil.convertNodePropsToEventData)(nodeProps) });
     };
     // since stopPropagation() is called in treeNode
     // if onWindowDrag is called, whice means state is keeped, drag state should be cleared
@@ -248,16 +248,17 @@ var RCTree = class extends import_react.Component {
       window.removeEventListener("dragend", this.onWindowDragEnd);
     };
     // if onNodeDragEnd is called, onWindowDragEnd won't be called since stopPropagation() is called
-    this.onNodeDragEnd = (event, node) => {
+    this.onNodeDragEnd = (event, nodeProps) => {
       const { onDragEnd } = this.props;
       this.setState({
         dragOverNodeKey: null
       });
       this.cleanDragState();
-      onDragEnd == null ? void 0 : onDragEnd({ event, node: (0, import_treeUtil.convertNodePropsToEventData)(node.props) });
-      this.dragNode = null;
+      onDragEnd == null ? void 0 : onDragEnd({ event, node: (0, import_treeUtil.convertNodePropsToEventData)(nodeProps) });
+      this.dragNodeProps = null;
+      window.removeEventListener("dragend", this.onWindowDragEnd);
     };
-    this.onNodeDrop = (event, node, outsideTree = false) => {
+    this.onNodeDrop = (event, _, outsideTree = false) => {
       var _a;
       const { dragChildrenKeys, dropPosition, dropTargetKey, dropTargetPos, dropAllowed } = this.state;
       if (!dropAllowed) {
@@ -273,24 +274,24 @@ var RCTree = class extends import_react.Component {
       }
       const abstractDropNodeProps = {
         ...(0, import_treeUtil.getTreeNodeProps)(dropTargetKey, this.getTreeNodeRequiredProps()),
-        active: ((_a = this.getActiveItem()) == null ? void 0 : _a.data.key) === dropTargetKey,
-        data: this.state.keyEntities[dropTargetKey].node
+        active: ((_a = this.getActiveItem()) == null ? void 0 : _a.key) === dropTargetKey,
+        data: (0, import_keyUtil.default)(this.state.keyEntities, dropTargetKey).node
       };
-      const dropToChild = dragChildrenKeys.indexOf(dropTargetKey) !== -1;
-      (0, import_Util.warning)(!dropToChild, "Can not drop to dragNode’s children node. This is a bug of rc-tree. Please report an issue.");
+      const dropToChild = dragChildrenKeys.includes(dropTargetKey);
+      (0, import_warning.default)(!dropToChild, "Can not drop to dragNodes children node. This is a bug of rc-tree. Please report an issue.");
       const posArr = (0, import_util.posToArr)(dropTargetPos);
       const dropResult = {
         event,
         node: (0, import_treeUtil.convertNodePropsToEventData)(abstractDropNodeProps),
-        dragNode: this.dragNode ? (0, import_treeUtil.convertNodePropsToEventData)(this.dragNode.props) : null,
-        dragNodesKeys: [this.dragNode.props.eventKey].concat(dragChildrenKeys),
+        dragNode: this.dragNodeProps ? (0, import_treeUtil.convertNodePropsToEventData)(this.dragNodeProps) : null,
+        dragNodesKeys: [this.dragNodeProps.eventKey].concat(dragChildrenKeys),
         dropToGap: dropPosition !== 0,
         dropPosition: dropPosition + Number(posArr[posArr.length - 1])
       };
       if (!outsideTree) {
         onDrop == null ? void 0 : onDrop(dropResult);
       }
-      this.dragNode = null;
+      this.dragNodeProps = null;
     };
     this.cleanDragState = () => {
       const { draggingNodeKey } = this.state;
@@ -308,12 +309,32 @@ var RCTree = class extends import_react.Component {
       this.dragStartMousePosition = null;
       this.currentMouseOverDroppableNodeKey = null;
     };
+    this.triggerExpandActionExpand = (e, treeNode) => {
+      const { expandedKeys, flattenNodes } = this.state;
+      const { expanded, key, isLeaf } = treeNode;
+      if (isLeaf || e.shiftKey || e.metaKey || e.ctrlKey) {
+        return;
+      }
+      const node = flattenNodes.filter((nodeItem) => nodeItem.key === key)[0];
+      const eventNode = (0, import_treeUtil.convertNodePropsToEventData)({
+        ...(0, import_treeUtil.getTreeNodeProps)(key, this.getTreeNodeRequiredProps()),
+        data: node.data
+      });
+      this.setExpandedKeys(expanded ? (0, import_util.arrDel)(expandedKeys, key) : (0, import_util.arrAdd)(expandedKeys, key));
+      this.onNodeExpand(e, eventNode);
+    };
     this.onNodeClick = (e, treeNode) => {
-      const { onClick } = this.props;
+      const { onClick, expandAction } = this.props;
+      if (expandAction === "click") {
+        this.triggerExpandActionExpand(e, treeNode);
+      }
       onClick == null ? void 0 : onClick(e, treeNode);
     };
     this.onNodeDoubleClick = (e, treeNode) => {
-      const { onDoubleClick } = this.props;
+      const { onDoubleClick, expandAction } = this.props;
+      if (expandAction === "doubleClick") {
+        this.triggerExpandActionExpand(e, treeNode);
+      }
       onDoubleClick == null ? void 0 : onDoubleClick(e, treeNode);
     };
     this.onNodeSelect = (e, treeNode) => {
@@ -331,12 +352,9 @@ var RCTree = class extends import_react.Component {
         selectedKeys = (0, import_util.arrAdd)(selectedKeys, key);
       }
       const selectedNodes = selectedKeys.map((selectedKey) => {
-        const entity = keyEntities[selectedKey];
-        if (!entity) {
-          return null;
-        }
-        return entity.node;
-      }).filter((node) => node);
+        const entity = (0, import_keyUtil.default)(keyEntities, selectedKey);
+        return entity ? entity.node : null;
+      }).filter(Boolean);
       this.setUncontrolledState({ selectedKeys });
       onSelect == null ? void 0 : onSelect(selectedKeys, {
         event: "select",
@@ -361,7 +379,7 @@ var RCTree = class extends import_react.Component {
         const checkedKeys = checked ? (0, import_util.arrAdd)(oriCheckedKeys, key) : (0, import_util.arrDel)(oriCheckedKeys, key);
         const halfCheckedKeys = (0, import_util.arrDel)(oriHalfCheckedKeys, key);
         checkedObj = { checked: checkedKeys, halfChecked: halfCheckedKeys };
-        eventObj.checkedNodes = checkedKeys.map((checkedKey) => keyEntities[checkedKey]).filter((entity) => entity).map((entity) => entity.node);
+        eventObj.checkedNodes = checkedKeys.map((checkedKey) => (0, import_keyUtil.default)(keyEntities, checkedKey)).filter(Boolean).map((entity) => entity.node);
         this.setUncontrolledState({ checkedKeys });
       } else {
         let { checkedKeys, halfCheckedKeys } = (0, import_conductUtil.conductCheck)([...oriCheckedKeys, key], true, keyEntities);
@@ -375,7 +393,7 @@ var RCTree = class extends import_react.Component {
         eventObj.checkedNodesPositions = [];
         eventObj.halfCheckedKeys = halfCheckedKeys;
         checkedKeys.forEach((checkedKey) => {
-          const entity = keyEntities[checkedKey];
+          const entity = (0, import_keyUtil.default)(keyEntities, checkedKey);
           if (!entity) {
             return;
           }
@@ -383,24 +401,22 @@ var RCTree = class extends import_react.Component {
           eventObj.checkedNodes.push(node);
           eventObj.checkedNodesPositions.push({ node, pos });
         });
-        this.setUncontrolledState(
-          {
-            checkedKeys
-          },
-          false,
-          {
-            halfCheckedKeys
-          }
-        );
+        this.setUncontrolledState({ checkedKeys }, false, { halfCheckedKeys });
       }
       onCheck == null ? void 0 : onCheck(checkedObj, eventObj);
     };
     this.onNodeLoad = (treeNode) => {
+      var _a;
       const { key } = treeNode;
+      const { keyEntities } = this.state;
+      const entity = (0, import_keyUtil.default)(keyEntities, key);
+      if ((_a = entity == null ? void 0 : entity.children) == null ? void 0 : _a.length) {
+        return;
+      }
       const loadPromise = new Promise((resolve, reject) => {
         this.setState(({ loadedKeys = [], loadingKeys = [] }) => {
           const { loadData, onLoad } = this.props;
-          if (!loadData || loadedKeys.indexOf(key) !== -1 || loadingKeys.indexOf(key) !== -1) {
+          if (!loadData || loadedKeys.includes(key) || loadingKeys.includes(key)) {
             return null;
           }
           const promise = loadData(treeNode);
@@ -425,7 +441,7 @@ var RCTree = class extends import_react.Component {
             this.loadingRetryTimes[key] = (this.loadingRetryTimes[key] || 0) + 1;
             if (this.loadingRetryTimes[key] >= MAX_RETRY_TIMES) {
               const { loadedKeys: currentLoadedKeys } = this.state;
-              (0, import_Util.warning)(false, "Retry for `loadData` many times but still failed. No more retry.");
+              (0, import_warning.default)(false, "Retry for `loadData` many times but still failed. No more retry.");
               this.setUncontrolledState({
                 loadedKeys: (0, import_util.arrAdd)(currentLoadedKeys, key)
               });
@@ -460,13 +476,13 @@ var RCTree = class extends import_react.Component {
     this.onFocus = (...args) => {
       const { onFocus } = this.props;
       this.setState({ focused: true });
-      onFocus == null ? void 0 : onFocus.apply(this, ...args);
+      onFocus == null ? void 0 : onFocus(...args);
     };
     this.onBlur = (...args) => {
       const { onBlur } = this.props;
       this.setState({ focused: false });
       this.onActiveChange(null);
-      onBlur == null ? void 0 : onBlur.apply(this, ...args);
+      onBlur == null ? void 0 : onBlur(...args);
     };
     this.getTreeNodeRequiredProps = () => {
       const { expandedKeys, selectedKeys, loadedKeys, loadingKeys, checkedKeys, halfCheckedKeys, dragOverNodeKey, dropPosition, keyEntities } = this.state;
@@ -487,17 +503,7 @@ var RCTree = class extends import_react.Component {
     this.setExpandedKeys = (expandedKeys) => {
       const { treeData, fieldNames } = this.state;
       const flattenNodes = (0, import_treeUtil.flattenTreeData)(treeData, expandedKeys, fieldNames);
-      this.setUncontrolledState(
-        {
-          expandedKeys,
-          flattenNodes
-        },
-        true
-      );
-    };
-    this.flattenTreeData = (expandedKeys) => {
-      const { treeData, fieldNames } = this.state;
-      return (0, import_treeUtil.flattenTreeData)(treeData, expandedKeys, fieldNames);
+      this.setUncontrolledState({ expandedKeys, flattenNodes }, true);
     };
     this.onNodeExpand = (e, treeNode) => {
       let { expandedKeys } = this.state;
@@ -508,14 +514,10 @@ var RCTree = class extends import_react.Component {
       if (listChanging) {
         return;
       }
-      const index = expandedKeys.indexOf(key);
+      const certain = expandedKeys.includes(key);
       const targetExpanded = !expanded;
-      (0, import_Util.warning)(expanded && index !== -1 || !expanded && index === -1, "Expand state not sync with index check");
-      if (targetExpanded) {
-        expandedKeys = (0, import_util.arrAdd)(expandedKeys, key);
-      } else {
-        expandedKeys = (0, import_util.arrDel)(expandedKeys, key);
-      }
+      (0, import_warning.default)(expanded && certain || !expanded && !certain, "Expand state not sync with index check");
+      expandedKeys = targetExpanded ? (0, import_util.arrAdd)(expandedKeys, key) : (0, import_util.arrDel)(expandedKeys, key);
       this.setExpandedKeys(expandedKeys);
       onExpand == null ? void 0 : onExpand(expandedKeys, {
         node: treeNode,
@@ -551,13 +553,13 @@ var RCTree = class extends import_react.Component {
     // =========================== Keyboard ===========================
     this.onActiveChange = (newActiveKey) => {
       const { activeKey } = this.state;
-      const { onActiveChange } = this.props;
+      const { onActiveChange, itemScrollOffset = 0 } = this.props;
       if (activeKey === newActiveKey) {
         return;
       }
       this.setState({ activeKey: newActiveKey });
       if (newActiveKey !== null) {
-        this.scrollTo({ key: newActiveKey });
+        this.scrollTo({ key: newActiveKey, offset: itemScrollOffset });
       }
       onActiveChange == null ? void 0 : onActiveChange(newActiveKey);
     };
@@ -584,7 +586,7 @@ var RCTree = class extends import_react.Component {
       }
     };
     this.onKeyDown = (event) => {
-      const { activeKey, expandedKeys, checkedKeys } = this.state;
+      const { activeKey, expandedKeys, checkedKeys, fieldNames } = this.state;
       const { onKeyDown, checkable, selectable } = this.props;
       switch (event.which) {
         case import_KeyCode.default.UP: {
@@ -601,7 +603,7 @@ var RCTree = class extends import_react.Component {
       const activeItem = this.getActiveItem();
       if (activeItem && activeItem.data) {
         const treeNodeRequiredProps = this.getTreeNodeRequiredProps();
-        const expandable = activeItem.data.isLeaf === false || !!(activeItem.data.children || []).length;
+        const expandable = activeItem.data.isLeaf === false || !!(activeItem.data[fieldNames.children] || []).length;
         const eventNode = (0, import_treeUtil.convertNodePropsToEventData)({
           ...(0, import_treeUtil.getTreeNodeProps)(activeKey, treeNodeRequiredProps),
           data: activeItem.data,
@@ -612,7 +614,7 @@ var RCTree = class extends import_react.Component {
             if (expandable && expandedKeys.includes(activeKey)) {
               this.onNodeExpand({}, eventNode);
             } else if (activeItem.parent) {
-              this.onActiveChange(activeItem.parent.data.key);
+              this.onActiveChange(activeItem.parent.key);
             }
             event.preventDefault();
             break;
@@ -621,7 +623,7 @@ var RCTree = class extends import_react.Component {
             if (expandable && !expandedKeys.includes(activeKey)) {
               this.onNodeExpand({}, eventNode);
             } else if (activeItem.children && activeItem.children.length) {
-              this.onActiveChange(activeItem.children[0].data.key);
+              this.onActiveChange(activeItem.children[0].key);
             }
             event.preventDefault();
             break;
@@ -637,7 +639,7 @@ var RCTree = class extends import_react.Component {
           }
         }
       }
-      onKeyDown == null ? void 0 : onKeyDown.call(this, event);
+      onKeyDown == null ? void 0 : onKeyDown(event);
     };
     /**
      * Only update the value which is not in props
@@ -648,7 +650,7 @@ var RCTree = class extends import_react.Component {
         let allPassed = true;
         const newState = {};
         Object.keys(state).forEach((name) => {
-          if (name in this.props) {
+          if (Object.prototype.hasOwnProperty.call(this.props, name)) {
             allPassed = false;
             return;
           }
@@ -668,17 +670,18 @@ var RCTree = class extends import_react.Component {
     };
   }
   componentDidMount() {
+    this.destroyed = false;
     this.onUpdated();
   }
   componentDidUpdate() {
     this.onUpdated();
   }
   onUpdated() {
-    const { activeKey } = this.props;
+    const { activeKey, itemScrollOffset = 0 } = this.props;
     if (activeKey !== void 0 && activeKey !== this.state.activeKey) {
       this.setState({ activeKey });
       if (activeKey !== null) {
-        this.scrollTo({ key: activeKey });
+        this.scrollTo({ key: activeKey, offset: itemScrollOffset });
       }
     }
   }
@@ -692,7 +695,7 @@ var RCTree = class extends import_react.Component {
       prevProps: props
     };
     function needSync(name) {
-      return !prevProps && name in props || prevProps && prevProps[name] !== props[name];
+      return !prevProps && Object.prototype.hasOwnProperty.call(props, name) || prevProps && prevProps[name] !== props[name];
     }
     let treeData;
     let { fieldNames } = prevState;
@@ -703,7 +706,7 @@ var RCTree = class extends import_react.Component {
     if (needSync("treeData")) {
       ({ treeData } = props);
     } else if (needSync("children")) {
-      (0, import_Util.warning)(false, "`children` of Tree is deprecated. Please use `treeData` instead.");
+      (0, import_warning.default)(false, "`children` of Tree is deprecated. Please use `treeData` instead.");
       treeData = (0, import_treeUtil.convertTreeToData)(props.children);
     }
     if (treeData) {
@@ -723,7 +726,14 @@ var RCTree = class extends import_react.Component {
     } else if (!prevProps && props.defaultExpandAll) {
       const cloneKeyEntities = { ...keyEntities };
       delete cloneKeyEntities[import_NodeList.MOTION_KEY];
-      newState.expandedKeys = Object.keys(cloneKeyEntities).map((key) => cloneKeyEntities[key].key);
+      const nextExpandedKeys = [];
+      Object.keys(cloneKeyEntities).forEach((key) => {
+        const 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 ? (0, import_util.conductExpandParent)(props.defaultExpandedKeys, keyEntities) : props.defaultExpandedKeys;
     }
@@ -785,6 +795,8 @@ var RCTree = class extends import_react.Component {
       prefixCls,
       className,
       style,
+      styles,
+      classNames: treeClassNames,
       showLine,
       focusable,
       tabIndex = 0,
@@ -801,6 +813,7 @@ var RCTree = class extends import_react.Component {
       filterTreeNode,
       height,
       itemHeight,
+      scrollWidth,
       virtual,
       titleRender,
       dropIndicatorRender,
@@ -826,97 +839,94 @@ var RCTree = class extends import_react.Component {
         draggableConfig = {};
       }
     }
-    return /* @__PURE__ */ import_react.default.createElement(
-      import_contextTypes.TreeContext.Provider,
+    const contextValue = {
+      styles,
+      classNames: treeClassNames,
+      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(import_contextTypes.TreeContext.Provider, { value: contextValue }, /* @__PURE__ */ React.createElement(
+      "div",
       {
-        value: {
+        className: (0, import_classnames.default)(prefixCls, className, rootClassName, {
+          [`${prefixCls}-show-line`]: showLine,
+          [`${prefixCls}-focused`]: focused,
+          [`${prefixCls}-active-focused`]: activeKey !== null
+        }),
+        style: rootStyle
+      },
+      /* @__PURE__ */ React.createElement(
+        import_NodeList.default,
+        {
+          ref: this.listRef,
           prefixCls,
-          selectable,
-          showIcon,
-          icon,
-          switcherIcon,
-          draggable: draggableConfig,
-          draggingNodeKey,
-          checkable,
-          checkStrictly,
+          style,
+          data: flattenNodes,
           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
+          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
         }
-      },
-      /* @__PURE__ */ import_react.default.createElement(
-        "div",
-        {
-          role: "tree",
-          className: (0, import_classnames.default)(prefixCls, className, rootClassName, {
-            [`${prefixCls}-show-line`]: showLine,
-            [`${prefixCls}-focused`]: focused,
-            [`${prefixCls}-active-focused`]: activeKey !== null
-          }),
-          style: rootStyle
-        },
-        /* @__PURE__ */ import_react.default.createElement(
-          import_NodeList.default,
-          {
-            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,
-            ...this.getTreeNodeRequiredProps(),
-            ...domProps
-          }
-        )
       )
-    );
+    ));
   }
 };
-RCTree.defaultProps = {
-  prefixCls: "r-tree",
+Tree.defaultProps = {
+  prefixCls: "el-tree",
   showLine: false,
   showIcon: true,
   selectable: true,
@@ -932,7 +942,8 @@ RCTree.defaultProps = {
   defaultCheckedKeys: [],
   defaultSelectedKeys: [],
   dropIndicatorRender: import_DropIndicator.default,
-  allowDrop: () => true
+  allowDrop: () => true,
+  expandAction: false
 };
-RCTree.TreeNode = import_TreeNode.default;
-var RCTree_default = RCTree;
+Tree.TreeNode = import_TreeNode.default;
+var RCTree_default = Tree;