@hsu-react/ui 0.0.1

package/lib/components/Tree/_components/TitleSearchBar/index.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _Input = _interopRequireDefault(require("../../../Input"));
+var _Icon = _interopRequireDefault(require("../../../Icon"));
+var _Button = _interopRequireDefault(require("../../../Button"));
+var _indexModule = _interopRequireDefault(require("../../index.module.less"));
+var _jsxRuntime = require("react/jsx-runtime");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const TitleSearchBar = ({
+  title,
+  search,
+  searchValue,
+  onSearchChange,
+  searchProps,
+  buttonGroup,
+  btnPosition = "right",
+  titleClassName,
+  className
+}) => {
+  // 渲染按钮组
+  const renderButtonGroup = (0, _react.useMemo)(() => {
+    if (!buttonGroup?.length) {
+      return null;
+    }
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+      className: _indexModule.default.buttonGroup,
+      children: buttonGroup?.map((button, idx) => /*#__PURE__*/(0, _jsxRuntime.jsx)(_Button.default, {
+        ...button
+      }, idx))
+    });
+  }, [buttonGroup]);
+  // 如果没有内容，不渲染
+  if (!search && !title && !buttonGroup?.length) {
+    return null;
+  }
+  return /*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
+    className: (0, _classnames.default)(_indexModule.default.title_search, className),
+    children: [title && /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+      className: (0, _classnames.default)(_indexModule.default.title, titleClassName),
+      children: title
+    }), btnPosition === "left" && renderButtonGroup, search && /*#__PURE__*/(0, _jsxRuntime.jsx)(_Input.default, {
+      prefix: /*#__PURE__*/(0, _jsxRuntime.jsx)(_Icon.default, {
+        icon: "mdi:search",
+        className: _indexModule.default.searchIcon
+      }),
+      placeholder: "\u8F93\u5165\u641C\u7D22",
+      ...searchProps,
+      value: searchValue,
+      onChange: onSearchChange,
+      className: (0, _classnames.default)(_indexModule.default.search, searchProps?.className)
+    }), btnPosition === "right" && renderButtonGroup]
+  });
+};
+var _default = exports.default = TitleSearchBar;

package/lib/components/Tree/_hooks/useClearNodeTitle.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+/**
+ * 清除树节点 title 属性的 Hook
+ * 当数据变更后，将所有 span.ant-tree-node-content-wrapper 的 title 设置为空
+ * @param treeData 树数据
+ * @param cls 树组件的唯一类名（用于精确定位）
+ */
+export declare const useClearNodeTitle: <T extends unknown[]>(treeData: T, cls?: string) => import("react").RefObject<HTMLDivElement>;

package/lib/components/Tree/_hooks/useClearNodeTitle.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useClearNodeTitle = void 0;
+var _react = require("react");
+/**
+ * 清除树节点 title 属性的 Hook
+ * 当数据变更后，将所有 span.ant-tree-node-content-wrapper 的 title 设置为空
+ * @param treeData 树数据
+ * @param cls 树组件的唯一类名（用于精确定位）
+ */
+const useClearNodeTitle = (treeData, cls) => {
+  const containerRef = (0, _react.useRef)(null);
+  (0, _react.useEffect)(() => {
+    // 使用 requestAnimationFrame 确保 DOM 已更新
+    const timer = requestAnimationFrame(() => {
+      // 根据类名查找或使用 ref
+      const container = cls ? document.querySelector(`.${cls}`) : containerRef.current;
+      if (!container) return;
+      setTimeout(() => {
+        // 获取所有 ant-tree-node-content-wrapper 元素
+        const nodes = container.querySelectorAll("span.ant-tree-node-content-wrapper");
+
+        // 清空每个元素的 title 属性
+        nodes?.forEach(node => {
+          if (node instanceof HTMLElement) {
+            node.title = "";
+          }
+        });
+      }, 100);
+    });
+    return () => {
+      cancelAnimationFrame(timer);
+    };
+  }, [treeData, cls]);
+  return containerRef;
+};
+exports.useClearNodeTitle = useClearNodeTitle;

package/lib/components/Tree/_hooks/useTreeCheck.d.ts

