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

package/dist/Tree/util.js

@@ -36,37 +36,19 @@ __export(util_exports, {
   conductExpandParent: () => conductExpandParent,
   convertDataToTree: () => convertDataToTree,
   getDragChildrenKeys: () => getDragChildrenKeys,
-  getPosition: () => getPosition,
+  getPosition: () => import_treeUtil.getPosition,
   isFirstChild: () => isFirstChild,
   isLastChild: () => isLastChild,
-  isTreeNode: () => isTreeNode,
-  omit: () => omit,
+  isTreeNode: () => import_treeUtil.isTreeNode,
   parseCheckedKeys: () => parseCheckedKeys,
-  posToArr: () => posToArr,
-  toArray: () => toArray
+  posToArr: () => posToArr
 });
 module.exports = __toCommonJS(util_exports);
+var import_warning = __toESM(require("rc-util/lib/warning"));
 var import_react = __toESM(require("react"));
-var import_Util = require("../Util");
 var import_TreeNode = __toESM(require("./TreeNode"));
-function toArray(children, option = {}) {
-  let ret = [];
-  import_react.Children.forEach(children, (child) => {
-    if ((child === void 0 || child === null) && !option.keepEmpty) {
-      return;
-    }
-    let nodeType = child == null ? void 0 : child.type;
-    nodeType = (nodeType == null ? void 0 : nodeType.displayName) || nodeType;
-    if (Array.isArray(child)) {
-      ret = ret.concat(toArray(child));
-    } else if (nodeType === "Fragment" && child.props) {
-      ret = ret.concat(toArray(child.props.children, option));
-    } else {
-      ret.push(child);
-    }
-  });
-  return ret;
-}
+var import_keyUtil = __toESM(require("./utils/keyUtil"));
+var import_treeUtil = require("./utils/treeUtil");
 function arrDel(list, value) {
   if (!list) {
     return [];
@@ -88,15 +70,9 @@ function arrAdd(list, value) {
 function posToArr(pos) {
   return pos.split("-");
 }
-function getPosition(level, index) {
-  return `${level}-${index}`;
-}
-function isTreeNode(node) {
-  return node && node.type && node.type.isTreeNode;
-}
 function getDragChildrenKeys(dragNodeKey, keyEntities) {
   const dragChildrenKeys = [];
-  const entity = keyEntities[dragNodeKey];
+  const entity = (0, import_keyUtil.default)(keyEntities, dragNodeKey);
   function dig(list = []) {
     list.forEach(({ key, children }) => {
       dragChildrenKeys.push(key);
@@ -117,25 +93,29 @@ function isFirstChild(treeNodeEntity) {
   const posArr = posToArr(treeNodeEntity.pos);
   return Number(posArr[posArr.length - 1]) === 0;
 }
-function calcDropPosition(event, dragNode, targetNode, indent, startMousePosition, allowDrop, flattenedNodes, keyEntities, expandKeys, direction) {
+function calcDropPosition(event, dragNodeProps, targetNodeProps, indent, startMousePosition, allowDrop, flattenedNodes, keyEntities, expandKeys, direction) {
   var _a;
   const { clientX, clientY } = event;
   const { top, height } = event.target.getBoundingClientRect();
   const horizontalMouseOffset = (direction === "rtl" ? -1 : 1) * (((startMousePosition == null ? void 0 : startMousePosition.x) || 0) - clientX);
   const rawDropLevelOffset = (horizontalMouseOffset - 12) / indent;
-  let abstractDropNodeEntity = keyEntities[targetNode.props.eventKey];
+  const filteredExpandKeys = expandKeys.filter((key) => {
+    var _a2, _b;
+    return (_b = (_a2 = keyEntities[key]) == null ? void 0 : _a2.children) == null ? void 0 : _b.length;
+  });
+  let abstractDropNodeEntity = (0, import_keyUtil.default)(keyEntities, targetNodeProps.eventKey);
   if (clientY < top + height / 2) {
     const nodeIndex = flattenedNodes.findIndex((flattenedNode) => flattenedNode.key === abstractDropNodeEntity.key);
     const prevNodeIndex = nodeIndex <= 0 ? 0 : nodeIndex - 1;
     const prevNodeKey = flattenedNodes[prevNodeIndex].key;
-    abstractDropNodeEntity = keyEntities[prevNodeKey];
+    abstractDropNodeEntity = (0, import_keyUtil.default)(keyEntities, prevNodeKey);
   }
   const initialAbstractDropNodeKey = abstractDropNodeEntity.key;
   const abstractDragOverEntity = abstractDropNodeEntity;
   const dragOverNodeKey = abstractDropNodeEntity.key;
   let dropPosition = 0;
   let dropLevelOffset = 0;
-  if (!expandKeys.includes(initialAbstractDropNodeKey)) {
+  if (!filteredExpandKeys.includes(initialAbstractDropNodeKey)) {
     for (let i = 0; i < rawDropLevelOffset; i += 1) {
       if (isLastChild(abstractDropNodeEntity)) {
         abstractDropNodeEntity = abstractDropNodeEntity.parent;
@@ -145,16 +125,16 @@ function calcDropPosition(event, dragNode, targetNode, indent, startMousePositio
       }
     }
   }
-  const abstractDragDataNode = dragNode.props.data;
+  const abstractDragDataNode = dragNodeProps.data;
   const abstractDropDataNode = abstractDropNodeEntity.node;
   let dropAllowed = true;
   if (isFirstChild(abstractDropNodeEntity) && abstractDropNodeEntity.level === 0 && clientY < top + height / 2 && allowDrop({
     dragNode: abstractDragDataNode,
     dropNode: abstractDropDataNode,
     dropPosition: -1
-  }) && abstractDropNodeEntity.key === targetNode.props.eventKey) {
+  }) && abstractDropNodeEntity.key === targetNodeProps.eventKey) {
     dropPosition = -1;
-  } else if ((abstractDragOverEntity.children || []).length && expandKeys.includes(dragOverNodeKey)) {
+  } else if ((abstractDragOverEntity.children || []).length && filteredExpandKeys.includes(dragOverNodeKey)) {
     if (allowDrop({
       dragNode: abstractDragDataNode,
       dropNode: abstractDropDataNode,
@@ -254,7 +234,7 @@ function parseCheckedKeys(keys) {
       halfCheckedKeys: keys.halfChecked || void 0
     };
   } else {
-    (0, import_Util.warning)(false, "`checkedKeys` is not an array or an object");
+    (0, import_warning.default)(false, "`checkedKeys` is not an array or an object");
     return null;
   }
   return keyProps;
@@ -265,7 +245,7 @@ function conductExpandParent(keyList, keyEntities) {
     if (expandedKeys.has(key)) {
       return;
     }
-    const entity = keyEntities[key];
+    const entity = (0, import_keyUtil.default)(keyEntities, key);
     if (!entity) {
       return;
     }
@@ -283,15 +263,6 @@ function conductExpandParent(keyList, keyEntities) {
   });
   return [...expandedKeys];
 }
-function omit(obj, fields) {
-  const clone = { ...obj };
-  if (Array.isArray(fields)) {
-    fields.forEach((key) => {
-      delete clone[key];
-    });
-  }
-  return clone;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   arrAdd,
@@ -305,8 +276,6 @@ function omit(obj, fields) {
   isFirstChild,
   isLastChild,
   isTreeNode,
-  omit,
   parseCheckedKeys,
-  posToArr,
-  toArray
+  posToArr
 });

package/dist/Tree/utils/conductUtil.d.ts

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

package/dist/Tree/utils/conductUtil.js

@@ -1,6 +1,8 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -14,6 +16,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/Tree/utils/conductUtil.ts
@@ -23,7 +33,8 @@ __export(conductUtil_exports, {
   isCheckDisabled: () => isCheckDisabled
 });
 module.exports = __toCommonJS(conductUtil_exports);
-var import_Util = require("../../Util");
+var import_warning = __toESM(require("rc-util/lib/warning"));
+var import_keyUtil = __toESM(require("./keyUtil"));
 function removeFromCheckedKeys(halfCheckedKeys, checkedKeys) {
   const filteredKeys = /* @__PURE__ */ new Set();
   halfCheckedKeys.forEach((key) => {
@@ -150,7 +161,7 @@ function conductCheck(keyList, checked, keyEntities, getCheckDisabled) {
   }
   const keys = new Set(
     keyList.filter((key) => {
-      const hasEntity = !!keyEntities[key];
+      const hasEntity = !!(0, import_keyUtil.default)(keyEntities, key);
       if (!hasEntity) {
         warningMissKeys.push(key);
       }
@@ -170,7 +181,7 @@ function conductCheck(keyList, checked, keyEntities, getCheckDisabled) {
     levelSet.add(entity);
     maxLevel = Math.max(maxLevel, level);
   });
-  (0, import_Util.warning)(
+  (0, import_warning.default)(
     !warningMissKeys.length,
     `Tree missing follow keys: ${warningMissKeys.slice(0, 100).map((key) => `'${key}'`).join(", ")}`
   );

package/dist/Tree/utils/dictUtil.d.ts

@@ -1,8 +1,13 @@
+import { TreeProps } from '../RCTree';
 import { DataNode, Key } from '../typings';
-export declare function calcRangeKeys<T = DataNode>({ treeData, expandedKeys, startKey, endKey }: {
-    treeData: T[];
+type FieldNames = TreeProps['fieldNames'];
+/** 计算选中范围，只考虑expanded情况以优化性能 */
+export declare function calcRangeKeys({ treeData, expandedKeys, startKey, endKey, fieldNames, }: {
+    treeData: DataNode[];
     expandedKeys: Key[];
     startKey?: Key;
     endKey?: Key;
+    fieldNames?: FieldNames;
 }): Key[];
-export declare function convertDirectoryKeysToNodes<T = DataNode>(treeData: T[], keys: Key[]): T[];
+export declare function convertDirectoryKeysToNodes(treeData: DataNode[], keys: Key[], fieldNames?: FieldNames): DataNode[];
+export {};

package/dist/Tree/utils/dictUtil.js

@@ -23,18 +23,30 @@ __export(dictUtil_exports, {
   convertDirectoryKeysToNodes: () => convertDirectoryKeysToNodes
 });
 module.exports = __toCommonJS(dictUtil_exports);
-function traverseNodesKey(treeData, callback) {
+var import_treeUtil = require("./treeUtil");
+var RECORD_NONE = 0;
+var RECORD_START = 1;
+var RECORD_END = 2;
+function traverseNodesKey(treeData, callback, fieldNames) {
+  const { key: fieldKey, children: fieldChildren } = fieldNames;
   function processNode(dataNode) {
-    const { key, children } = dataNode;
+    const key = dataNode[fieldKey];
+    const children = dataNode[fieldChildren];
     if (callback(key, dataNode) !== false) {
-      traverseNodesKey(children || [], callback);
+      traverseNodesKey(children || [], callback, fieldNames);
     }
   }
   treeData.forEach(processNode);
 }
-function calcRangeKeys({ treeData, expandedKeys, startKey, endKey }) {
+function calcRangeKeys({
+  treeData,
+  expandedKeys,
+  startKey,
+  endKey,
+  fieldNames
+}) {
   const keys = [];
-  let record = 0 /* None */;
+  let record = RECORD_NONE;
   if (startKey && startKey === endKey) {
     return [startKey];
   }
@@ -44,39 +56,44 @@ function calcRangeKeys({ treeData, expandedKeys, startKey, endKey }) {
   function matchKey(key) {
     return key === startKey || key === endKey;
   }
-  traverseNodesKey(treeData, (key) => {
-    if (record === 2 /* End */) {
-      return false;
-    }
-    if (matchKey(key)) {
-      keys.push(key);
-      if (record === 0 /* None */) {
-        record = 1 /* Start */;
-      } else if (record === 1 /* Start */) {
-        record = 2 /* End */;
+  traverseNodesKey(
+    treeData,
+    (key) => {
+      if (record === RECORD_END) {
         return false;
       }
-    } else if (record === 1 /* Start */) {
-      keys.push(key);
-    }
-    if (expandedKeys.indexOf(key) === -1) {
-      return false;
-    }
-    return true;
-  });
+      if (matchKey(key)) {
+        keys.push(key);
+        if (record === RECORD_NONE) {
+          record = RECORD_START;
+        } else if (record === RECORD_START) {
+          record = RECORD_END;
+          return false;
+        }
+      } else if (record === RECORD_START) {
+        keys.push(key);
+      }
+      return expandedKeys.includes(key);
+    },
+    (0, import_treeUtil.fillFieldNames)(fieldNames)
+  );
   return keys;
 }
-function convertDirectoryKeysToNodes(treeData, keys) {
+function convertDirectoryKeysToNodes(treeData, keys, fieldNames) {
   const restKeys = [...keys];
   const nodes = [];
-  traverseNodesKey(treeData, (key, node) => {
-    const index = restKeys.indexOf(key);
-    if (index !== -1) {
-      nodes.push(node);
-      restKeys.splice(index, 1);
-    }
-    return !!restKeys.length;
-  });
+  traverseNodesKey(
+    treeData,
+    (key, node) => {
+      const index = restKeys.indexOf(key);
+      if (index !== -1) {
+        nodes.push(node);
+        restKeys.splice(index, 1);
+      }
+      return !!restKeys.length;
+    },
+    (0, import_treeUtil.fillFieldNames)(fieldNames)
+  );
   return nodes;
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/Tree/utils/diffUtil.d.ts

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

package/dist/Tree/utils/keyUtil.d.ts

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

package/dist/{VirtualList/utils/isFirefox.js → Tree/utils/keyUtil.js}

@@ -16,11 +16,12 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/VirtualList/utils/isFirefox.ts
-var isFirefox_exports = {};
-__export(isFirefox_exports, {
-  default: () => isFirefox_default
+// src/Tree/utils/keyUtil.ts
+var keyUtil_exports = {};
+__export(keyUtil_exports, {
+  default: () => getEntity
 });
-module.exports = __toCommonJS(isFirefox_exports);
-var isFF = typeof navigator === "object" && /Firefox/i.test(navigator.userAgent);
-var isFirefox_default = isFF;
+module.exports = __toCommonJS(keyUtil_exports);
+function getEntity(keyEntities, key) {
+  return keyEntities[key];
+}

package/dist/Tree/utils/motion.js

@@ -29,12 +29,13 @@ __export(motion_exports, {
 });
 module.exports = __toCommonJS(motion_exports);
 var import_dom_lib = require("dom-lib");
+var import_prefix = require("../../hooks/prefix");
 var beforeEnter = (el) => {
   el.style.height = "0";
   el.style.opacity = "0";
 };
 var onEnter = (el) => {
-  (0, import_dom_lib.addClass)(el, "r-motion-collapse");
+  (0, import_dom_lib.addClass)(el, `${import_prefix.namespace}-motion-collapse`);
   el.dataset.oldOverflow = el.style.overflow;
   if (el.scrollHeight !== 0) {
     el.style.height = `${el.scrollHeight}px`;
@@ -45,12 +46,12 @@ var onEnter = (el) => {
   el.style.overflow = "hidden";
 };
 var afterEnter = (el) => {
-  (0, import_dom_lib.removeClass)(el, "r-motion-collapse");
+  (0, import_dom_lib.removeClass)(el, `${import_prefix.namespace}-motion-collapse`);
   el.style.height = "";
   el.style.overflow = el.dataset.oldOverflow;
 };
 var beforeLeave = (el) => {
-  (0, import_dom_lib.addClass)(el, "r-motion-collapse");
+  (0, import_dom_lib.addClass)(el, `${import_prefix.namespace}-motion-collapse`);
   if (!el.dataset) {
     el.dataset = {};
   }
@@ -59,13 +60,13 @@ var beforeLeave = (el) => {
   el.style.overflow = "hidden";
 };
 var afterLeave = (el) => {
-  (0, import_dom_lib.removeClass)(el, "r-motion-collapse");
+  (0, import_dom_lib.removeClass)(el, `${import_prefix.namespace}-motion-collapse`);
   el.style.height = "";
   el.style.overflow = el.dataset.oldOverflow;
   el.style.display = "";
 };
 var collapseMotion = {
-  name: "r-treenode-collapse",
+  name: `${import_prefix.namespace}-treenode-collapse`,
   beforeEnter,
   onEnter,
   afterEnter,

package/dist/Tree/utils/pickAttrs.d.ts

@@ -3,4 +3,9 @@ export interface PickConfig {
     data?: boolean;
     attr?: boolean;
 }
+/**
+ * Picker props from exist props with filter
+ * @param props Passed props
+ * @param ariaOnly boolean | { aria?: boolean; data?: boolean; attr?: boolean; } filter config
+ */
 export default function pickAttrs(props: object, ariaOnly?: boolean | PickConfig): {};

package/dist/Tree/utils/treeUtil.d.ts

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