@hsu-react/ui 0.0.1

package/es/components/TextEllipsis/index.module.less

@@ -0,0 +1,28 @@
+.container {
+  display: inline-block;
+  width: 100%;
+  flex: 1;
+  min-width: 0px;
+}
+
+.measureElement {
+  position: absolute;
+  visibility: hidden;
+  white-space: nowrap;
+  top: -9999px;
+  left: -9999px;
+}
+
+.textElement {
+  display: block;
+  overflow: hidden;
+  white-space: nowrap;
+
+  &.ellipsisEnd {
+    text-overflow: ellipsis;
+  }
+
+  &.ellipsisStart {
+    text-overflow: clip;
+  }
+}

package/es/components/Tree/_components/TitleSearchBar/index.d.ts

@@ -0,0 +1,16 @@
+import React from "react";
+import { InputProps } from "../../../Input";
+import { ButtonProps } from "../../../Button";
+export interface TitleSearchBarProps {
+    title?: React.ReactNode;
+    search?: boolean;
+    searchValue?: string;
+    onSearchChange?: (value: string) => void;
+    searchProps?: InputProps;
+    buttonGroup?: ButtonProps[];
+    btnPosition?: "left" | "right";
+    titleClassName?: string;
+    className?: string;
+}
+declare const TitleSearchBar: React.FC<TitleSearchBarProps>;
+export default TitleSearchBar;

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

@@ -0,0 +1,60 @@
+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 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); }
+import React, { useMemo } from "react";
+import classNames from "classnames";
+import Input from "../../../Input";
+import Icon from "../../../Icon";
+import Button from "../../../Button";
+import styles from "../../index.module.less";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+var TitleSearchBar = function TitleSearchBar(_ref) {
+  var title = _ref.title,
+    search = _ref.search,
+    searchValue = _ref.searchValue,
+    onSearchChange = _ref.onSearchChange,
+    searchProps = _ref.searchProps,
+    buttonGroup = _ref.buttonGroup,
+    _ref$btnPosition = _ref.btnPosition,
+    btnPosition = _ref$btnPosition === void 0 ? "right" : _ref$btnPosition,
+    titleClassName = _ref.titleClassName,
+    className = _ref.className;
+  // 渲染按钮组
+  var renderButtonGroup = useMemo(function () {
+    if (!(buttonGroup !== null && buttonGroup !== void 0 && buttonGroup.length)) {
+      return null;
+    }
+    return /*#__PURE__*/_jsx("div", {
+      className: styles.buttonGroup,
+      children: buttonGroup === null || buttonGroup === void 0 ? void 0 : buttonGroup.map(function (button, idx) {
+        return /*#__PURE__*/_jsx(Button, _objectSpread({}, button), idx);
+      })
+    });
+  }, [buttonGroup]);
+  // 如果没有内容，不渲染
+  if (!search && !title && !(buttonGroup !== null && buttonGroup !== void 0 && buttonGroup.length)) {
+    return null;
+  }
+  return /*#__PURE__*/_jsxs("div", {
+    className: classNames(styles.title_search, className),
+    children: [title && /*#__PURE__*/_jsx("div", {
+      className: classNames(styles.title, titleClassName),
+      children: title
+    }), btnPosition === "left" && renderButtonGroup, search && /*#__PURE__*/_jsx(Input, _objectSpread(_objectSpread({
+      prefix: /*#__PURE__*/_jsx(Icon, {
+        icon: "mdi:search",
+        className: styles.searchIcon
+      }),
+      placeholder: "\u8F93\u5165\u641C\u7D22"
+    }, searchProps), {}, {
+      value: searchValue,
+      onChange: onSearchChange,
+      className: classNames(styles.search, searchProps === null || searchProps === void 0 ? void 0 : searchProps.className)
+    })), btnPosition === "right" && renderButtonGroup]
+  });
+};
+export default TitleSearchBar;

package/es/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/es/components/Tree/_hooks/useClearNodeTitle.js

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

package/es/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/es/components/Tree/_hooks/useTreeCheck.js