@@ -0,0 +1,7 @@
+import { TreeProps as AntdTreeProps } from "antd";
+import { CheckedKeys } from "..";
+/**
+ * 处理树勾选的 hook
+ * 使用 antd 默认逻辑，不做额外操作
+ */
+export declare const useTreeCheck: (setCheckedKeys: React.Dispatch<React.SetStateAction<CheckedKeys | undefined>>, onCheck?: AntdTreeProps["onCheck"], onChange?: ((checked: CheckedKeys) => void) | undefined) => (checked: CheckedKeys, info: Parameters<NonNullable<AntdTreeProps["onCheck"]>>[1]) => void;

package/lib/components/Tree/_hooks/useTreeCheck.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTreeCheck = void 0;
+var _react = require("react");
+/**
+ * 处理树勾选的 hook
+ * 使用 antd 默认逻辑，不做额外操作
+ */
+const useTreeCheck = (setCheckedKeys, onCheck, onChange) => {
+  // 处理勾选逻辑：直接使用 antd 的默认行为
+  const handleCheck = (0, _react.useCallback)((checked, info) => {
+    setCheckedKeys(checked);
+    onCheck?.(checked, info);
+
+    // 触发 onChange 回调
+    if (onChange) {
+      if (Array.isArray(checked)) {
+        onChange({
+          checked,
+          halfChecked: info.halfCheckedKeys || []
+        });
+      } else {
+        onChange(checked);
+      }
+    }
+  }, [setCheckedKeys, onCheck, onChange]);
+  return handleCheck;
+};
+exports.useTreeCheck = useTreeCheck;

package/lib/components/Tree/_hooks/useTreeSearch.d.ts

@@ -0,0 +1,10 @@
+import { Key } from "react";
+import { TreeData } from "..";
+/**
+ * 处理树搜索的 hook
+ */
+export declare const useTreeSearch: (treeData: TreeData[], setExpandedKeys: React.Dispatch<React.SetStateAction<Key[] | undefined>>) => {
+    searchKey: string;
+    handleSearchChange: (value: string) => void;
+    filteredTreeData: TreeData[];
+};

package/lib/components/Tree/_hooks/useTreeSearch.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTreeSearch = void 0;
+var _react = require("react");
+var _utils = require("../_utils");
+/**
+ * 处理树搜索的 hook
+ */
+const useTreeSearch = (treeData, setExpandedKeys) => {
+  const [searchKey, setSearchKey] = (0, _react.useState)("");
+  const prevSearchKeyRef = (0, _react.useRef)("");
+
+  // 处理树数据（搜索过滤）
+  // filterTreeData 内部已经处理了数据拷贝，无需额外 cloneDeep
+  const filteredTreeData = (0, _react.useMemo)(() => {
+    if (!searchKey.trim()) {
+      return treeData;
+    }
+    return (0, _utils.filterTreeData)(searchKey, treeData);
+  }, [searchKey, treeData]);
+
+  // 处理搜索时的展开逻辑
+  (0, _react.useEffect)(() => {
+    const trimmedSearchKey = searchKey.trim();
+    const prevTrimmedKey = prevSearchKeyRef.current.trim();
+
+    // 如果搜索关键词没有变化，跳过处理
+    if (trimmedSearchKey === prevTrimmedKey) {
+      return;
+    }
+    prevSearchKeyRef.current = searchKey;
+
+    // 清空搜索时，重置展开状态
+    if (!trimmedSearchKey) {
+      setExpandedKeys([]);
+      return;
+    }
+
+    // 有搜索关键词时，展开所有匹配的节点
+    if (!filteredTreeData.length) {
+      return;
+    }
+    const keysToExpandSet = new Set();
+    const collectExpandKeys = nodes => {
+      for (const node of nodes) {
+        if (node.children?.length) {
+          keysToExpandSet.add(node.key);
+          collectExpandKeys(node.children);
+        }
+      }
+    };
+    collectExpandKeys(filteredTreeData);
+    if (keysToExpandSet.size > 0) {
+      setExpandedKeys(prev => {
+        const prevSet = new Set(prev ?? []);
+        keysToExpandSet?.forEach(key => prevSet.add(key));
+        return Array.from(prevSet);
+      });
+    }
+  }, [searchKey, filteredTreeData, setExpandedKeys]);
+  const handleSearchChange = (0, _react.useCallback)(value => {
+    setSearchKey(value);
+  }, []);
+  return {
+    searchKey,
+    handleSearchChange,
+    filteredTreeData
+  };
+};
+exports.useTreeSearch = useTreeSearch;

