rsuite 5.60.2 → 5.61.0

package/cjs/Tree/hooks/useTreeNodeProps.js

@@ -0,0 +1,83 @@
+'use client';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+exports.__esModule = true;
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _utils = require("../../utils");
+var _hooks = require("../../internals/Picker/hooks");
+var _TreeProvider = require("../TreeProvider");
+var _Highlight = _interopRequireDefault(require("../../Highlight"));
+function useTreeNodeProps(props) {
+  var _useItemDataKeys = (0, _TreeProvider.useItemDataKeys)(),
+    valueKey = _useItemDataKeys.valueKey,
+    labelKey = _useItemDataKeys.labelKey,
+    childrenKey = _useItemDataKeys.childrenKey;
+  var _useCombobox = (0, _hooks.useCombobox)(),
+    id = _useCombobox.id;
+  var value = props.value,
+    disabledItemValues = props.disabledItemValues,
+    loadingNodeValues = props.loadingNodeValues,
+    focusItemValue = props.focusItemValue,
+    keyword = props.keyword,
+    dragNode = props.dragNode,
+    dragOverNodeKey = props.dragOverNodeKey,
+    dropNodePosition = props.dropNodePosition;
+  return (0, _react.useCallback)(function (nodeData, layer, index) {
+    var DRAG_OVER = _utils.TREE_NODE_DROP_POSITION.DRAG_OVER,
+      DRAG_OVER_TOP = _utils.TREE_NODE_DROP_POSITION.DRAG_OVER_TOP,
+      DRAG_OVER_BOTTOM = _utils.TREE_NODE_DROP_POSITION.DRAG_OVER_BOTTOM;
+    var visible = nodeData.visible;
+    var draggingNode = dragNode !== null && dragNode !== void 0 ? dragNode : {};
+    var nodeValue = nodeData[valueKey];
+    var nodeLabel = nodeData[labelKey];
+    var children = nodeData[childrenKey];
+    var label = keyword ? /*#__PURE__*/_react.default.createElement(_Highlight.default, {
+      as: "span",
+      query: keyword
+    }, nodeLabel) : nodeLabel;
+    var dragging = (0, _utils.shallowEqual)(nodeValue, draggingNode[valueKey]);
+    var dragStatus;
+    if ((0, _utils.shallowEqual)(nodeValue, dragOverNodeKey)) {
+      switch (dropNodePosition) {
+        case DRAG_OVER:
+          dragStatus = 'drag-over';
+          break;
+        case DRAG_OVER_TOP:
+          dragStatus = 'drag-over-top';
+          break;
+        case DRAG_OVER_BOTTOM:
+          dragStatus = 'drag-over-bottom';
+          break;
+      }
+    }
+    var disabled = disabledItemValues.some(function (disabledItem) {
+      return (0, _utils.shallowEqual)(disabledItem, nodeValue);
+    });
+    var loading = loadingNodeValues.some(function (item) {
+      return (0, _utils.shallowEqual)(item, nodeValue);
+    });
+    var active = (0, _utils.shallowEqual)(nodeValue, value);
+    var focus = (0, _utils.shallowEqual)(nodeValue, focusItemValue);
+    return {
+      id: id ? id + "-opt-" + nodeValue : undefined,
+      value: nodeValue,
+      label: label,
+      index: index,
+      layer: layer,
+      loading: loading,
+      active: active,
+      focus: focus,
+      visible: visible,
+      children: children,
+      nodeData: nodeData,
+      disabled: disabled,
+      dragging: dragging,
+      dragStatus: dragStatus
+    };
+  }, [childrenKey, disabledItemValues, dragNode, dragOverNodeKey, dropNodePosition, focusItemValue, id, keyword, labelKey, loadingNodeValues, value, valueKey]);
+}
+var _default = useTreeNodeProps;
+exports.default = _default;

package/cjs/Tree/hooks/useTreeNodeRefs.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Custom hook that manages references to tree nodes. */
+export default function useTreeNodeRefs(): {
+    treeNodesRefs: {};
+    saveTreeNodeRef: (ref: React.Ref<any>, refKey?: string) => void;
+};

package/cjs/Tree/hooks/useTreeNodeRefs.js

