@zid-utils/tree-utils 0.0.6 → 0.0.8

package/README.md

@@ -0,0 +1,458 @@
+# @zid-utils/tree-utils
+
+> 树形数据结构处理工具库 (Tree data structure utility library)
+
+## 安装
+
+```bash
+pnpm add @zid-utils/tree-utils
+```
+
+## 核心方法（来自 tree-lodash）
+
+本包使用 [tree-lodash](https://github.com/zhangshichun/tree-lodash) 作为核心实现，提供强大的树操作功能。
+
+### foreach - 遍历
+
+遍历树或森林的所有节点。
+
+```typescript
+import { foreach } from '@zid-utils/tree-utils';
+
+const tree = {
+  key: '1',
+  title: 'Root',
+  children: [
+    { key: '1-1', title: 'Child 1' },
+    { key: '1-2', title: 'Child 2' }
+  ]
+};
+
+foreach(tree, (node, meta) => {
+  console.log(`${'  '.repeat(meta.depth)}${node.title}`);
+}, { strategy: 'pre' });
+```
+
+### map - 映射
+
+遍历并映射每个节点，返回新的树结构。
+
+```typescript
+import { map } from '@zid-utils/tree-utils';
+
+const newTree = map(tree, (node) => ({
+  ...node,
+  title: `Mapped: ${node.title}`
+}));
+```
+
+### filter - 过滤
+
+过滤树节点，保留符合条件的节点。
+
+```typescript
+import { filter } from '@zid-utils/tree-utils';
+
+const filteredTree = filter(tree, (node) => node.key.startsWith('1-'));
+```
+
+### find - 查找
+
+查找第一个匹配的节点。
+
+```typescript
+import { find } from '@zid-utils/tree-utils';
+
+const node = find(tree, (node) => node.key === '1-1');
+```
+
+### some - 存在检查
+
+检查是否存在匹配的节点。
+
+```typescript
+import { some } from '@zid-utils/tree-utils';
+
+const exists = some(tree, (node) => node.key === '1-1');
+```
+
+### toArray - 扁平化
+
+将树结构扁平化为数组。
+
+```typescript
+import { toArray } from '@zid-utils/tree-utils';
+
+const nodes = toArray(tree);
+```
+
+### fromArray - 构建树
+
+从扁平数组构建树结构。
+
+```typescript
+import { fromArray } from '@zid-utils/tree-utils';
+
+const array = [
+  { id: 1, pid: null, title: 'Root' },
+  { id: 2, pid: 1, title: 'Child' }
+];
+
+const tree = fromArray(array, {
+  parentKey: 'pid',
+  itemKey: 'id',
+  childrenKey: 'children'
+});
+```
+
+## 扩展方法
+
+### 节点查询
+
+#### getLeafNodes
+
+获取所有叶子节点。
+
+```typescript
+import { getLeafNodes } from '@zid-utils/tree-utils';
+
+const leafNodes = getLeafNodes(tree, 'isLeaf');
+```
+
+#### findNodeByKey
+
+根据 key 查找节点。
+
+```typescript
+import { findNodeByKey } from '@zid-utils/tree-utils';
+
+const node = findNodeByKey(tree, '1-1');
+```
+
+#### findNodeById
+
+根据 id 查找节点。
+
+```typescript
+import { findNodeById } from '@zid-utils/tree-utils';
+
+const node = findNodeById(tree, 'node-id');
+```
+
+#### findNodeByMatcher
+
+根据匹配器查找节点。
+
+```typescript
+import { findNodeByMatcher } from '@zid-utils/tree-utils';
+
+const node = findNodeByMatcher(tree, (n) => n.title === 'Target');
+```
+
+#### nodeExistsInTree
+
+检查节点是否存在于树中。
+
+```typescript
+import { nodeExistsInTree } from '@zid-utils/tree-utils';
+
+const exists = nodeExistsInTree(tree, 'node-title');
+```
+
+#### findParentOf
+
+查找节点的父节点。
+
+```typescript
+import { findParentOf } from '@zid-utils/tree-utils';
+
+const parent = findParentOf(tree, 'child-key');
+```
+
+#### getNodePath
+
+获取节点路径。
+
+```typescript
+import { getNodePath, type PathNode } from '@zid-utils/tree-utils';
+
+const path = getNodePath(tree, '1-2', 'key', 'children');
+// 返回 PathNode[] 包含路径信息
+```
+
+#### getNodeDepth
+
+获取节点深度。
+
+```typescript
+import { getNodeDepth } from '@zid-utils/tree-utils';
+
+const depth = getNodeDepth(tree, '1-2-1');
+// 返回节点所在层级（根节点为0）
+```
+
+#### getNodeBreadcrumb
+
+获取面包屑路径（所有祖先节点）。
+
+```typescript
+import { getNodeBreadcrumb } from '@zid-utils/tree-utils';
+
+const breadcrumb = getNodeBreadcrumb(tree, '1-2-1');
+// 返回从根到目标的所有节点
+```
+
+#### getTreeStats
+
+获取树统计信息。
+
+```typescript
+import { getTreeStats } from '@zid-utils/tree-utils';
+
+const stats = getTreeStats(tree);
+// { totalNodes: 10, maxDepth: 3, leafCount: 5 }
+```
+
+### 节点操作
+
+#### updateKeys
+
+更新节点的 key。
+
+```typescript
+import { updateKeys } from '@zid-utils/tree-utils';
+
+updateKeys(sourceNode, targetNode);
+```
+
+#### updateNodeTitleByKey
+
+根据 key 更新节点标题。
+
+```typescript
+import { updateNodeTitleByKey } from '@zid-utils/tree-utils';
+
+updateNodeTitleByKey(tree, '1-1', 'New Title');
+```
+
+#### updateNodeByMatcher
+
+根据匹配器更新节点。
+
+```typescript
+import { updateNodeByMatcher } from '@zid-utils/tree-utils';
+
+const newTree = updateNodeByMatcher(
+  tree,
+  (node) => node.key === 'target',
+  (node) => ({ ...node, title: 'Updated' })
+);
+```
+
+#### moveNodeInTree
+
+在树中移动节点。
+
+```typescript
+import { moveNodeInTree } from '@zid-utils/tree-utils';
+
+moveNodeInTree(tree, 'source-key', 'target-key');
+```
+
+#### cloneNode
+
+克隆节点。
+
+```typescript
+import { cloneNode } from '@zid-utils/tree-utils';
+
+cloneNode(sourceNode, targetNode);
+```
+
+#### copyNode
+
+复制节点（带副本标识）。
+
+```typescript
+import { copyNode } from '@zid-utils/tree-utils';
+
+const newTree = copyNode(tree, 'source-key', 'target-key');
+```
+
+#### deleteNode
+
+删除节点。
+
+```typescript
+import { deleteNode } from '@zid-utils/tree-utils';
+
+const newTree = deleteNode(tree, 'key-to-delete');
+```
+
+#### addLeafProperties
+
+为节点添加叶子属性。
+
+```typescript
+import { addLeafProperties } from '@zid-utils/tree-utils';
+
+const newTree = addLeafProperties(tree);
+// 自动设置 isLeaf 和 disabled 属性
+```
+
+### 树转换
+
+#### transformTreeKeys
+
+转换树节点的键。
+
+```typescript
+import { transformTreeKeys } from '@zid-utils/tree-utils';
+
+const newTree = transformTreeKeys(tree, {
+  title: 'label',
+  key: 'id'
+});
+```
+
+#### transformTreeNodes
+
+转换树节点数据。
+
+```typescript
+import { transformTreeNodes } from '@zid-utils/tree-utils';
+
+const newTree = transformTreeNodes(tree, (node) => ({
+  ...node,
+  isActive: true
+}));
+```
+
+#### searchInTree
+
+在树中搜索节点。
+
+```typescript
+import { searchInTree } from '@zid-utils/tree-utils';
+
+const results = searchInTree(tree, 'search-term');
+```
+
+### 工具函数
+
+#### findFirstLeaf
+
+查找第一个叶子节点。
+
+```typescript
+import { findFirstLeaf } from '@zid-utils/tree-utils';
+
+const leaf = findFirstLeaf(tree);
+```
+
+#### traverseTreeValues
+
+遍历树中特定键的值。
+
+```typescript
+import { traverseTreeValues } from '@zid-utils/tree-utils';
+
+const values = traverseTreeValues(tree, 'title');
+```
+
+#### filterCheckedLeafKeys
+
+过滤选中的叶子节点 key。
+
+```typescript
+import { filterCheckedLeafKeys } from '@zid-utils/tree-utils';
+
+const keys = filterCheckedLeafKeys(tree);
+```
+
+#### collectLeafValuesByKey
+
+收集叶子节点的值。
+
+```typescript
+import { collectLeafValuesByKey } from '@zid-utils/tree-utils';
+
+const values = collectLeafValuesByKey(tree, 'parent-value');
+```
+
+#### convertGroupsToTreeData
+
+将分组数据转换为树形结构。
+
+```typescript
+import { convertGroupsToTreeData, type TreeGroup } from '@zid-utils/tree-utils';
+
+const tree = convertGroupsToTreeData(items, 'category');
+// 返回 TreeGroup[] 类型
+```
+
+## 类型定义
+
+### TreeNode
+
+```typescript
+interface TreeNode {
+  key?: string | number;
+  title?: string | number;
+  children?: TreeNode[];
+  isLeaf?: boolean;
+  disabled?: boolean;
+  selectable?: boolean;
+  checked?: boolean;
+  [key: string]: any;
+}
+```
+
+### PathNode
+
+```typescript
+interface PathNode<T> {
+  node: T;           // 节点数据
+  depth: number;      // 深度（根节点为0）
+  index: number;      // 在兄弟节点中的索引
+  parent: PathNode<T> | null;  // 父节点
+  path: string;       // 路径字符串，如 'root/child/grandchild'
+}
+```
+
+### TreeGroup
+
+```typescript
+interface TreeGroup {
+  label: string;
+  value: string | number;
+  children?: any[];
+}
+```
+
+## 遍历策略
+
+所有核心方法都支持三种遍历策略：
+
+- `pre` - 前序遍历（默认）
+- `post` - 后序遍历
+- `breadth` - 广度优先遍历
+
+```typescript
+import { foreach } from '@zid-utils/tree-utils';
+
+foreach(tree, callback, { strategy: 'breadth' });
+```
+
+## 相关库推荐
+
+### 文件系统场景
+- [@httpx/treeu](https://github.com/belgattitude/httpx/tree/main/packages/treeu) - 轻量级 DFS 搜索和路径映射，适合深层嵌套树的性能优化
+
+### 其他选择
+- [tree-model](https://github.com/joaonuno/tree-model) - 模型驱动的树操作
+- [js-tree](https://github.com/guigrpa/js-tree) - React 集成友好的树组件
+
+## License
+
+MIT

package/dist/index.js

@@ -1,8 +1,16 @@
-// src/index.ts
-var defaultLogger = {
-  warn: (msg) => console.warn("[tree-utils]", msg),
-  error: (msg) => console.error("[tree-utils]", msg)
-};
+// src/traverse/foreach.ts
+import { default as default2 } from "tree-lodash";
+
+// src/traverse/toArray.ts
+import { default as default3 } from "tree-lodash";
+
+// src/query/find.ts
+import { default as default4 } from "tree-lodash";
+
+// src/query/some.ts
+import { default as default5 } from "tree-lodash";
+
+// src/query/getLeafNodes.ts
 var getLeafNodes = (treeData, isLeafKey = "isLeaf") => {
   function collectLeafNodes(nodes) {
     const leafNodes = [];
@@ -17,24 +25,8 @@ var getLeafNodes = (treeData, isLeafKey = "isLeaf") => {
   }
   return collectLeafNodes(treeData);
 };
-var filterTreeNodes = (nodes, callback, isOnlyFilterChildren = true) => {
-  const filterChildren = (children) => {
-    if (children && children.length > 0) {
-      return children.filter(callback).map((child) => {
-        return {
-          ...child,
-          children: filterChildren(child.children)
-        };
-      });
-    }
-    return [];
-  };
-  const rootNodes = isOnlyFilterChildren ? nodes : nodes.filter(callback);
-  return rootNodes.map((node) => ({
-    ...node,
-    children: filterChildren(node.children)
-  }));
-};
+
+// src/query/findNodeByKey.ts
 var findNodeByKey = (treeData, key) => {
   for (let i = 0; i < treeData.length; i++) {
     const node = treeData[i];
@@ -50,28 +42,127 @@ var findNodeByKey = (treeData, key) => {
   }
   return null;
 };
-var searchInTree = (tree, searchValue) => {
-  function searchRecursive(node, searchText, result2) {
-    const title = node.title?.toString().toLowerCase() || "";
-    const text = searchText.toLowerCase();
-    const arr = text.split("");
-    if (node.isLeaf && arr.every((item) => title.includes(item))) {
-      if (!result2.some((item) => item.key === node.key)) {
-        result2.push(node);
-      }
+
+// src/query/findNodeById.ts
+var findNodeById = (nodes, id) => {
+  for (const node of nodes) {
+    if (node.id === id) return node;
+    if (node.children && node.children.length) {
+      const found = findNodeById(node.children, id);
+      if (found) return found;
     }
-    if (node.children) {
-      for (const child of node.children) {
-        searchRecursive(child, text, result2);
+  }
+  return null;
+};
+
+// src/query/findNodeByMatcher.ts
+var findNodeByMatcher = (nodes, matcher, childrenKey = "children") => {
+  for (const node of nodes) {
+    if (matcher(node)) {
+      return node;
+    }
+    if (node[childrenKey]) {
+      const found = findNodeByMatcher(node[childrenKey], matcher, childrenKey);
+      if (found) {
+        return found;
       }
     }
   }
-  const result = [];
-  for (const rootNode of tree) {
-    searchRecursive(rootNode, searchValue.toLowerCase(), result);
+  return null;
+};
+
+// src/query/nodeExistsInTree.ts
+var nodeExistsInTree = (nodes, searchValue) => {
+  return nodes.some((node) => {
+    if (node.value === searchValue || node.title === searchValue) {
+      return true;
+    }
+    if (node.children && Array.isArray(node.children)) {
+      return nodeExistsInTree(node.children, searchValue);
+    }
+    return false;
+  });
+};
+
+// src/query/findParentOf.ts
+var findParentOf = (nodes, targetKey) => {
+  for (const node of nodes) {
+    if (node.children?.some((child) => child.key === targetKey)) {
+      return node;
+    }
+    if (node.children) {
+      const found = findParentOf(node.children, targetKey);
+      if (found) return found;
+    }
   }
-  return result;
+  return null;
+};
+
+// src/query/getNodePath.ts
+var getNodePath = (treeData, targetKey, keyField = "key", childrenKey = "children") => {
+  const findPath = (nodes, target, currentPath) => {
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      const newPathNode = {
+        node,
+        depth: currentPath.length,
+        index: i,
+        parent: currentPath.length > 0 ? currentPath[currentPath.length - 1] : null,
+        path: currentPath.length === 0 ? String(node[keyField]) : `${currentPath[currentPath.length - 1].path}/${String(node[keyField])}`
+      };
+      if (node[keyField] === target) {
+        return [...currentPath, newPathNode];
+      }
+      const children = node[childrenKey];
+      if (children && Array.isArray(children) && children.length > 0) {
+        const result = findPath(children, target, [
+          ...currentPath,
+          newPathNode
+        ]);
+        if (result) {
+          return result;
+        }
+      }
+    }
+    return null;
+  };
+  return findPath(treeData, targetKey, []);
+};
+
+// src/query/getNodeDepth.ts
+var getNodeDepth = (treeData, targetKey, keyField = "key", childrenKey = "children") => {
+  const path = getNodePath(treeData, targetKey, keyField, childrenKey);
+  return path ? path.length - 1 : -1;
 };
+
+// src/query/getNodeBreadcrumb.ts
+var getNodeBreadcrumb = (treeData, targetKey, keyField = "key", childrenKey = "children") => {
+  const path = getNodePath(treeData, targetKey, keyField, childrenKey);
+  return path ? path.map((p) => p.node) : [];
+};
+
+// src/query/getTreeStats.ts
+var getTreeStats = (treeData, childrenKey = "children") => {
+  let totalNodes = 0;
+  let maxDepth = 0;
+  let leafCount = 0;
+  const traverse = (nodes, depth) => {
+    for (const node of nodes) {
+      totalNodes++;
+      maxDepth = Math.max(maxDepth, depth);
+      const children = node[childrenKey];
+      if (children && Array.isArray(children) && children.length > 0) {
+        traverse(children, depth + 1);
+      } else {
+        leafCount++;
+      }
+    }
+  };
+  traverse(treeData, 0);
+  return { totalNodes, maxDepth, leafCount };
+};
+
+// src/modify/updateKeys.ts
 var updateKeys = (sourceNode, targetNode) => {
   sourceNode.key = `${targetNode.key}-${targetNode.children?.length}`;
   if (sourceNode.children) {
@@ -80,6 +171,49 @@ var updateKeys = (sourceNode, targetNode) => {
     });
   }
 };
+
+// src/modify/updateNodeTitleByKey.ts
+var updateNodeTitleByKey = (tree, targetKey, newTitle) => {
+  for (const node of tree) {
+    if (node.key === targetKey) {
+      node.title = newTitle;
+      return;
+    }
+    if (node.children) {
+      updateNodeTitleByKey(node.children, targetKey, newTitle);
+    }
+  }
+};
+
+// src/modify/updateNodeByMatcher.ts
+var updateNodeByMatcher = (nodes, matcher, updater, childrenKey = "children") => {
+  return nodes.map((node) => {
+    if (matcher(node)) {
+      return updater(node);
+    }
+    if (node[childrenKey] && node[childrenKey].length > 0) {
+      const newChildren = updateNodeByMatcher(
+        node[childrenKey],
+        matcher,
+        updater,
+        childrenKey
+      );
+      if (newChildren !== node[childrenKey]) {
+        return {
+          ...node,
+          [childrenKey]: newChildren
+        };
+      }
+    }
+    return node;
+  });
+};
+
+// src/modify/moveNodeInTree.ts
+var defaultLogger = {
+  warn: (msg) => console.warn("[tree-utils]", msg),
+  error: (msg) => console.error("[tree-utils]", msg)
+};
 var moveNodeInTree = (treeData, sourceKey, targetKey, logger = defaultLogger) => {
   function findNode(nodes, key) {
     if (!nodes) return null;
@@ -133,6 +267,8 @@ var moveNodeInTree = (treeData, sourceKey, targetKey, logger = defaultLogger) =>
   targetNode.children = targetNode.children || [];
   targetNode.children.push(sourceNode);
 };
+
+// src/modify/cloneNode.ts
 var cloneNode = (sourceNode, targetNode) => {
   const clonedNode = { ...sourceNode };
   if (targetNode.children) {
@@ -141,6 +277,8 @@ var cloneNode = (sourceNode, targetNode) => {
     targetNode.children = [clonedNode];
   }
 };
+
+// src/modify/copyNode.ts
 var copyNode = (treeData, key, targetKey) => {
   const sourceNode = structuredClone(findNodeByKey(treeData, key));
   const targetNode = findNodeByKey(treeData, targetKey);
@@ -152,17 +290,8 @@ var copyNode = (treeData, key, targetKey) => {
   }
   return treeData;
 };
-var updateNodeTitleByKey = (tree, targetKey, newTitle) => {
-  for (const node of tree) {
-    if (node.key === targetKey) {
-      node.title = newTitle;
-      return;
-    }
-    if (node.children) {
-      updateNodeTitleByKey(node.children, targetKey, newTitle);
-    }
-  }
-};
+
+// src/modify/deleteNode.ts
 var deleteNode = (treeData, key) => {
   const delNode = (data) => {
     return data.filter((node) => {
@@ -177,19 +306,8 @@ var deleteNode = (treeData, key) => {
   };
   return delNode([...treeData]);
 };
-var flattenTree = (tree, filter = () => true) => {
-  const result = [];
-  const flatten = (node) => {
-    if (filter(node)) {
-      result.push(node);
-    }
-    if (node.children) {
-      node.children.forEach(flatten);
-    }
-  };
-  tree.forEach(flatten);
-  return result;
-};
+
+// src/modify/addLeafProperties.ts
 var addLeafProperties = (treeData) => {
   return treeData.map((node) => {
     const isLeaf = !node.children || node.children.length === 0;
@@ -201,66 +319,19 @@ var addLeafProperties = (treeData) => {
     };
   });
 };
-var findNodeById = (nodes, id) => {
-  for (const node of nodes) {
-    if (node.id === id) return node;
-    if (node.children && node.children.length) {
-      const found = findNodeById(node.children, id);
-      if (found) return found;
-    }
-  }
-  return null;
-};
-var filterCheckedLeafKeys = (treeData) => {
-  const result = [];
-  const traverse = (nodes) => {
-    if (!nodes || nodes.length === 0) return;
-    for (const node of nodes) {
-      if (node.checked === false) continue;
-      if (node.children && node.children.length > 0) {
-        traverse(node.children);
-      } else if (node.checked === true) {
-        result.push(node.key);
-      }
-    }
-  };
-  traverse(treeData);
-  return result;
-};
-var nodeExistsInTree = (nodes, searchValue) => {
-  return nodes.some((node) => {
-    if (node.value === searchValue || node.title === searchValue) {
-      return true;
-    }
-    if (node.children && Array.isArray(node.children)) {
-      return nodeExistsInTree(node.children, searchValue);
-    }
-    return false;
-  });
-};
-var collectLeafValuesByKey = (nodes, targetValue, isLeafKey = "isLeaf") => {
-  for (const node of nodes) {
-    if (node.value === targetValue) {
-      if (node.children && Array.isArray(node.children) && node.children.length > 0) {
-        const leafNodes = getLeafNodes([node], isLeafKey);
-        return leafNodes.map((leaf) => leaf.value);
-      }
-      return null;
-    }
-    if (node.children && Array.isArray(node.children)) {
-      const result = collectLeafValuesByKey(
-        node.children,
-        targetValue,
-        isLeafKey
-      );
-      if (result !== null) {
-        return result;
-      }
-    }
-  }
-  return null;
+
+// src/transform/map.ts
+import { default as default6 } from "tree-lodash";
+
+// src/transform/filter.ts
+import { default as default7 } from "tree-lodash";
+
+// src/transform/transformTreeKeys.ts
+var defaultLogger2 = {
+  warn: (msg) => console.warn("[tree-utils]", msg),
+  error: (msg) => console.error("[tree-utils]", msg)
 };
-var transformTreeKeys = (treeData, keyMapping, childrenKey = "children", logger = defaultLogger) => {
+var transformTreeKeys = (treeData, keyMapping, childrenKey = "children", logger = defaultLogger2) => {
   if (!Array.isArray(treeData)) {
     logger.warn?.("transformTreeKeys: treeData must be an array");
     return [];
@@ -288,7 +359,13 @@ var transformTreeKeys = (treeData, keyMapping, childrenKey = "children", logger
   };
   return treeData.map(transformNode);
 };
-var transformTreeNodes = (treeData, transformer, childrenKey = "children", logger = defaultLogger) => {
+
+// src/transform/transformTreeNodes.ts
+var defaultLogger3 = {
+  warn: (msg) => console.warn("[tree-utils]", msg),
+  error: (msg) => console.error("[tree-utils]", msg)
+};
+var transformTreeNodes = (treeData, transformer, childrenKey = "children", logger = defaultLogger3) => {
   if (!Array.isArray(treeData)) {
     logger.warn?.("transformTreeNodes: treeData must be an array");
     return [];
@@ -313,126 +390,35 @@ var transformTreeNodes = (treeData, transformer, childrenKey = "children", logge
   };
   return treeData.map(transformNode);
 };
-var findParentOf = (nodes, targetKey) => {
-  for (const node of nodes) {
-    if (node.children?.some((child) => child.key === targetKey)) {
-      return node;
+
+// src/transform/searchInTree.ts
+var searchInTree = (tree, searchValue) => {
+  function searchRecursive(node, searchText, result2) {
+    const title = node.title?.toString().toLowerCase() || "";
+    const text = searchText.toLowerCase();
+    const arr = text.split("");
+    if (node.isLeaf && arr.every((item) => title.includes(item))) {
+      if (!result2.some((item) => item.key === node.key)) {
+        result2.push(node);
+      }
     }
     if (node.children) {
-      const found = findParentOf(node.children, targetKey);
-      if (found) return found;
-    }
-  }
-  return null;
-};
-var findNodeByMatcher = (nodes, matcher, childrenKey = "children") => {
-  for (const node of nodes) {
-    if (matcher(node)) {
-      return node;
-    }
-    if (node[childrenKey]) {
-      const found = findNodeByMatcher(node[childrenKey], matcher, childrenKey);
-      if (found) {
-        return found;
+      for (const child of node.children) {
+        searchRecursive(child, text, result2);
       }
     }
   }
-  return null;
-};
-var updateNodeByMatcher = (nodes, matcher, updater, childrenKey = "children") => {
-  return nodes.map((node) => {
-    if (matcher(node)) {
-      return updater(node);
-    }
-    if (node[childrenKey] && node[childrenKey].length > 0) {
-      const newChildren = updateNodeByMatcher(
-        node[childrenKey],
-        matcher,
-        updater,
-        childrenKey
-      );
-      if (newChildren !== node[childrenKey]) {
-        return {
-          ...node,
-          [childrenKey]: newChildren
-        };
-      }
-    }
-    return node;
-  });
-};
-var getNodePath = (treeData, targetKey, keyField = "key", childrenKey = "children") => {
-  const findPath = (nodes, target, currentPath) => {
-    for (let i = 0; i < nodes.length; i++) {
-      const node = nodes[i];
-      const newPathNode = {
-        node,
-        depth: currentPath.length,
-        index: i,
-        parent: currentPath.length > 0 ? currentPath[currentPath.length - 1] : null,
-        path: currentPath.length === 0 ? String(node[keyField]) : `${currentPath[currentPath.length - 1].path}/${String(node[keyField])}`
-      };
-      if (node[keyField] === target) {
-        return [...currentPath, newPathNode];
-      }
-      const children = node[childrenKey];
-      if (children && Array.isArray(children) && children.length > 0) {
-        const result = findPath(children, target, [
-          ...currentPath,
-          newPathNode
-        ]);
-        if (result) {
-          return result;
-        }
-      }
-    }
-    return null;
-  };
-  return findPath(treeData, targetKey, []);
-};
-var getNodeDepth = (treeData, targetKey, keyField = "key", childrenKey = "children") => {
-  const path = getNodePath(treeData, targetKey, keyField, childrenKey);
-  return path ? path.length - 1 : -1;
-};
-var getNodeBreadcrumb = (treeData, targetKey, keyField = "key", childrenKey = "children") => {
-  const path = getNodePath(treeData, targetKey, keyField, childrenKey);
-  return path ? path.map((p) => p.node) : [];
-};
-var getTreeStats = (treeData, childrenKey = "children") => {
-  let totalNodes = 0;
-  let maxDepth = 0;
-  let leafCount = 0;
-  const traverse = (nodes, depth) => {
-    for (const node of nodes) {
-      totalNodes++;
-      maxDepth = Math.max(maxDepth, depth);
-      const children = node[childrenKey];
-      if (children && Array.isArray(children) && children.length > 0) {
-        traverse(children, depth + 1);
-      } else {
-        leafCount++;
-      }
-    }
-  };
-  traverse(treeData, 0);
-  return { totalNodes, maxDepth, leafCount };
-};
-var mapTree = (treeData, mapper, childrenKey = "children") => {
-  const traverse = (nodes, parent) => {
-    return nodes.map((node) => {
-      const mappedNode = mapper(node, parent);
-      const children = node[childrenKey];
-      if (children && Array.isArray(children) && children.length > 0) {
-        return {
-          ...mappedNode,
-          [childrenKey]: traverse(children, node)
-        };
-      }
-      return mappedNode;
-    });
-  };
-  return traverse(treeData);
+  const result = [];
+  for (const rootNode of tree) {
+    searchRecursive(rootNode, searchValue.toLowerCase(), result);
+  }
+  return result;
 };
+
+// src/build/fromArray.ts
+import { default as default8 } from "tree-lodash";
+
+// src/utils/findFirstLeaf.ts
 var findFirstLeaf = (treeData, childrenKey = "children") => {
   for (const node of treeData) {
     const children = node[childrenKey];
@@ -444,6 +430,8 @@ var findFirstLeaf = (treeData, childrenKey = "children") => {
   }
   return null;
 };
+
+// src/utils/traverseTreeValues.ts
 var traverseTreeValues = (treeData, key, childrenKey = "children") => {
   const result = [];
   const traverse = (nodes) => {
@@ -460,6 +448,50 @@ var traverseTreeValues = (treeData, key, childrenKey = "children") => {
   traverse(treeData);
   return result;
 };
+
+// src/utils/filterCheckedLeafKeys.ts
+var filterCheckedLeafKeys = (treeData) => {
+  const result = [];
+  const traverse = (nodes) => {
+    if (!nodes || nodes.length === 0) return;
+    for (const node of nodes) {
+      if (node.checked === false) continue;
+      if (node.children && node.children.length > 0) {
+        traverse(node.children);
+      } else if (node.checked === true) {
+        result.push(node.key);
+      }
+    }
+  };
+  traverse(treeData);
+  return result;
+};
+
+// src/utils/collectLeafValuesByKey.ts
+var collectLeafValuesByKey = (nodes, targetValue, isLeafKey = "isLeaf") => {
+  for (const node of nodes) {
+    if (node.value === targetValue) {
+      if (node.children && Array.isArray(node.children) && node.children.length > 0) {
+        const leafNodes = getLeafNodes([node], isLeafKey);
+        return leafNodes.map((leaf) => leaf.value);
+      }
+      return null;
+    }
+    if (node.children && Array.isArray(node.children)) {
+      const result = collectLeafValuesByKey(
+        node.children,
+        targetValue,
+        isLeafKey
+      );
+      if (result !== null) {
+        return result;
+      }
+    }
+  }
+  return null;
+};
+
+// src/utils/convertGroupsToTreeData.ts
 var convertGroupsToTreeData = (groups, groupKey = "group", _childrenKey = "children") => {
   const groupMap = /* @__PURE__ */ new Map();
   for (const item of groups) {
@@ -482,27 +514,27 @@ export {
   convertGroupsToTreeData,
   copyNode,
   deleteNode,
+  default7 as filter,
   filterCheckedLeafKeys,
-  filterTreeNodes,
+  default4 as find,
   findFirstLeaf,
-  findNodeById as findNode,
-  collectLeafValuesByKey as findNodeAndCollectLeafValues,
   findNodeById,
   findNodeByKey,
   findNodeByMatcher,
-  nodeExistsInTree as findNodeInTree,
   findParentOf,
-  findParentOf as findTreeNode,
-  flattenTree,
+  default2 as foreach,
+  default8 as fromArray,
   getLeafNodes,
   getNodeBreadcrumb,
   getNodeDepth,
   getNodePath,
   getTreeStats,
-  mapTree,
+  default6 as map,
   moveNodeInTree,
   nodeExistsInTree,
   searchInTree,
+  default5 as some,
+  default3 as toArray,
   transformTreeKeys,
   transformTreeNodes,
   traverseTreeValues,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zid-utils/tree-utils",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "Tree data structure utility functions",
   "repository": "github:huangzida/utils-packages",
   "type": "module",
@@ -19,8 +19,11 @@
   ],
   "devDependencies": {
     "tsup": "^8.0.2",
-    "vitest": "^2.0.0",
-    "typescript": "^5.4.5"
+    "typescript": "^5.4.5",
+    "vitest": "^2.0.0"
+  },
+  "dependencies": {
+    "tree-lodash": "^0.4.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm --out-dir dist --clean",