package/lib/components/Tree/_hooks/useTreeState.d.ts

@@ -0,0 +1,11 @@
+import { Key } from "react";
+import { CheckedKeys, TreeData } from "..";
+/**
+ * 同步外部 expandedKeys 的 hook
+ */
+export declare const useExpandedKeys: (expandedKeysProps?: Key[], defaultExpandedKeys?: Key[]) => readonly [Key[] | undefined, (keys: Key[] | ((prev: Key[] | undefined) => Key[] | undefined) | undefined) => void];
+/**
+ * 同步外部 checkedKeys 的 hook
+ * 自动规范化：当父级在 checked 中但子项未全选时，将父级设为半选
+ */
+export declare const useCheckedKeys: (checkedKeysProps?: CheckedKeys, treeData?: TreeData[]) => readonly [CheckedKeys | undefined, import("react").Dispatch<import("react").SetStateAction<CheckedKeys | undefined>>];

package/lib/components/Tree/_hooks/useTreeState.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useExpandedKeys = exports.useCheckedKeys = void 0;
+var _react = require("react");
+var _hsuUtils = require("hsu-utils");
+var _normalizeCheckedKeys = require("../_utils/normalizeCheckedKeys");
+/**
+ * 同步外部 expandedKeys 的 hook
+ */
+const useExpandedKeys = (expandedKeysProps, defaultExpandedKeys) => {
+  const [expandedKeys, setExpandedKeys] = (0, _react.useState)(defaultExpandedKeys);
+  const prevPropsRef = (0, _react.useRef)(expandedKeysProps);
+  const prevDefaultRef = (0, _react.useRef)(defaultExpandedKeys);
+  // 标记用户是否已手动操作过展开状态
+  const hasUserInteractedRef = (0, _react.useRef)(false);
+
+  // 监听受控模式的 expandedKeysProps 变化
+  (0, _react.useEffect)(() => {
+    if (expandedKeysProps !== undefined && !_hsuUtils.Equal.ObjEqual(prevPropsRef.current, expandedKeysProps)) {
+      prevPropsRef.current = expandedKeysProps;
+      setExpandedKeys(expandedKeysProps);
+    }
+  }, [expandedKeysProps]);
+
+  // 监听 defaultExpandedKeys 变化（非受控模式下，用于响应异步数据加载）
+  (0, _react.useEffect)(() => {
+    // 只有在非受控模式下，且用户未手动操作过，才响应 defaultExpandedKeys 变化
+    if (expandedKeysProps === undefined && !hasUserInteractedRef.current && !_hsuUtils.Equal.ObjEqual(prevDefaultRef.current, defaultExpandedKeys)) {
+      prevDefaultRef.current = defaultExpandedKeys;
+      setExpandedKeys(defaultExpandedKeys);
+    }
+  }, [defaultExpandedKeys, expandedKeysProps]);
+
+  // 包装 setExpandedKeys，标记用户已手动操作
+  const handleSetExpandedKeys = keys => {
+    hasUserInteractedRef.current = true;
+    setExpandedKeys(keys);
+  };
+  return [expandedKeys, handleSetExpandedKeys];
+};
+
+/**
+ * 同步外部 checkedKeys 的 hook
+ * 自动规范化：当父级在 checked 中但子项未全选时，将父级设为半选
+ */
+exports.useExpandedKeys = useExpandedKeys;
+const useCheckedKeys = (checkedKeysProps, treeData) => {
+  // 规范化 checkedKeys
+  const normalizedCheckedKeys = (0, _react.useMemo)(() => {
+    if (!checkedKeysProps || !treeData?.length) {
+      return checkedKeysProps;
+    }
+    return (0, _normalizeCheckedKeys.normalizeCheckedKeys)(checkedKeysProps, treeData);
+  }, [checkedKeysProps, treeData]);
+  const [checkedKeys, setCheckedKeys] = (0, _react.useState)(() => normalizedCheckedKeys);
+  const prevNormalizedRef = (0, _react.useRef)(normalizedCheckedKeys);
+  (0, _react.useEffect)(() => {
+    // 只有当规范化后的值真正变化时才更新
+    if (normalizedCheckedKeys !== undefined && !_hsuUtils.Equal.ObjEqual(prevNormalizedRef.current, normalizedCheckedKeys)) {
+      prevNormalizedRef.current = normalizedCheckedKeys;
+      setCheckedKeys(normalizedCheckedKeys);
+    }
+  }, [normalizedCheckedKeys]);
+  return [checkedKeys, setCheckedKeys];
+};
+exports.useCheckedKeys = useCheckedKeys;

