@qsxy/element-plus-react 1.0.0-next.7 → 1.0.1

package/dist/Tree/utils/treeUtil.js

@@ -1,138 +1,144 @@
-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)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  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/treeUtil.ts
-var treeUtil_exports = {};
-__export(treeUtil_exports, {
-  convertDataToEntities: () => convertDataToEntities,
-  convertNodePropsToEventData: () => convertNodePropsToEventData,
-  convertTreeToData: () => convertTreeToData,
-  fillFieldNames: () => fillFieldNames,
-  flattenTreeData: () => flattenTreeData,
-  getKey: () => getKey,
-  getPosition: () => getPosition,
-  getTreeNodeProps: () => getTreeNodeProps,
-  isTreeNode: () => isTreeNode,
-  traverseDataNodes: () => traverseDataNodes,
-  warningWithoutKey: () => warningWithoutKey
-});
-module.exports = __toCommonJS(treeUtil_exports);
-var import_toArray = __toESM(require("rc-util/lib/Children/toArray"));
-var import_omit = __toESM(require("rc-util/lib/omit"));
-var import_warning = __toESM(require("rc-util/lib/warning"));
-var import_keyUtil = __toESM(require("./keyUtil"));
-function getPosition(level, index) {
-  return `${level}-${index}`;
+var _excluded = ["children"];
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import toArray from 'rc-util/lib/Children/toArray';
+import omit from 'rc-util/lib/omit';
+import warning from 'rc-util/lib/warning';
+import getEntity from "./keyUtil";
+export function getPosition(level, index) {
+  return "".concat(level, "-").concat(index);
 }
-function isTreeNode(node) {
+export function isTreeNode(node) {
   return node && node.type && node.type.isTreeNode;
 }
-function getKey(key, pos) {
-  if (key !== null && key !== void 0) {
+export function getKey(key, pos) {
+  if (key !== null && key !== undefined) {
     return key;
   }
   return pos;
 }
-function fillFieldNames(fieldNames) {
-  const { title, _title, key, children } = fieldNames || {};
-  const mergedTitle = title || "title";
+export function fillFieldNames(fieldNames) {
+  var _ref = fieldNames || {},
+    title = _ref.title,
+    _title = _ref._title,
+    key = _ref.key,
+    children = _ref.children;
+  var mergedTitle = title || 'title';
   return {
     title: mergedTitle,
     _title: _title || [mergedTitle],
-    key: key || "key",
-    children: children || "children"
+    key: key || 'key',
+    children: children || 'children'
   };
 }
-function warningWithoutKey(treeData, fieldNames) {
-  const keys = /* @__PURE__ */ new Map();
-  function dig(list, path = "") {
-    (list || []).forEach((treeNode) => {
-      const key = treeNode[fieldNames.key];
-      const children = treeNode[fieldNames.children];
-      (0, import_warning.default)(key !== null && key !== void 0, `Tree node must have a certain key: [${path}${key}]`);
-      const recordKey = String(key);
-      (0, import_warning.default)(!keys.has(recordKey) || key === null || key === void 0, `Same 'key' exist in the Tree: ${recordKey}`);
+
+/**
+ * Warning if TreeNode do not provides key
+ */
+export function warningWithoutKey(treeData, fieldNames) {
+  var keys = new Map();
+  function dig(list) {
+    var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+    (list || []).forEach(function (treeNode) {
+      var key = treeNode[fieldNames.key];
+      var children = treeNode[fieldNames.children];
+      warning(key !== null && key !== undefined, "Tree node must have a certain key: [".concat(path).concat(key, "]"));
+      var recordKey = String(key);
+      warning(!keys.has(recordKey) || key === null || key === undefined, "Same 'key' exist in the Tree: ".concat(recordKey));
       keys.set(recordKey, true);
-      dig(children, `${path}${recordKey} > `);
+      dig(children, "".concat(path).concat(recordKey, " > "));
     });
   }
   dig(treeData);
 }
-function convertTreeToData(rootNodes) {
+
+/**
+ * Convert `children` of Tree into `treeData` structure.
+ */
+export function convertTreeToData(rootNodes) {
   function dig(node) {
-    const treeNodes = (0, import_toArray.default)(node);
-    return treeNodes.map((treeNode) => {
+    var treeNodes = toArray(node);
+    return treeNodes.map(function (treeNode) {
+      // Filter invalidate node
       if (!isTreeNode(treeNode)) {
-        (0, import_warning.default)(!treeNode, "Tree/TreeNode can only accept TreeNode as children.");
+        warning(!treeNode, 'Tree/TreeNode can only accept TreeNode as children.');
         return null;
       }
-      const { key } = treeNode;
-      const { children, ...rest } = treeNode.props;
-      const dataNode = {
-        key,
-        ...rest
-      };
-      const parsedChildren = dig(children);
+      var key = treeNode.key;
+      var _treeNode$props = treeNode.props,
+        children = _treeNode$props.children,
+        rest = _objectWithoutProperties(_treeNode$props, _excluded);
+      var dataNode = _objectSpread({
+        key: key
+      }, rest);
+      var parsedChildren = dig(children);
       if (parsedChildren.length) {
         dataNode.children = parsedChildren;
       }
       return dataNode;
-    }).filter((dataNode) => dataNode);
+    }).filter(function (dataNode) {
+      return dataNode;
+    });
   }
   return dig(rootNodes);
 }
-function flattenTreeData(treeNodeList, expandedKeys, fieldNames) {
-  const { _title: fieldTitles, key: fieldKey, children: fieldChildren } = fillFieldNames(fieldNames);
-  const expandedKeySet = new Set(expandedKeys === true ? [] : expandedKeys);
-  const flattenList = [];
-  function dig(list, parent = null) {
-    return list.map((treeNode, index) => {
-      const pos = getPosition(parent ? parent.pos : "0", index);
-      const mergedKey = getKey(treeNode[fieldKey], pos);
-      let mergedTitle;
-      for (let i = 0; i < fieldTitles.length; i += 1) {
-        const fieldTitle = fieldTitles[i];
-        if (treeNode[fieldTitle] !== void 0) {
+
+/**
+ * Flat nest tree data into flatten list. This is used for virtual list render.
+ * @param treeNodeList Origin data node list
+ * @param expandedKeys
+ * need expanded keys, provides `true` means all expanded (used in `rc-tree-select`).
+ */
+export function flattenTreeData(treeNodeList, expandedKeys, fieldNames) {
+  var _fillFieldNames = fillFieldNames(fieldNames),
+    fieldTitles = _fillFieldNames._title,
+    fieldKey = _fillFieldNames.key,
+    fieldChildren = _fillFieldNames.children;
+  var expandedKeySet = new Set(expandedKeys === true ? [] : expandedKeys);
+  var flattenList = [];
+  function dig(list) {
+    var parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    return list.map(function (treeNode, index) {
+      var pos = getPosition(parent ? parent.pos : '0', index);
+      var mergedKey = getKey(treeNode[fieldKey], pos);
+
+      // Pick matched title in field title list
+      var mergedTitle;
+      for (var i = 0; i < fieldTitles.length; i += 1) {
+        var fieldTitle = fieldTitles[i];
+        if (treeNode[fieldTitle] !== undefined) {
           mergedTitle = treeNode[fieldTitle];
           break;
         }
       }
-      const flattenNode = Object.assign((0, import_omit.default)(treeNode, [...fieldTitles, fieldKey, fieldChildren]), {
+
+      // Add FlattenDataNode into list
+      // We use `Object.assign` here to save perf since babel's `objectSpread` has perf issue
+      var flattenNode = Object.assign(omit(treeNode, [].concat(_toConsumableArray(fieldTitles), [fieldKey, fieldChildren])), {
         title: mergedTitle,
         key: mergedKey,
-        parent,
-        pos,
+        parent: parent,
+        pos: pos,
         children: null,
         data: treeNode,
-        isStart: [...parent ? parent.isStart : [], index === 0],
-        isEnd: [...parent ? parent.isEnd : [], index === list.length - 1]
+        isStart: [].concat(_toConsumableArray(parent ? parent.isStart : []), [index === 0]),
+        isEnd: [].concat(_toConsumableArray(parent ? parent.isEnd : []), [index === list.length - 1])
       });
       flattenList.push(flattenNode);
+
+      // Loop treeNode children
       if (expandedKeys === true || expandedKeySet.has(mergedKey)) {
         flattenNode.children = dig(treeNode[fieldChildren] || [], flattenNode);
       } else {
@@ -144,106 +150,163 @@ function flattenTreeData(treeNodeList, expandedKeys, fieldNames) {
   dig(treeNodeList);
   return flattenList;
 }
-function traverseDataNodes(dataNodes, callback, config) {
-  let mergedConfig = {};
-  if (typeof config === "object") {
+/**
+ * Traverse all the data by `treeData`.
+ * Please not use it out of the `rc-tree` since we may refactor this code.
+ */
+export function traverseDataNodes(dataNodes, callback,
+// To avoid too many params, let use config instead of origin param
+config) {
+  var mergedConfig = {};
+  if (_typeof(config) === 'object') {
     mergedConfig = config;
   } else {
-    mergedConfig = { externalGetKey: config };
+    mergedConfig = {
+      externalGetKey: config
+    };
   }
   mergedConfig = mergedConfig || {};
-  const { childrenPropName, externalGetKey, fieldNames } = mergedConfig;
-  const { key: fieldKey, children: fieldChildren } = fillFieldNames(fieldNames);
-  const mergeChildrenPropName = childrenPropName || fieldChildren;
-  let syntheticGetKey;
+
+  // Init config
+  var _mergedConfig = mergedConfig,
+    childrenPropName = _mergedConfig.childrenPropName,
+    externalGetKey = _mergedConfig.externalGetKey,
+    fieldNames = _mergedConfig.fieldNames;
+  var _fillFieldNames2 = fillFieldNames(fieldNames),
+    fieldKey = _fillFieldNames2.key,
+    fieldChildren = _fillFieldNames2.children;
+  var mergeChildrenPropName = childrenPropName || fieldChildren;
+
+  // Get keys
+  var syntheticGetKey;
   if (externalGetKey) {
-    if (typeof externalGetKey === "string") {
-      syntheticGetKey = (node) => node[externalGetKey];
-    } else if (typeof externalGetKey === "function") {
-      syntheticGetKey = (node) => externalGetKey(node);
+    if (typeof externalGetKey === 'string') {
+      syntheticGetKey = function syntheticGetKey(node) {
+        return node[externalGetKey];
+      };
+    } else if (typeof externalGetKey === 'function') {
+      syntheticGetKey = function syntheticGetKey(node) {
+        return externalGetKey(node);
+      };
     }
   } else {
-    syntheticGetKey = (node, pos) => getKey(node[fieldKey], pos);
+    syntheticGetKey = function syntheticGetKey(node, pos) {
+      return getKey(node[fieldKey], pos);
+    };
   }
+
+  // Process
   function processNode(node, index, parent, pathNodes) {
-    const children = node ? node[mergeChildrenPropName] : dataNodes;
-    const pos = node ? getPosition(parent.pos, index) : "0";
-    const connectNodes = node ? [...pathNodes, node] : [];
+    var children = node ? node[mergeChildrenPropName] : dataNodes;
+    var pos = node ? getPosition(parent.pos, index) : '0';
+    var connectNodes = node ? [].concat(_toConsumableArray(pathNodes), [node]) : [];
+
+    // Process node if is not root
     if (node) {
-      const key = syntheticGetKey(node, pos);
-      const data = {
-        node,
-        index,
-        pos,
-        key,
+      var key = syntheticGetKey(node, pos);
+      var _data = {
+        node: node,
+        index: index,
+        pos: pos,
+        key: key,
         parentPos: parent.node ? parent.pos : null,
         level: parent.level + 1,
         nodes: connectNodes
       };
-      callback(data);
+      callback(_data);
     }
+
+    // Process children node
     if (children) {
-      children.forEach((subNode, subIndex) => {
-        processNode(
-          subNode,
-          subIndex,
-          {
-            node,
-            pos,
-            level: parent ? parent.level + 1 : -1
-          },
-          connectNodes
-        );
+      children.forEach(function (subNode, subIndex) {
+        processNode(subNode, subIndex, {
+          node: node,
+          pos: pos,
+          level: parent ? parent.level + 1 : -1
+        }, connectNodes);
       });
     }
   }
   processNode(null);
 }
-function convertDataToEntities(dataNodes, {
-  initWrapper,
-  processEntity,
-  onProcessFinished,
-  externalGetKey,
-  childrenPropName,
-  fieldNames
-} = {}, legacyExternalGetKey) {
-  const mergedExternalGetKey = externalGetKey || legacyExternalGetKey;
-  const posEntities = {};
-  const keyEntities = {};
-  let wrapper = {
-    posEntities,
-    keyEntities
+/**
+ * Convert `treeData` into entity records.
+ */
+export function convertDataToEntities(dataNodes) {
+  var _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    initWrapper = _ref2.initWrapper,
+    processEntity = _ref2.processEntity,
+    onProcessFinished = _ref2.onProcessFinished,
+    externalGetKey = _ref2.externalGetKey,
+    childrenPropName = _ref2.childrenPropName,
+    fieldNames = _ref2.fieldNames;
+  var /** @deprecated Use `config.externalGetKey` instead */
+  legacyExternalGetKey = arguments.length > 2 ? arguments[2] : undefined;
+  // Init config
+  var mergedExternalGetKey = externalGetKey || legacyExternalGetKey;
+  var posEntities = {};
+  var keyEntities = {};
+  var wrapper = {
+    posEntities: posEntities,
+    keyEntities: keyEntities
   };
   if (initWrapper) {
     wrapper = initWrapper(wrapper) || wrapper;
   }
-  traverseDataNodes(
-    dataNodes,
-    (item) => {
-      const { node, index, pos, key, parentPos, level, nodes } = item;
-      const entity = { node, nodes, index, key, pos, level };
-      const mergedKey = getKey(key, pos);
-      posEntities[pos] = entity;
-      keyEntities[mergedKey] = entity;
-      entity.parent = posEntities[parentPos];
-      if (entity.parent) {
-        entity.parent.children = entity.parent.children || [];
-        entity.parent.children.push(entity);
-      }
-      if (processEntity) {
-        processEntity(entity, wrapper);
-      }
-    },
-    { externalGetKey: mergedExternalGetKey, childrenPropName, fieldNames }
-  );
+  traverseDataNodes(dataNodes, function (item) {
+    var node = item.node,
+      index = item.index,
+      pos = item.pos,
+      key = item.key,
+      parentPos = item.parentPos,
+      level = item.level,
+      nodes = item.nodes;
+    var entity = {
+      node: node,
+      nodes: nodes,
+      index: index,
+      key: key,
+      pos: pos,
+      level: level
+    };
+    var mergedKey = getKey(key, pos);
+    posEntities[pos] = entity;
+    keyEntities[mergedKey] = entity;
+
+    // Fill children
+    entity.parent = posEntities[parentPos];
+    if (entity.parent) {
+      entity.parent.children = entity.parent.children || [];
+      entity.parent.children.push(entity);
+    }
+    if (processEntity) {
+      processEntity(entity, wrapper);
+    }
+  }, {
+    externalGetKey: mergedExternalGetKey,
+    childrenPropName: childrenPropName,
+    fieldNames: fieldNames
+  });
   if (onProcessFinished) {
     onProcessFinished(wrapper);
   }
   return wrapper;
 }
-function getTreeNodeProps(key, { expandedKeys, selectedKeys, loadedKeys, loadingKeys, checkedKeys, halfCheckedKeys, dragOverNodeKey, dropPosition, keyEntities }) {
-  const entity = (0, import_keyUtil.default)(keyEntities, key);
-  const treeNodeProps = {
+/**
+ * Get TreeNode props with Tree props.
+ */
+export function getTreeNodeProps(key, _ref3) {
+  var expandedKeys = _ref3.expandedKeys,
+    selectedKeys = _ref3.selectedKeys,
+    loadedKeys = _ref3.loadedKeys,
+    loadingKeys = _ref3.loadingKeys,
+    checkedKeys = _ref3.checkedKeys,
+    halfCheckedKeys = _ref3.halfCheckedKeys,
+    dragOverNodeKey = _ref3.dragOverNodeKey,
+    dropPosition = _ref3.dropPosition,
+    keyEntities = _ref3.keyEntities;
+  var entity = getEntity(keyEntities, key);
+  var treeNodeProps = {
     eventKey: key,
     expanded: expandedKeys.indexOf(key) !== -1,
     selected: selectedKeys.indexOf(key) !== -1,
@@ -251,7 +314,7 @@ function getTreeNodeProps(key, { expandedKeys, selectedKeys, loadedKeys, loading
     loading: loadingKeys.indexOf(key) !== -1,
     checked: checkedKeys.indexOf(key) !== -1,
     halfChecked: halfCheckedKeys.indexOf(key) !== -1,
-    pos: String(entity ? entity.pos : ""),
+    pos: String(entity ? entity.pos : ''),
     // [Legacy] Drag props
     // Since the interaction of drag is changed, the semantic of the props are
     // not accuracy, I think it should be finally removed
@@ -261,44 +324,41 @@ function getTreeNodeProps(key, { expandedKeys, selectedKeys, loadedKeys, loading
   };
   return treeNodeProps;
 }
-function convertNodePropsToEventData(props) {
-  const { data, expanded, selected, checked, loaded, loading, halfChecked, dragOver, dragOverGapTop, dragOverGapBottom, pos, active, eventKey } = props;
-  const eventData = {
-    ...data,
-    expanded,
-    selected,
-    checked,
-    loaded,
-    loading,
-    halfChecked,
-    dragOver,
-    dragOverGapTop,
-    dragOverGapBottom,
-    pos,
-    active,
+export function convertNodePropsToEventData(props) {
+  var data = props.data,
+    expanded = props.expanded,
+    selected = props.selected,
+    checked = props.checked,
+    loaded = props.loaded,
+    loading = props.loading,
+    halfChecked = props.halfChecked,
+    dragOver = props.dragOver,
+    dragOverGapTop = props.dragOverGapTop,
+    dragOverGapBottom = props.dragOverGapBottom,
+    pos = props.pos,
+    active = props.active,
+    eventKey = props.eventKey;
+  var eventData = _objectSpread(_objectSpread({}, data), {}, {
+    expanded: expanded,
+    selected: selected,
+    checked: checked,
+    loaded: loaded,
+    loading: loading,
+    halfChecked: halfChecked,
+    dragOver: dragOver,
+    dragOverGapTop: dragOverGapTop,
+    dragOverGapBottom: dragOverGapBottom,
+    pos: pos,
+    active: active,
     key: eventKey
-  };
-  if (!("props" in eventData)) {
-    Object.defineProperty(eventData, "props", {
-      get() {
-        (0, import_warning.default)(false, "Second param return from event is node data instead of TreeNode instance. Please read value directly instead of reading from `props`.");
+  });
+  if (!('props' in eventData)) {
+    Object.defineProperty(eventData, 'props', {
+      get: function get() {
+        warning(false, 'Second param return from event is node data instead of TreeNode instance. Please read value directly instead of reading from `props`.');
         return props;
       }
     });
   }
   return eventData;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  convertDataToEntities,
-  convertNodePropsToEventData,
-  convertTreeToData,
-  fillFieldNames,
-  flattenTreeData,
-  getKey,
-  getPosition,
-  getTreeNodeProps,
-  isTreeNode,
-  traverseDataNodes,
-  warningWithoutKey
-});
+}

package/dist/TreeSelect/TreeSelect.d.ts

@@ -1,6 +1,6 @@
 import React, { RefObject } from 'react';
 import { TreeSelectProps, TreeSelectRef } from './typings';
-declare const ForwardTreeSelect: <RecordType extends object = any>(props: TreeSelectProps<RecordType, string | number | readonly string[]> & {
+declare const ForwardTreeSelect: <RecordType extends object = any>(props: TreeSelectProps<RecordType> & {
     ref?: RefObject<TreeSelectRef>;
 }) => React.ReactElement;
 type InternalDirectoryTreeType = typeof ForwardTreeSelect;