@@ -0,0 +1,22 @@
+'use client';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.default = useTreeNodeRefs;
+var _react = require("react");
+var _isNil = _interopRequireDefault(require("lodash/isNil"));
+/**
+ * Custom hook that manages references to tree nodes. */
+function useTreeNodeRefs() {
+  var treeNodeRefs = (0, _react.useRef)({});
+  var saveTreeNodeRef = function saveTreeNodeRef(ref, refKey) {
+    if (!(0, _isNil.default)(refKey)) {
+      treeNodeRefs.current[refKey] = ref;
+    }
+  };
+  return {
+    treeNodesRefs: treeNodeRefs.current,
+    saveTreeNodeRef: saveTreeNodeRef
+  };
+}

package/cjs/Tree/hooks/useTreeSearch.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+interface TreeSearchProps<T> {
+    searchKeyword?: string;
+    data: T[];
+    searchBy?: (keyword: any, label: any, item: any) => boolean;
+    callback?: (keyword: string, data: T[], event: React.SyntheticEvent) => void;
+}
+/**
+ * Custom hook for searching and filtering data in a tree structure.
+ */
+export default function useTreeSearch<T>(props: TreeSearchProps<T>): {
+    keyword: string;
+    filteredData: T[];
+    setFilteredData: (data: T[], searchKeyword: string) => void;
+    setSearchKeyword: React.Dispatch<React.SetStateAction<string>>;
+    handleSearch: (searchKeyword: string, event?: React.ChangeEvent) => void;
+};
+export {};

package/cjs/Tree/hooks/useTreeSearch.js