package/lib/components/Tree/_utils/index.d.ts

@@ -0,0 +1,44 @@
+import { Key } from "react";
+import { TreeData } from "..";
+/**
+ * 获取节点的所有子节点 key
+ * @param children 子节点数组
+ * @returns 所有子节点的 key 数组
+ */
+export declare const getAllChildrenKeys: (children: TreeData[]) => Key[];
+/**
+ * 在树中查找节点的所有父级节点 key
+ * @param targetKey 目标节点的 key
+ * @param treeData 树数据
+ * @param parentKeys 父级节点 key 数组（递归使用）
+ * @returns 所有父级节点的 key 数组，如果未找到则返回空数组
+ */
+export declare const getAllParentKeys: (targetKey: Key, treeData: TreeData[], parentKeys?: Key[]) => Key[];
+/**
+ * 根据 key 查找节点
+ * @param targetKey 目标节点的 key
+ * @param data 树数据
+ * @returns 找到的节点或 null
+ */
+export declare const findNodeByKey: (targetKey: Key, data: TreeData[]) => TreeData | null;
+/**
+ * 搜索过滤树数据
+ * @param searchKey 搜索关键词
+ * @param data 树数据
+ * @returns 过滤后的树数据
+ */
+export declare const filterTreeData: (searchKey: string, data: TreeData[]) => TreeData[];
+/**
+ * 根据默认展开层级计算应该展开的节点 keys
+ * @param treeData 树数据
+ * @param level 展开层级（从 1 开始，1 表示第一层，2 表示第二层，以此类推）
+ * @returns 应该展开的节点 keys 数组
+ */
+export declare const getExpandedKeysByLevel: (treeData: TreeData[], level: number) => Key[];
+/**
+ * 获取节点的完整路径（从根节点到当前节点）
+ * @param targetKey 目标节点的 key
+ * @param treeData 树数据
+ * @returns 节点路径数组，包含从根节点到目标节点的所有节点信息；如果未找到则返回 null
+ */
+export declare const getNodePath: (targetKey: Key, treeData: TreeData[]) => TreeData[] | null;

package/lib/components/Tree/_utils/index.js