@@ -0,0 +1,25 @@
+import { useCallback } from "react";
+/**
+ * 处理树勾选的 hook
+ * 使用 antd 默认逻辑，不做额外操作
+ */
+export var useTreeCheck = function useTreeCheck(setCheckedKeys, onCheck, onChange) {
+  // 处理勾选逻辑：直接使用 antd 的默认行为
+  var handleCheck = useCallback(function (checked, info) {
+    setCheckedKeys(checked);
+    onCheck === null || onCheck === void 0 || onCheck(checked, info);
+
+    // 触发 onChange 回调
+    if (onChange) {
+      if (Array.isArray(checked)) {
+        onChange({
+          checked: checked,
+          halfChecked: info.halfCheckedKeys || []
+        });
+      } else {
+        onChange(checked);
+      }
+    }
+  }, [setCheckedKeys, onCheck, onChange]);
+  return handleCheck;
+};

package/es/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/es/components/Tree/_hooks/useTreeSearch.js

@@ -0,0 +1,89 @@
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure 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 _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 _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import { useCallback, useMemo, useEffect, useState, useRef } from "react";
+import { filterTreeData } from "../_utils";
+
+/**
+ * 处理树搜索的 hook
+ */
+export var useTreeSearch = function useTreeSearch(treeData, setExpandedKeys) {
+  var _useState = useState(""),
+    _useState2 = _slicedToArray(_useState, 2),
+    searchKey = _useState2[0],
+    setSearchKey = _useState2[1];
+  var prevSearchKeyRef = useRef("");
+
+  // 处理树数据（搜索过滤）
+  // filterTreeData 内部已经处理了数据拷贝，无需额外 cloneDeep
+  var filteredTreeData = useMemo(function () {
+    if (!searchKey.trim()) {
+      return treeData;
+    }
+    return filterTreeData(searchKey, treeData);
+  }, [searchKey, treeData]);
+
+  // 处理搜索时的展开逻辑
+  useEffect(function () {
+    var trimmedSearchKey = searchKey.trim();
+    var prevTrimmedKey = prevSearchKeyRef.current.trim();
+
+    // 如果搜索关键词没有变化，跳过处理
+    if (trimmedSearchKey === prevTrimmedKey) {
+      return;
+    }
+    prevSearchKeyRef.current = searchKey;
+
+    // 清空搜索时，重置展开状态
+    if (!trimmedSearchKey) {
+      setExpandedKeys([]);
+      return;
+    }
+
+    // 有搜索关键词时，展开所有匹配的节点
+    if (!filteredTreeData.length) {
+      return;
+    }
+    var keysToExpandSet = new Set();
+    var collectExpandKeys = function collectExpandKeys(nodes) {
+      var _iterator = _createForOfIteratorHelper(nodes),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _node$children;
+          var node = _step.value;
+          if ((_node$children = node.children) !== null && _node$children !== void 0 && _node$children.length) {
+            keysToExpandSet.add(node.key);
+            collectExpandKeys(node.children);
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    };
+    collectExpandKeys(filteredTreeData);
+    if (keysToExpandSet.size > 0) {
+      setExpandedKeys(function (prev) {
+        var prevSet = new Set(prev !== null && prev !== void 0 ? prev : []);
+        keysToExpandSet === null || keysToExpandSet === void 0 || keysToExpandSet.forEach(function (key) {
+          return prevSet.add(key);
+        });
+        return Array.from(prevSet);
+      });
+    }
+  }, [searchKey, filteredTreeData, setExpandedKeys]);
+  var handleSearchChange = useCallback(function (value) {
+    setSearchKey(value);
+  }, []);
+  return {
+    searchKey: searchKey,
+    handleSearchChange: handleSearchChange,
+    filteredTreeData: filteredTreeData
+  };
+};

package/es/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/es/components/Tree/_hooks/useTreeState.js

@@ -0,0 +1,76 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure 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 _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 _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import { useEffect, useState, useMemo, useRef } from "react";
+import { Equal } from "hsu-utils";
+import { normalizeCheckedKeys } from "../_utils/normalizeCheckedKeys";
+
+/**
+ * 同步外部 expandedKeys 的 hook
+ */
+export var useExpandedKeys = function useExpandedKeys(expandedKeysProps, defaultExpandedKeys) {
+  var _useState = useState(defaultExpandedKeys),
+    _useState2 = _slicedToArray(_useState, 2),
+    expandedKeys = _useState2[0],
+    setExpandedKeys = _useState2[1];
+  var prevPropsRef = useRef(expandedKeysProps);
+  var prevDefaultRef = useRef(defaultExpandedKeys);
+  // 标记用户是否已手动操作过展开状态
+  var hasUserInteractedRef = useRef(false);
+
+  // 监听受控模式的 expandedKeysProps 变化
+  useEffect(function () {
+    if (expandedKeysProps !== undefined && !Equal.ObjEqual(prevPropsRef.current, expandedKeysProps)) {
+      prevPropsRef.current = expandedKeysProps;
+      setExpandedKeys(expandedKeysProps);
+    }
+  }, [expandedKeysProps]);
+
+  // 监听 defaultExpandedKeys 变化（非受控模式下，用于响应异步数据加载）
+  useEffect(function () {
+    // 只有在非受控模式下，且用户未手动操作过，才响应 defaultExpandedKeys 变化
+    if (expandedKeysProps === undefined && !hasUserInteractedRef.current && !Equal.ObjEqual(prevDefaultRef.current, defaultExpandedKeys)) {
+      prevDefaultRef.current = defaultExpandedKeys;
+      setExpandedKeys(defaultExpandedKeys);
+    }
+  }, [defaultExpandedKeys, expandedKeysProps]);
+
+  // 包装 setExpandedKeys，标记用户已手动操作
+  var handleSetExpandedKeys = function handleSetExpandedKeys(keys) {
+    hasUserInteractedRef.current = true;
+    setExpandedKeys(keys);
+  };
+  return [expandedKeys, handleSetExpandedKeys];
+};
+
+/**
+ * 同步外部 checkedKeys 的 hook
+ * 自动规范化：当父级在 checked 中但子项未全选时，将父级设为半选
+ */
+export var useCheckedKeys = function useCheckedKeys(checkedKeysProps, treeData) {
+  // 规范化 checkedKeys
+  var normalizedCheckedKeys = useMemo(function () {
+    if (!checkedKeysProps || !(treeData !== null && treeData !== void 0 && treeData.length)) {
+      return checkedKeysProps;
+    }
+    return normalizeCheckedKeys(checkedKeysProps, treeData);
+  }, [checkedKeysProps, treeData]);
+  var _useState3 = useState(function () {
+      return normalizedCheckedKeys;
+    }),
+    _useState4 = _slicedToArray(_useState3, 2),
+    checkedKeys = _useState4[0],
+    setCheckedKeys = _useState4[1];
+  var prevNormalizedRef = useRef(normalizedCheckedKeys);
+  useEffect(function () {
+    // 只有当规范化后的值真正变化时才更新
+    if (normalizedCheckedKeys !== undefined && !Equal.ObjEqual(prevNormalizedRef.current, normalizedCheckedKeys)) {
+      prevNormalizedRef.current = normalizedCheckedKeys;
+      setCheckedKeys(normalizedCheckedKeys);
+    }
+  }, [normalizedCheckedKeys]);
+  return [checkedKeys, setCheckedKeys];
+};

package/es/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/es/components/Tree/_utils/index.js

@@ -0,0 +1,210 @@
+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 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 _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 _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 _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+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 _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; }
+/**
+ * 获取节点的所有子节点 key
+ * @param children 子节点数组
+ * @returns 所有子节点的 key 数组
+ */
+export var getAllChildrenKeys = function getAllChildrenKeys(children) {
+  var keys = [];
+  var traverse = function traverse(nodes) {
+    var _iterator = _createForOfIteratorHelper(nodes),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _node$children;
+        var node = _step.value;
+        keys.push(node.key);
+        if ((_node$children = node.children) !== null && _node$children !== void 0 && _node$children.length) {
+          traverse(node.children);
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  };
+  traverse(children);
+  return keys;
+};
+
+/**
+ * 在树中查找节点的所有父级节点 key
+ * @param targetKey 目标节点的 key
+ * @param treeData 树数据
+ * @param parentKeys 父级节点 key 数组（递归使用）
+ * @returns 所有父级节点的 key 数组，如果未找到则返回空数组
+ */
+export var getAllParentKeys = function getAllParentKeys(targetKey, treeData) {
+  var parentKeys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  var _iterator2 = _createForOfIteratorHelper(treeData),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _node$children2;
+      var node = _step2.value;
+      if (node.key === targetKey) {
+        return parentKeys;
+      }
+      if ((_node$children2 = node.children) !== null && _node$children2 !== void 0 && _node$children2.length) {
+        var newParentKeys = [].concat(_toConsumableArray(parentKeys), [node.key]);
+        var found = getAllParentKeys(targetKey, node.children, newParentKeys);
+        // 如果找到了（返回的数组长度大于0或等于newParentKeys），说明在子树中找到了
+        if (found.length > 0) {
+          return found;
+        }
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return [];
+};
+
+/**
+ * 根据 key 查找节点
+ * @param targetKey 目标节点的 key
+ * @param data 树数据
+ * @returns 找到的节点或 null
+ */
+export var findNodeByKey = function findNodeByKey(targetKey, data) {
+  var _iterator3 = _createForOfIteratorHelper(data),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var node = _step3.value;
+      if (node.key === targetKey) {
+        return node;
+      }
+      if (node.children) {
+        var found = findNodeByKey(targetKey, node.children);
+        if (found) return found;
+      }
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  return null;
+};
+
+/**
+ * 搜索过滤树数据
+ * @param searchKey 搜索关键词
+ * @param data 树数据
+ * @returns 过滤后的树数据
+ */
+export var filterTreeData = function filterTreeData(searchKey, data) {
+  if (!searchKey.trim()) return data;
+  var result = [];
+  var lowerSearchKey = searchKey.toLowerCase();
+  var _iterator4 = _createForOfIteratorHelper(data),
+    _step4;
+  try {
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var _item$children;
+      var item = _step4.value;
+      var matchesTitle = item.title.toLowerCase().includes(lowerSearchKey);
+      var filteredChildren = (_item$children = item.children) !== null && _item$children !== void 0 && _item$children.length ? filterTreeData(searchKey, item.children) : undefined;
+      if (matchesTitle || filteredChildren !== null && filteredChildren !== void 0 && filteredChildren.length) {
+        result.push(_objectSpread(_objectSpread({}, item), {}, {
+          children: filteredChildren !== null && filteredChildren !== void 0 && filteredChildren.length ? filteredChildren : undefined
+        }));
+      }
+    }
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+  return result;
+};
+
+/**
+ * 根据默认展开层级计算应该展开的节点 keys
+ * @param treeData 树数据
+ * @param level 展开层级（从 1 开始，1 表示第一层，2 表示第二层，以此类推）
+ * @returns 应该展开的节点 keys 数组
+ */
+export var getExpandedKeysByLevel = function getExpandedKeysByLevel(treeData, level) {
+  if (level < 1 || !(treeData !== null && treeData !== void 0 && treeData.length)) {
+    return [];
+  }
+  var expandedKeys = [];
+  var traverse = function traverse(nodes, currentLevel) {
+    var _iterator5 = _createForOfIteratorHelper(nodes),
+      _step5;
+    try {
+      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+        var _node$children3;
+        var node = _step5.value;
+        // 如果当前层级小于等于目标层级，则展开该节点
+        if (currentLevel <= level && (_node$children3 = node.children) !== null && _node$children3 !== void 0 && _node$children3.length) {
+          expandedKeys.push(node.key);
+          traverse(node.children, currentLevel + 1);
+        }
+      }
+    } catch (err) {
+      _iterator5.e(err);
+    } finally {
+      _iterator5.f();
+    }
+  };
+  traverse(treeData, 1);
+  return expandedKeys;
+};
+
+/**
+ * 获取节点的完整路径（从根节点到当前节点）
+ * @param targetKey 目标节点的 key
+ * @param treeData 树数据
+ * @returns 节点路径数组，包含从根节点到目标节点的所有节点信息；如果未找到则返回 null
+ */
+export var getNodePath = function getNodePath(targetKey, treeData) {
+  var findPath = function findPath(nodes) {
+    var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    var _iterator6 = _createForOfIteratorHelper(nodes),
+      _step6;
+    try {
+      for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+        var _node$children4;
+        var node = _step6.value;
+        var currentPath = [].concat(_toConsumableArray(path), [node]);
+
+        // 找到目标节点
+        if (node.key === targetKey) {
+          return currentPath;
+        }
+
+        // 在子节点中继续查找
+        if ((_node$children4 = node.children) !== null && _node$children4 !== void 0 && _node$children4.length) {
+          var found = findPath(node.children, currentPath);
+          if (found) {
+            return found;
+          }
+        }
+      }
+    } catch (err) {
+      _iterator6.e(err);
+    } finally {
+      _iterator6.f();
+    }
+    return null;
+  };
+  return findPath(treeData);
+};

package/es/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;