@@ -0,0 +1,74 @@
+'use client';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.default = useTreeSearch;
+var _react = require("react");
+var _isArray = _interopRequireDefault(require("lodash/isArray"));
+var _Picker = require("../../internals/Picker");
+var _TreeProvider = require("../TreeProvider");
+/**
+ * Custom hook for searching and filtering data in a tree structure.
+ */
+function useTreeSearch(props) {
+  var _useItemDataKeys = (0, _TreeProvider.useItemDataKeys)(),
+    labelKey = _useItemDataKeys.labelKey,
+    childrenKey = _useItemDataKeys.childrenKey;
+  var searchKeyword = props.searchKeyword,
+    data = props.data,
+    searchBy = props.searchBy,
+    callback = props.callback;
+  var filterVisibleData = (0, _react.useCallback)(function (data, searchKeyword) {
+    var setVisible = function setVisible(nodes) {
+      return nodes.forEach(function (item) {
+        item.visible = searchBy ? searchBy(searchKeyword, item[labelKey], item) : (0, _Picker.shouldDisplay)(item[labelKey], searchKeyword);
+        if ((0, _isArray.default)(item[childrenKey])) {
+          filterVisibleData(item[childrenKey], searchKeyword);
+          item[childrenKey].forEach(function (child) {
+            if (child.visible) {
+              item.visible = child.visible;
+            }
+          });
+        }
+      });
+    };
+    setVisible(data);
+    return data;
+  }, [childrenKey, labelKey, searchBy]);
+
+  // Use search keywords to filter options.
+  var _useState = (0, _react.useState)(searchKeyword !== null && searchKeyword !== void 0 ? searchKeyword : ''),
+    keyword = _useState[0],
+    setSearchKeyword = _useState[1];
+  var _useState2 = (0, _react.useState)(function () {
+      return filterVisibleData(data, keyword);
+    }),
+    filteredData = _useState2[0],
+    setFilteredData = _useState2[1];
+  var handleSearch = function handleSearch(searchKeyword, event) {
+    var filteredData = filterVisibleData(data, searchKeyword);
+    setFilteredData(filteredData);
+    setSearchKeyword(searchKeyword);
+    if (event) {
+      callback === null || callback === void 0 ? void 0 : callback(searchKeyword, filteredData, event);
+    }
+  };
+  (0, _react.useEffect)(function () {
+    handleSearch(searchKeyword !== null && searchKeyword !== void 0 ? searchKeyword : '');
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [searchKeyword]);
+  (0, _react.useEffect)(function () {
+    setSearchKeyword(searchKeyword !== null && searchKeyword !== void 0 ? searchKeyword : '');
+  }, [searchKeyword, setSearchKeyword]);
+  var setVisibleData = (0, _react.useCallback)(function (data, searchKeyword) {
+    setFilteredData(filterVisibleData(data, searchKeyword));
+  }, [filterVisibleData]);
+  return {
+    keyword: keyword,
+    filteredData: filteredData,
+    setFilteredData: setVisibleData,
+    setSearchKeyword: setSearchKeyword,
+    handleSearch: handleSearch
+  };
+}

package/cjs/Tree/hooks/useTreeWithChildren.d.ts

@@ -0,0 +1,14 @@
+import { TreeNode } from '../types';
+interface UseTreeWithChildrenOptions {
+    valueKey: string;
+    childrenKey: string;
+}
+/**
+ * Custom hook that provides functionality for managing a tree structure with children.
+ */
+export default function useTreeWithChildren<T extends TreeNode>(data: T[], options: UseTreeWithChildrenOptions): {
+    treeData: T[];
+    loadingNodeValues: never[];
+    appendChild: (node: any, getChildren: any) => void;
+};
+export {};

package/cjs/Tree/hooks/useTreeWithChildren.js

@@ -0,0 +1,64 @@
+'use client';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.default = useTreeWithChildren;
+var _react = require("react");
+var _shallowEqual = _interopRequireDefault(require("../../utils/shallowEqual"));
+var _utils = require("../../internals/Tree/utils");
+/**
+ * Custom hook that provides functionality for managing a tree structure with children.
+ */
+function useTreeWithChildren(data, options) {
+  var valueKey = options.valueKey,
+    childrenKey = options.childrenKey;
+  var _useState = (0, _react.useState)([]),
+    loadingNodeValues = _useState[0],
+    setLoadingNodeValues = _useState[1];
+  var _useState2 = (0, _react.useState)(data),
+    treeData = _useState2[0],
+    setTreeData = _useState2[1];
+  (0, _react.useEffect)(function () {
+    setTreeData(data);
+  }, [data]);
+  var concatChildren = (0, _react.useCallback)(function (treeNode, children) {
+    var value = treeNode[valueKey];
+    treeNode = (0, _utils.findNodeOfTree)(data, function (item) {
+      return value === item[valueKey];
+    });
+    treeNode[childrenKey] = children;
+    var newData = data.concat([]);
+    setTreeData(newData);
+    return newData;
+  }, [data, valueKey, childrenKey]);
+  var appendChild = (0, _react.useCallback)(function (node, getChildren) {
+    setLoadingNodeValues(function (prev) {
+      return prev.concat(node[valueKey]);
+    });
+    var children = getChildren(node);
+    if (children instanceof Promise) {
+      children.then(function (res) {
+        var newData = concatChildren(node, res);
+        setTreeData(newData);
+        setLoadingNodeValues(function (prev) {
+          return prev.filter(function (item) {
+            return !(0, _shallowEqual.default)(item, node[valueKey]);
+          });
+        });
+      });
+    } else {
+      setTreeData(concatChildren(node, children));
+      setLoadingNodeValues(function (prev) {
+        return prev.filter(function (item) {
+          return !(0, _shallowEqual.default)(item, node[valueKey]);
+        });
+      });
+    }
+  }, [concatChildren, valueKey]);
+  return {
+    treeData: treeData,
+    loadingNodeValues: loadingNodeValues,
+    appendChild: appendChild
+  };
+}

package/cjs/Tree/hooks/useVirtualizedTreeData.d.ts

@@ -0,0 +1,7 @@
+import type { TreeNode, TreeNodeMap } from '../types';
+declare function useVirtualizedTreeData(nodes: TreeNodeMap, data: TreeNode[], options: {
+    expandItemValues: (string | number)[];
+    cascade?: boolean;
+    searchKeyword?: string;
+}): () => TreeNode[];
+export default useVirtualizedTreeData;

package/cjs/Tree/hooks/useVirtualizedTreeData.js

@@ -0,0 +1,82 @@
+'use client';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.default = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _react = require("react");
+var _intersection = _interopRequireDefault(require("lodash/intersection"));
+var _isUndefined = _interopRequireDefault(require("lodash/isUndefined"));
+var _getNodeParentKeys = require("../utils/getNodeParentKeys");
+var _isSearching = require("../utils/isSearching");
+var _flattenTree = require("../utils/flattenTree");
+var _utils = require("../../CheckTree/utils");
+var _TreeProvider = require("../TreeProvider");
+/**
+ * Determines whether a node should be shown based on the expanded state of its parent nodes.
+ */
+function shouldShowNodeByParentExpanded(expandItemValues, parentKeys) {
+  if (expandItemValues === void 0) {
+    expandItemValues = [];
+  }
+  if (parentKeys === void 0) {
+    parentKeys = [];
+  }
+  var intersectionKeys = (0, _intersection.default)(expandItemValues, parentKeys);
+  if (intersectionKeys.length === parentKeys.length) {
+    return true;
+  }
+  return false;
+}
+function useVirtualizedTreeData(nodes, data, options) {
+  var _useItemDataKeys = (0, _TreeProvider.useItemDataKeys)(),
+    childrenKey = _useItemDataKeys.childrenKey,
+    valueKey = _useItemDataKeys.valueKey;
+  /**
+   * Formats the virtualized tree data.
+   */
+  return (0, _react.useCallback)(function () {
+    var cascade = options.cascade,
+      searchKeyword = options.searchKeyword,
+      expandItemValues = options.expandItemValues;
+    return (0, _flattenTree.UNSAFE_flattenTree)(data, childrenKey, function (node) {
+      var formatted = {};
+      var curNode = nodes === null || nodes === void 0 ? void 0 : nodes[node.refKey];
+      var parentKeys = (0, _getNodeParentKeys.getNodeParentKeys)(nodes, curNode, valueKey);
+      /**
+       * When using virtualized,
+       * if the parent node is collapsed, the child nodes should be hidden
+       * avoid component height calculation errors
+       */
+      var visible = curNode !== null && curNode !== void 0 && curNode.parent ? shouldShowNodeByParentExpanded(expandItemValues, parentKeys) : true;
+
+      /**
+       * when searching, every node default expand
+       * the node's visible should follow the original state
+       */
+      if ((0, _isSearching.isSearching)(searchKeyword)) {
+        visible = node.visible;
+      }
+      if (curNode) {
+        var checkState = !(0, _isUndefined.default)(cascade) ? (0, _utils.getNodeCheckState)(curNode, {
+          cascade: cascade,
+          nodes: nodes,
+          childrenKey: childrenKey
+        }) : undefined;
+        formatted = (0, _extends2.default)({}, node, {
+          check: curNode.check,
+          uncheckable: curNode.uncheckable,
+          hasChildren: !!node[childrenKey],
+          layer: curNode.layer,
+          parent: curNode.parent,
+          checkState: checkState,
+          visible: visible
+        });
+      }
+      return formatted;
+    });
+  }, [childrenKey, data, nodes, options, valueKey]);
+}
+var _default = useVirtualizedTreeData;
+exports.default = _default;

package/cjs/Tree/types.d.ts

@@ -0,0 +1,257 @@
+/// <reference types="react" />
+import type { CheckStateType } from '../utils/constants';
+import type { StandardProps } from '../@types/common';
+import type { ListProps } from '../internals/Windowing';
+/**
+ * Represents a single node in a tree.
+ */
+export interface TreeNode extends Record<string, any> {
+    /**
+     * Specifies whether the node is uncheckable.
+     */
+    uncheckable?: boolean;
+    /**
+     * The reference key of the node.
+     */
+    refKey?: string;
+    /**
+     * Specifies whether the node is checked.
+     */
+    check?: boolean;
+    /**
+     * The parent node of the current node.
+     */
+    parent?: TreeNode;
+    /**
+     * Specifies whether all child nodes are checked.
+     */
+    checkAll?: boolean;
+    /**
+     * Specifies whether the node is visible.
+     */
+    visible?: boolean;
+    /**
+     * Specifies whether the node is expanded.
+     */
+    expand?: boolean;
+    /**
+     * The layer of the node in the tree hierarchy.
+     */
+    layer?: number;
+    /**
+     * The label of the node.
+     */
+    label?: string | React.ReactNode;
+    /**
+     * The value of the node.
+     */
+    value?: string | number;
+    /**
+     * The property to group nodes by.
+     */
+    groupBy?: string;
+    /**
+     * The child nodes of the current node.
+     */
+    children?: TreeNode[];
+    /**
+     * Specifies whether the node has children.
+     */
+    hasChildren?: boolean;
+    /**
+     * The check state of the node.
+     */
+    checkState?: CheckStateType;
+}
+/**
+ * Represents a map of tree nodes.
+ */
+export interface TreeNodeMap {
+    [key: string]: TreeNode;
+}
+/**
+ * Tree Node Drag Type
+ */
+export declare enum TREE_NODE_DROP_POSITION {
+    DRAG_OVER = 0,
+    DRAG_OVER_TOP = 1,
+    DRAG_OVER_BOTTOM = 2
+}
+export interface DropData<T> {
+    /** drag node data */
+    dragNode: T;
+    /** dropNode data */
+    dropNode: T;
+    /** node drop position */
+    dropNodePosition: TREE_NODE_DROP_POSITION;
+    /** Update Data when drop node */
+    createUpdateDataFunction: (data: T[]) => T[];
+}
+/**
+ * Represents the drag-related props for the Tree component.
+ */
+export interface TreeDragProps<T = Record<string, any>> {
+    /**
+     * Specifies whether the node can be dragged.
+     */
+    draggable?: boolean;
+    /**
+     * Called when scrolling.
+     * @param event - The scroll event.
+     */
+    onScroll?: (event: React.SyntheticEvent) => void;
+    /**
+     * Called when the node drag starts.
+     * @param nodeData - The data associated with the dragged node.
+     * @param e - The drag event.
+     */
+    onDragStart?: (nodeData: T, e: React.DragEvent) => void;
+    /**
+     * Called when the node is dragged over.
+     * @param nodeData - The data associated with the dragged node.
+     * @param e - The drag event.
+     */
+    onDragEnter?: (nodeData: T, e: React.DragEvent) => void;
+    /**
+     * Called when the node is dragged over.
+     * @param nodeData - The data associated with the dragged node.
+     * @param e - The drag event.
+     */
+    onDragOver?: (nodeData: T, e: React.DragEvent) => void;
+    /**
+     * Called when the node is dragged out.
+     * @param nodeData - The data associated with the dragged node.
+     * @param e - The drag event.
+     */
+    onDragLeave?: (nodeData: T, e: React.DragEvent) => void;
+    /**
+     * Called when the node drag ends.
+     * @param nodeData - The data associated with the dragged node.
+     * @param e - The drag event.
+     */
+    onDragEnd?: (nodeData: T, e: React.DragEvent) => void;
+    /**
+     * Called when a node is dropped.
+     * @param dropData - The data associated with the dropped node.
+     * @param e - The drag event.
+     */
+    onDrop?: (dropData: DropData<T>, e: React.DragEvent) => void;
+}
+/**
+ * Represents the base props for the Tree component.
+ *
+ * @template V - The type of the value associated with each tree node.
+ * @template T - The type of the tree node.
+ */
+/**
+ * Represents the props for the Tree component.
+ */
+export interface TreeViewBaseProps<V = string | number, T = TreeNode> extends StandardProps {
+    /**
+     * The height of the tree.
+     */
+    height?: number;
+    /**
+     * Whether to display the search input box.
+     */
+    searchable?: boolean;
+    /**
+     * Whether to display an auxiliary line when the tree node is indented.
+     */
+    showIndentLine?: boolean;
+    /**
+     * Whether to use virtualized list.
+     */
+    virtualized?: boolean;
+    /**
+     * Props for the virtualized list.
+     */
+    listProps?: Partial<ListProps>;
+    /**
+     * The search keyword (controlled).
+     */
+    searchKeyword?: string;
+    /**
+     * The option values for the expand nodes with controlled.
+     */
+    expandItemValues?: any[];
+    /**
+     * Callback function for expanding tree nodes.
+     * @param expandItemValues - The values of the expanded nodes.
+     * @param activeNode - The currently active node.
+     * @param concat - A function to concatenate data and children.
+     */
+    onExpand?: (expandItemValues: T[], activeNode: T, concat: (data: T[], children: T[]) => T[]) => void;
+    /**
+     * Callback function after selecting a tree node.
+     * @param activeNode - The currently active node.
+     * @param value - The value of the selected node.
+     * @param event - The event object.
+     */
+    onSelect?: (activeNode: T, value: V, event: React.SyntheticEvent) => void;
+    /**
+     * Callback when a tree item is clicked.
+     * @param item - The clicked tree item.
+     * @param path - The path of the clicked item.
+     */
+    onSelectItem?: (item: T, path: T[]) => void;
+    /**
+     * Callback fired when searching.
+     * @param searchKeyword - The search keyword.
+     * @param event - The event object.
+     */
+    onSearch?: (searchKeyword: string, event: React.SyntheticEvent) => void;
+    /**
+     * Callback fired when cleaning.
+     * @param event - The event object.
+     */
+    onClean?: (event: React.SyntheticEvent) => void;
+    /**
+     * Custom search rules.
+     * @param keyword - The search keyword.
+     * @param label - The label of the tree item.
+     * @param item - The tree item.
+     * @returns Whether the item matches the search criteria.
+     */
+    searchBy?: (keyword: string, label: React.ReactNode, item: any) => boolean;
+    /**
+     * Callback function called after the value has been changed.
+     * @param value - The new value.
+     * @param event - The event object.
+     */
+    onChange?: (value: V, event: React.SyntheticEvent) => void;
+}
+export interface TreeExtraProps<T = TreeNode> {
+    /**
+     * Whether to expand all nodes by default.
+     */
+    defaultExpandAll?: boolean;
+    /**
+     * The option values for the expand nodes by default.
+     */
+    defaultExpandItemValues?: any[];
+    /**
+     * Function to load node children data asynchronously.
+     * @param activeNode - The currently active node.
+     * @returns The children of the active node.
+     */
+    getChildren?: (activeNode: T) => T[] | Promise<T[]>;
+    /**
+     * Custom render function for the tree.
+     * @param menu - The menu to be rendered.
+     * @returns The rendered tree.
+     */
+    renderTree?: (menu: React.ReactNode) => React.ReactNode;
+    /**
+     * Custom render function for tree nodes.
+     * @param nodeData - The data of the tree node.
+     * @returns The rendered node.
+     */
+    renderTreeNode?: (nodeData: T) => React.ReactNode;
+    /**
+     * Custom render function for tree icons.
+     * @param nodeData - The data of the tree node.
+     * @returns The rendered icon.
+     */
+    renderTreeIcon?: (nodeData: T, expanded?: boolean) => React.ReactNode;
+}

package/cjs/Tree/types.js

@@ -0,0 +1,33 @@
+'use client';
+"use strict";
+
+exports.__esModule = true;
+exports.TREE_NODE_DROP_POSITION = void 0;
+/**
+ * Represents a single node in a tree.
+ */
+/**
+ * Represents a map of tree nodes.
+ */
+/**
+ * Tree Node Drag Type
+ */
+var TREE_NODE_DROP_POSITION;
+exports.TREE_NODE_DROP_POSITION = TREE_NODE_DROP_POSITION;
+(function (TREE_NODE_DROP_POSITION) {
+  TREE_NODE_DROP_POSITION[TREE_NODE_DROP_POSITION["DRAG_OVER"] = 0] = "DRAG_OVER";
+  TREE_NODE_DROP_POSITION[TREE_NODE_DROP_POSITION["DRAG_OVER_TOP"] = 1] = "DRAG_OVER_TOP";
+  TREE_NODE_DROP_POSITION[TREE_NODE_DROP_POSITION["DRAG_OVER_BOTTOM"] = 2] = "DRAG_OVER_BOTTOM";
+})(TREE_NODE_DROP_POSITION || (exports.TREE_NODE_DROP_POSITION = TREE_NODE_DROP_POSITION = {}));
+/**
+ * Represents the drag-related props for the Tree component.
+ */
+/**
+ * Represents the base props for the Tree component.
+ *
+ * @template V - The type of the value associated with each tree node.
+ * @template T - The type of the tree node.
+ */
+/**
+ * Represents the props for the Tree component.
+ */