@@ -0,0 +1,149 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getNodePath = exports.getExpandedKeysByLevel = exports.getAllParentKeys = exports.getAllChildrenKeys = exports.findNodeByKey = exports.filterTreeData = void 0;
+/**
+ * 获取节点的所有子节点 key
+ * @param children 子节点数组
+ * @returns 所有子节点的 key 数组
+ */
+const getAllChildrenKeys = children => {
+  const keys = [];
+  const traverse = nodes => {
+    for (const node of nodes) {
+      keys.push(node.key);
+      if (node.children?.length) {
+        traverse(node.children);
+      }
+    }
+  };
+  traverse(children);
+  return keys;
+};
+
+/**
+ * 在树中查找节点的所有父级节点 key
+ * @param targetKey 目标节点的 key
+ * @param treeData 树数据
+ * @param parentKeys 父级节点 key 数组（递归使用）
+ * @returns 所有父级节点的 key 数组，如果未找到则返回空数组
+ */
+exports.getAllChildrenKeys = getAllChildrenKeys;
+const getAllParentKeys = (targetKey, treeData, parentKeys = []) => {
+  for (const node of treeData) {
+    if (node.key === targetKey) {
+      return parentKeys;
+    }
+    if (node.children?.length) {
+      const newParentKeys = [...parentKeys, node.key];
+      const found = getAllParentKeys(targetKey, node.children, newParentKeys);
+      // 如果找到了（返回的数组长度大于0或等于newParentKeys），说明在子树中找到了
+      if (found.length > 0) {
+        return found;
+      }
+    }
+  }
+  return [];
+};
+
+/**
+ * 根据 key 查找节点
+ * @param targetKey 目标节点的 key
+ * @param data 树数据
+ * @returns 找到的节点或 null
+ */
+exports.getAllParentKeys = getAllParentKeys;
+const findNodeByKey = (targetKey, data) => {
+  for (const node of data) {
+    if (node.key === targetKey) {
+      return node;
+    }
+    if (node.children) {
+      const found = findNodeByKey(targetKey, node.children);
+      if (found) return found;
+    }
+  }
+  return null;
+};
+
+/**
+ * 搜索过滤树数据
+ * @param searchKey 搜索关键词
+ * @param data 树数据
+ * @returns 过滤后的树数据
+ */
+exports.findNodeByKey = findNodeByKey;
+const filterTreeData = (searchKey, data) => {
+  if (!searchKey.trim()) return data;
+  const result = [];
+  const lowerSearchKey = searchKey.toLowerCase();
+  for (const item of data) {
+    const matchesTitle = item.title.toLowerCase().includes(lowerSearchKey);
+    const filteredChildren = item.children?.length ? filterTreeData(searchKey, item.children) : undefined;
+    if (matchesTitle || filteredChildren?.length) {
+      result.push({
+        ...item,
+        children: filteredChildren?.length ? filteredChildren : undefined
+      });
+    }
+  }
+  return result;
+};
+
+/**
+ * 根据默认展开层级计算应该展开的节点 keys
+ * @param treeData 树数据
+ * @param level 展开层级（从 1 开始，1 表示第一层，2 表示第二层，以此类推）
+ * @returns 应该展开的节点 keys 数组
+ */
+exports.filterTreeData = filterTreeData;
+const getExpandedKeysByLevel = (treeData, level) => {
+  if (level < 1 || !treeData?.length) {
+    return [];
+  }
+  const expandedKeys = [];
+  const traverse = (nodes, currentLevel) => {
+    for (const node of nodes) {
+      // 如果当前层级小于等于目标层级，则展开该节点
+      if (currentLevel <= level && node.children?.length) {
+        expandedKeys.push(node.key);
+        traverse(node.children, currentLevel + 1);
+      }
+    }
+  };
+  traverse(treeData, 1);
+  return expandedKeys;
+};
+
+/**
+ * 获取节点的完整路径（从根节点到当前节点）
+ * @param targetKey 目标节点的 key
+ * @param treeData 树数据
+ * @returns 节点路径数组，包含从根节点到目标节点的所有节点信息；如果未找到则返回 null
+ */
+exports.getExpandedKeysByLevel = getExpandedKeysByLevel;
+const getNodePath = (targetKey, treeData) => {
+  const findPath = (nodes, path = []) => {
+    for (const node of nodes) {
+      const currentPath = [...path, node];
+
+      // 找到目标节点
+      if (node.key === targetKey) {
+        return currentPath;
+      }
+
+      // 在子节点中继续查找
+      if (node.children?.length) {
+        const found = findPath(node.children, currentPath);
+        if (found) {
+          return found;
+        }
+      }
+    }
+    return null;
+  };
+  return findPath(treeData);
+};
+exports.getNodePath = getNodePath;

package/lib/components/Tree/_utils/normalizeCheckedKeys.d.ts

@@ -0,0 +1,8 @@
+import { TreeData, CheckedKeys } from "..";
+/**
+ * 规范化 checkedKeys：检查父节点，如果子项未全选，将父节点设为半选
+ * @param checkedKeys 待规范化的 checkedKeys
+ * @param treeData 树数据
+ * @returns 规范化后的 checkedKeys
+ */
+export declare const normalizeCheckedKeys: (checkedKeys: CheckedKeys | undefined, treeData: TreeData[]) => CheckedKeys | undefined;

package/lib/components/Tree/_utils/normalizeCheckedKeys.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normalizeCheckedKeys = void 0;
+var _ = require(".");
+/**
+ * 规范化 checkedKeys：检查父节点，如果子项未全选，将父节点设为半选
+ * @param checkedKeys 待规范化的 checkedKeys
+ * @param treeData 树数据
+ * @returns 规范化后的 checkedKeys
+ */
+const normalizeCheckedKeys = (checkedKeys, treeData) => {
+  if (!checkedKeys || !treeData.length) {
+    return checkedKeys;
+  }
+
+  // 如果是数组格式，转换为对象格式
+  const checkedSet = new Set();
+  const halfCheckedSet = new Set();
+  if (Array.isArray(checkedKeys)) {
+    checkedKeys?.forEach(key => checkedSet.add(key));
+  } else {
+    checkedKeys.checked?.forEach(key => checkedSet.add(key));
+    (checkedKeys.halfChecked || [])?.forEach(key => halfCheckedSet.add(key));
+  }
+
+  // 递归遍历所有节点，检查父节点状态
+  // 从最底层开始处理，确保父节点的状态基于子节点的正确状态
+  const processNode = node => {
+    // 先递归处理子节点（从最底层开始）
+    if (node.children?.length) {
+      for (const child of node.children) {
+        processNode(child);
+      }
+    }
+
+    // 然后处理当前节点（父节点）
+    // 如果节点在 checked 中，且有子节点
+    if (checkedSet.has(node.key) && node.children?.length) {
+      // 获取所有子节点的 key
+      const allChildrenKeys = (0, _.getAllChildrenKeys)(node.children);
+
+      // 检查所有子节点是否都被勾选
+      if (allChildrenKeys.length > 0) {
+        const allChildrenChecked = allChildrenKeys.every(childKey => checkedSet.has(childKey));
+        if (!allChildrenChecked) {
+          // 如果子节点未全选，将父节点从 checked 中移除，添加到 halfChecked
+          checkedSet.delete(node.key);
+          halfCheckedSet.add(node.key);
+        } else {
+          // 如果所有子节点都被勾选，确保父节点不在 halfChecked 中
+          halfCheckedSet.delete(node.key);
+        }
+      }
+    }
+  };
+
+  // 遍历所有根节点
+  for (const node of treeData) {
+    processNode(node);
+  }
+
+  // 返回规范化后的 checkedKeys
+  return {
+    checked: Array.from(checkedSet),
+    halfChecked: Array.from(halfCheckedSet)
+  };
+};
+exports.normalizeCheckedKeys = normalizeCheckedKeys;

package/lib/components/Tree/index.d.ts

@@ -0,0 +1,48 @@
+import { TreeProps as AntdTreeProps } from "antd";
+import React, { ReactNode, Key } from "react";
+import { InputProps } from "../Input";
+import { ButtonProps } from "../Button";
+export interface TreeData extends Record<string, unknown> {
+    title: string;
+    key: string | number;
+    value: string | number;
+    selectable?: boolean;
+    disabled?: boolean;
+    disableCheckbox?: boolean;
+    isLeaf?: boolean;
+    checkable?: boolean;
+    icon?: ReactNode;
+    children?: TreeData[];
+}
+export interface CheckedObject {
+    checked: React.Key[];
+    halfChecked: React.Key[];
+}
+export type CheckedKeys = React.Key[] | CheckedObject;
+export interface TreeProps extends Omit<AntdTreeProps, "treeData" | "loadData" | "loadedKeys" | "titleRender"> {
+    titleRender?: (data: TreeData) => ReactNode;
+    treeClassName?: string;
+    treeContainerClassName?: string;
+    titleClassName?: string;
+    title?: ReactNode;
+    search?: boolean;
+    treeData?: TreeData[];
+    onChange?: (checked: CheckedKeys) => void;
+    searchProps?: InputProps;
+    indent?: number;
+    switchWidth?: number;
+    switchGap?: number;
+    hideLeafExpand?: boolean;
+    buttonGroup?: ButtonProps[];
+    btnPosition?: "left" | "right";
+    /** 默认展开层级（从 1 开始，1 表示第一层，2 表示第二层，以此类推） */
+    defaultExpandLevel?: number;
+    hasPermi?: string[];
+    /** 节点被选中时的回调，返回选中节点的完整路径 */
+    onSelectPath?: (path: TreeData[] | null, selectedKeys: Key[]) => void;
+    /** 点击已选中的节点时是否允许取消选中，默认 true（允许取消选中） */
+    allowDeselect?: boolean;
+    titleSearchBarClassName?: string;
+}
+declare const Tree: React.FC<TreeProps>;
+export default Tree;