tree-processor 0.6.2 → 0.7.0

package/README.md

@@ -2,7 +2,7 @@
 
 一个轻量级的树结构数据处理工具库，使用 TypeScript 编写，支持 tree-shaking，每个格式打包体积约 **3-4 KB**（ESM: 3.25 KB，CJS: 3.42 KB，UMD: 3.56 KB）。
 
-目前已支持 mapTree、forEachTree、filterTree、findTree、pushTree、unshiftTree、popTree、shiftTree、someTree、everyTree、includesTree、atTree、indexOfTree、atIndexOfTree、getParentTree、nodeDepthMap、dedupTree、removeTree、isEmptyTree、isSingleTree 和 isMultipleTrees。每个方法的最后一个参数可以自定义 children 和 id 的属性名。
+目前已支持 mapTree、forEachTree、filterTree、findTree、pushTree、unshiftTree、popTree、shiftTree、someTree、everyTree、includesTree、atTree、indexOfTree、atIndexOfTree、dedupTree、removeTree、getParentTree、getChildrenTree、getSiblingsTree、getNodeDepthMap、getNodeDepth、isEmptyTreeData、isEmptySingleTreeData、isSingleTreeData 和 isTreeData。每个方法的最后一个参数可以自定义 children 和 id 的属性名。
 
 ## ✨ 特性
 
@@ -12,7 +12,7 @@
 - 🎯 **类似数组 API** - 提供 map、filter、find 等熟悉的数组方法
 - ⚙️ **自定义字段名** - 支持自定义 children 和 id 字段名
 - ✅ **零依赖** - 无外部依赖，开箱即用
-- 🧪 **完善的测试覆盖** - 包含 160 个测试用例，覆盖基础功能、边界情况、异常处理、复杂场景、npm 包导入等
+- 🧪 **完善的测试覆盖** - 包含 200 个测试用例，覆盖基础功能、边界情况、异常处理、复杂场景、npm 包导入等
 
 ## 📦 安装
 
@@ -54,6 +54,11 @@ const { mapTree, filterTree } = require('tree-processor')
 - ✅ 更好的代码提示和类型检查
 - ✅ 更清晰的依赖关系
 
+**关于类型导入：**
+- TypeScript 会自动从函数签名推断类型，**大多数情况下不需要显式引入类型**
+- 只有在需要显式声明变量类型时才需要引入类型（如 `const treeData: TreeData = [...]`）
+- 使用 `import type` 导入类型不会增加运行时体积（类型在编译时会被移除）
+
 ### 示例树结构数据
 
 以下示例数据将用于后续所有方法的演示：
@@ -84,12 +89,23 @@ const treeData = [
 
 ### mapTree（遍历树结构数据的方法）
 
-遍历树结构数据，对每个节点执行回调函数。
+遍历树结构数据，对每个节点执行回调函数，返回映射后的数组。
 
 ```javascript
-t.mapTree(treeData, (item) => {
-    console.log(item)
-})
+// 获取所有节点的名称
+const nodeNames = t.mapTree(treeData, (node) => node.name)
+console.log(nodeNames) // ['node1', 'node2', 'node4', 'node5', 'node3', 'node6']
+
+// 获取所有节点的ID
+const nodeIds = t.mapTree(treeData, (node) => node.id)
+console.log(nodeIds) // [1, 2, 4, 5, 3, 6]
+
+// 修改节点数据
+const modifiedNodes = t.mapTree(treeData, (node) => ({
+  ...node,
+  label: node.name
+}))
+console.log(modifiedNodes) // 返回包含 label 字段的新数组
 ```
 
 ### forEachTree（遍历树结构数据的方法，不返回值）
@@ -97,11 +113,23 @@ t.mapTree(treeData, (item) => {
 遍历树结构数据，对每个节点执行回调函数。与 mapTree 的区别是不返回值，性能更好，适合只需要遍历而不需要返回结果的场景。
 
 ```javascript
-t.forEachTree(treeData, (item) => {
-    console.log(item)
-    // 可以在这里修改节点
-    item.visited = true
+// 遍历所有节点并打印
+t.forEachTree(treeData, (node) => {
+    console.log(node)
+})
+
+// 修改节点属性
+t.forEachTree(treeData, (node) => {
+    node.visited = true
+    node.timestamp = Date.now()
 })
+
+// 统计节点数量
+let nodeCount = 0
+t.forEachTree(treeData, () => {
+    nodeCount++
+})
+console.log(nodeCount) // 节点总数
 ```
 
 ### filterTree（树结构数据的filter方法）
@@ -109,84 +137,117 @@ t.forEachTree(treeData, (item) => {
 过滤树结构数据，返回满足条件的节点。
 
 ```javascript
-const values = ['node1', 'node2', 'node3'];
-const result = t.filterTree(treeData, (item) => {
-    return values.includes(item.name)
+// 过滤出名称包含 'node' 的节点
+const filteredNodes = t.filterTree(treeData, (node) => {
+    return node.name.includes('node')
 })
+console.log(filteredNodes) // 返回满足条件的节点数组
 
-console.log(result)
+// 过滤出ID大于2的节点
+const nodesWithLargeId = t.filterTree(treeData, (node) => node.id > 2)
+console.log(nodesWithLargeId) // 返回ID大于2的节点数组
+
+// 过滤出没有子节点的节点（叶子节点）
+const leafNodes = t.filterTree(treeData, (node) => {
+    return !node.children || node.children.length === 0
+})
+console.log(leafNodes) // 返回所有叶子节点
 ```
 
 ### findTree（树结构数据的find方法）
 
-查找树结构数据中满足条件的第一个节点。
+查找树结构数据中满足条件的第一个节点。如果未找到，返回 null。
 
 ```javascript
-const result = t.findTree(treeData, (item) => {
-    return item.hasOwnProperty('children')
-})
+// 查找ID为2的节点
+const foundNode = t.findTree(treeData, (node) => node.id === 2)
+console.log(foundNode) // 返回找到的节点对象，未找到返回 null
+
+// 查找名称为 'node3' 的节点
+const node3 = t.findTree(treeData, (node) => node.name === 'node3')
+console.log(node3) // { id: 3, name: 'node3', children: [...] }
 
-console.log(result)
+// 查找不存在的节点
+const nodeNotFound = t.findTree(treeData, (node) => node.id === 999)
+console.log(nodeNotFound) // null
 ```
 
 ### pushTree（在指定节点下添加子节点到末尾）
 
-targetParentId 为目标节点的 id，newNode 为往该节点添加的数据。
+在指定节点下添加子节点到末尾。返回 true 表示添加成功，false 表示未找到目标节点。
 
 ```javascript
-t.pushTree(treeData, targetParentId, newNode);
-
-console.log(treeData)
+// 在ID为1的节点下添加新子节点
+const addSuccess = t.pushTree(treeData, 1, { id: 7, name: 'node7' })
+console.log(addSuccess) // true
+console.log(treeData) // 新节点已添加到 children 数组末尾
+
+// 尝试在不存在的节点下添加
+const addFailed = t.pushTree(treeData, 999, { id: 8, name: 'node8' })
+console.log(addFailed) // false，未找到目标节点
 ```
 
 ### unshiftTree（在指定节点下添加子节点到开头）
 
-targetParentId 为目标节点的 id，newNode 为往该节点添加的数据。
+在指定节点下添加子节点到开头。返回 true 表示添加成功，false 表示未找到目标节点。
 
 ```javascript
-t.unshiftTree(treeData, targetParentId, newNode);
-
-console.log(treeData)
+// 在ID为1的节点下添加新子节点到开头
+const unshiftSuccess = t.unshiftTree(treeData, 1, { id: 7, name: 'node7' })
+console.log(unshiftSuccess) // true
+console.log(treeData) // 新节点已添加到 children 数组开头
 ```
 
 ### popTree（删除指定节点下的最后一个子节点）
 
-rootId 为目标节点的 id，此方法可删除 rootId 下的最后一个子节点。
+删除指定节点下的最后一个子节点。返回被删除的节点，如果节点不存在或没有子节点则返回 false。
 
 ```javascript
-t.popTree(treeData, rootId);
+// 删除ID为1的节点下的最后一个子节点
+const removedNode = t.popTree(treeData, 1)
+console.log(removedNode) // 返回被删除的节点对象，或 false
 
-console.log(treeData)
+// 尝试删除不存在的节点下的子节点
+const popFailed = t.popTree(treeData, 999)
+console.log(popFailed) // false
 ```
 
 ### shiftTree（删除指定节点下的第一个子节点）
 
-rootId 为目标节点的 id，此方法可删除 rootId 下的第一个子节点。
+删除指定节点下的第一个子节点。返回被删除的节点，如果节点不存在或没有子节点则返回 false。
 
 ```javascript
-t.shiftTree(treeData, rootId);
-
-console.log(treeData)
+// 删除ID为1的节点下的第一个子节点
+const shiftedNode = t.shiftTree(treeData, 1)
+console.log(shiftedNode) // 返回被删除的节点对象，或 false
 ```
 
 ### someTree（树结构数据的some方法）
 
-检查树结构数据中是否存在满足条件的节点。
+检查树结构数据中是否存在满足条件的节点。只要有一个节点满足条件就返回 true。
 
 ```javascript
-const result = t.someTree(treeData, item => item.name === 'jack')
+// 检查是否存在名称为 'node2' 的节点
+const hasNode2 = t.someTree(treeData, node => node.name === 'node2')
+console.log(hasNode2) // true
 
-console.log(result)
+// 检查是否存在ID大于10的节点
+const hasLargeId = t.someTree(treeData, node => node.id > 10)
+console.log(hasLargeId) // false
 ```
 
 ### everyTree（树结构数据的every方法）
 
-检查树结构数据中是否所有节点都满足条件。
+检查树结构数据中是否所有节点都满足条件。只有所有节点都满足条件才返回 true。
 
 ```javascript
-const result = t.everyTree(treeData, item => item.age >= 18)
+// 检查所有节点的ID是否都大于0
+const allIdsPositive = t.everyTree(treeData, node => node.id > 0)
+console.log(allIdsPositive) // true
 
-console.log(result)
+// 检查所有节点是否都有 name 属性
+const allHaveName = t.everyTree(treeData, node => node.name)
+console.log(allHaveName) // 根据实际数据返回 true 或 false
 ```
 
 ### includesTree（检查树中是否包含指定节点）
@@ -194,146 +255,370 @@ console.log(result)
 检查树结构数据中是否包含指定ID的节点。
 
 ```javascript
-const hasNode = t.includesTree(treeData, targetId)
+const nodeId = 2
+const hasNode = t.includesTree(treeData, nodeId)
 
 console.log(hasNode) // true 表示包含该节点，false 表示不包含
 ```
 
 ### atTree（根据父节点ID和子节点索引获取节点）
 
-parentId 为指定父节点的 id，nodeIndex 为子节点的索引，可传负数，和数组的 at 方法一样。
+根据父节点ID和子节点索引获取节点。支持负数索引，和数组的 at 方法一样。未找到返回 null。
 
 ```javascript
-const result = t.atTree(treeData, parentId, nodeIndex)
+// 获取ID为1的节点的第一个子节点（索引0）
+const firstChildNode = t.atTree(treeData, 1, 0)
+console.log(firstChildNode) // 返回第一个子节点
+
+// 获取最后一个子节点（负数索引）
+const lastChildNode = t.atTree(treeData, 1, -1)
+console.log(lastChildNode) // 返回最后一个子节点
 
-console.log(result)
+// 索引超出范围返回 null
+const nodeNotFound = t.atTree(treeData, 1, 10)
+console.log(nodeNotFound) // null
 ```
 
 ### indexOfTree（返回从根节点到目标节点的索引路径）
 
-返回一个数组，值为从根节点开始到 targetId 所在节点的索引，返回值可以传入 atIndexOfTree 的第二个参数进行取值。
+返回一个数组，值为从根节点开始到 targetId 所在节点的索引路径。未找到返回 null。返回值可以传入 atIndexOfTree 的第二个参数进行取值。
 
 ```javascript
-const result = t.indexOfTree(treeData, targetId)
-
-console.log(result)
+// 获取ID为4的节点的索引路径
+const nodePath = t.indexOfTree(treeData, 4)
+console.log(nodePath) // [0, 0, 0] 表示根节点 -> 第一个子节点 -> 第一个子节点
+
+// 未找到节点返回 null
+const pathNotFound = t.indexOfTree(treeData, 999)
+console.log(pathNotFound) // null
+
+// 结合 atIndexOfTree 使用
+const indexPath = t.indexOfTree(treeData, 4)
+const nodeByPath = t.atIndexOfTree(treeData, indexPath)
+console.log(nodeByPath) // 获取到ID为4的节点
 ```
 
 ### atIndexOfTree（根据索引路径获取节点）
 
-传入节点数据的下标数组，返回节点数据。
+根据索引路径获取节点。路径无效或超出范围返回 null。
 
 ```javascript
-const result = t.atIndexOfTree(treeData, [0, 1, 0])
+// 根据索引路径获取节点
+const nodeByIndexPath = t.atIndexOfTree(treeData, [0, 1, 0])
+console.log(nodeByIndexPath) // 返回对应路径的节点对象
+
+// 结合 indexOfTree 使用
+const targetPath = t.indexOfTree(treeData, 4)
+const targetNode = t.atIndexOfTree(treeData, targetPath)
+console.log(targetNode) // 获取到ID为4的节点
+
+// 路径无效返回 null
+const invalidPath = t.atIndexOfTree(treeData, [999])
+console.log(invalidPath) // null
+```
 
-console.log(result)
+### dedupTree（树结构对象数组去重方法）
+
+树结构对象数组去重方法，根据指定的键去除重复节点。保留第一次出现的节点。
+
+```javascript
+// 根据 id 字段去重
+const uniqueTreeData = t.dedupTree(treeData, 'id')
+console.log(uniqueTreeData) // 返回去重后的树结构数据
+
+// 根据 name 字段去重
+const uniqueByNameTree = t.dedupTree(treeData, 'name')
+console.log(uniqueByNameTree) // 返回根据 name 去重后的数据
+```
+
+### removeTree（删除指定节点）
+
+删除树结构数据中指定ID的节点，包括根节点和子节点。
+
+```javascript
+const nodeIdToRemove = 2
+const removeSuccess = t.removeTree(treeData, nodeIdToRemove)
+
+console.log(removeSuccess) // true 表示删除成功，false 表示未找到节点
+console.log(treeData) // 删除后的树结构
 ```
 
 ### getParentTree（获取节点的父节点）
 
-获取指定节点的父节点。如果节点是根节点，返回 null。
+获取指定节点的父节点。如果节点是根节点或未找到，返回 null。
 
 ```javascript
-const parent = t.getParentTree(treeData, targetId)
+// 获取ID为2的节点的父节点
+const parentNode = t.getParentTree(treeData, 2)
+console.log(parentNode) // 返回父节点对象 { id: 1, name: 'node1', ... }
+
+// 根节点没有父节点，返回 null
+const rootParentNode = t.getParentTree(treeData, 1)
+console.log(rootParentNode) // null
 
-console.log(parent) // 返回父节点对象，如果未找到或节点是根节点则返回 null
+// 未找到节点返回 null
+const parentNotFound = t.getParentTree(treeData, 999)
+console.log(parentNotFound) // null
 ```
 
-### nodeDepthMap（返回节点ID到深度的映射）
+### getChildrenTree（获取节点的所有直接子节点）
 
-返回一个字典，键代表节点的 id，值代表该节点在数据的第几层。
+获取指定节点的所有直接子节点。如果未找到节点或没有子节点，返回空数组。
 
 ```javascript
-const result = t.nodeDepthMap(treeData)
+// 获取ID为1的节点的所有子节点
+const children = t.getChildrenTree(treeData, 1)
+console.log(children) // 返回子节点数组 [{ id: 2, ... }, { id: 3, ... }]
 
-console.log(result)
+// 节点没有子节点，返回空数组
+const emptyChildren = t.getChildrenTree(treeData, 4)
+console.log(emptyChildren) // []
+
+// 未找到节点返回空数组
+const notFound = t.getChildrenTree(treeData, 999)
+console.log(notFound) // []
+
+// 支持自定义字段名
+const customTree = [
+  {
+    nodeId: 1,
+    name: 'root',
+    subNodes: [
+      { nodeId: 2, name: 'child1' },
+      { nodeId: 3, name: 'child2' },
+    ],
+  },
+];
+const fieldNames = { children: 'subNodes', id: 'nodeId' };
+const customChildren = t.getChildrenTree(customTree, 1, fieldNames)
+console.log(customChildren) // 返回子节点数组
 ```
 
-### dedupTree（树结构对象数组去重方法）
+### getSiblingsTree（获取节点的所有兄弟节点）
 
-树结构对象数组去重方法，第一个参数为需要去重的数据，第二个参数为以哪个键去重。
+获取指定节点的所有兄弟节点（包括自己）。如果未找到节点，返回空数组。根节点的兄弟节点是其他根节点。
 
 ```javascript
-const result = t.dedupTree(treeData, 'id')
+// 获取ID为2的节点的所有兄弟节点（包括自己）
+const siblings = t.getSiblingsTree(treeData, 2)
+console.log(siblings) // 返回兄弟节点数组 [{ id: 2, ... }, { id: 3, ... }]
+
+// 根节点的兄弟节点是其他根节点
+const multiRoot = [
+  { id: 1, children: [{ id: 2 }] },
+  { id: 3, children: [{ id: 4 }] },
+];
+const rootSiblings = t.getSiblingsTree(multiRoot, 1)
+console.log(rootSiblings) // 返回所有根节点 [{ id: 1, ... }, { id: 3, ... }]
 
-console.log(result)
+// 未找到节点返回空数组
+const notFound = t.getSiblingsTree(treeData, 999)
+console.log(notFound) // []
+
+// 支持自定义字段名
+const customTree = [
+  {
+    nodeId: 1,
+    name: 'root',
+    subNodes: [
+      { nodeId: 2, name: 'child1' },
+      { nodeId: 3, name: 'child2' },
+      { nodeId: 4, name: 'child3' },
+    ],
+  },
+];
+const fieldNames = { children: 'subNodes', id: 'nodeId' };
+const customSiblings = t.getSiblingsTree(customTree, 2, fieldNames)
+console.log(customSiblings) // 返回兄弟节点数组（包括自己）
 ```
 
-### removeTree（删除指定节点）
+### getNodeDepthMap（返回节点ID到深度的映射）
 
-删除树结构数据中指定ID的节点，包括根节点和子节点。
+返回一个字典，键代表节点的 id，值代表该节点在数据的第几层。深度从1开始，根节点深度为1。
 
 ```javascript
-const success = t.removeTree(treeData, targetId)
+// 获取所有节点的深度映射
+const nodeDepthMap = t.getNodeDepthMap(treeData)
+console.log(nodeDepthMap) // { 1: 1, 2: 2, 3: 2, 4: 3, 5: 3, 6: 3 }
 
-console.log(success) // true 表示删除成功，false 表示未找到节点
-console.log(treeData) // 删除后的树结构
+// 获取特定节点的深度
+const node2Depth = nodeDepthMap[2]
+console.log(node2Depth) // 2
+
+// 空树返回空对象
+const emptyDepthMap = t.getNodeDepthMap([])
+console.log(emptyDepthMap) // {}
 ```
 
-### isEmptyTree（检查树是否为空）
+### getNodeDepth（获取单个节点的深度）
 
-检查树结构数据是否为空。
+获取指定节点的深度。深度从1开始，根节点深度为1。
 
 ```javascript
-const isEmpty = t.isEmptyTree(treeData)
+// 获取根节点的深度
+const rootDepth = t.getNodeDepth(treeData, 1)
+console.log(rootDepth) // 1
+
+// 获取子节点的深度
+const childDepth = t.getNodeDepth(treeData, 2)
+console.log(childDepth) // 2
 
-console.log(isEmpty) // true 表示树为空，false 表示树不为空
+// 获取深层节点的深度
+const deepDepth = t.getNodeDepth(treeData, 4)
+console.log(deepDepth) // 3
+
+// 未找到节点返回 null
+const notFound = t.getNodeDepth(treeData, 999)
+console.log(notFound) // null
+
+// 支持自定义字段名
+const customTree = [
+  {
+    nodeId: 1,
+    name: 'root',
+    subNodes: [
+      { nodeId: 2, name: 'child' },
+    ],
+  },
+];
+const fieldNames = { children: 'subNodes', id: 'nodeId' };
+const depth = t.getNodeDepth(customTree, 2, fieldNames)
+console.log(depth) // 2
 ```
 
-### isSingleTree（判断数据是否是单个树结构）
+**与 getNodeDepthMap 的区别：**
+- `getNodeDepthMap` - 批量获取所有节点的深度（一次性计算所有节点）
+- `getNodeDepth` - 只获取单个节点的深度（只计算目标节点，效率更高）
+
+### isEmptyTreeData（检查树结构数据是否为空）
 
-判断数据是否是单个树结构（单个对象）。树结构必须是一个对象（不能是数组、null、undefined 或基本类型），如果存在 children 字段，必须是数组类型，并且会递归检查所有子节点。
+检查树结构数据（数组）是否为空。空数组、null、undefined 都视为空。此函数支持 fieldNames 参数以保持 API 一致性，但该参数不生效（因为只检查数组是否为空，不访问 children 或 id 字段）。
 
 ```javascript
-// 有效的单个树结构
-const tree = {
+// 检查树结构数据是否为空
+const isEmptyTree = t.isEmptyTreeData(treeData)
+console.log(isEmptyTree) // false（有数据）
+
+// 空数组返回 true
+const isEmptyArray = t.isEmptyTreeData([])
+console.log(isEmptyArray) // true
+
+// null 或 undefined 返回 true
+const isNullTree = t.isEmptyTreeData(null)
+console.log(isNullTree) // true
+
+// 支持 fieldNames 参数（保持 API 一致性，但不生效）
+const fieldNames = { children: 'subNodes', id: 'nodeId' };
+const isEmptyWithFieldNames = t.isEmptyTreeData(treeData, fieldNames)
+console.log(isEmptyWithFieldNames) // false（结果与不传 fieldNames 相同）
+```
+
+### isEmptySingleTreeData（检查单个树结构数据是否为空）
+
+检查单个树结构数据是否为空。如果数据不是有效的单个树结构数据、没有 children 字段，或者 children 是空数组，则视为空。如果有子节点（children 数组不为空），即使子节点本身是空的，树也不为空。
+
+```javascript
+// 没有 children 字段，视为空
+const tree1 = { id: 1, name: 'node1' };
+const isEmpty1 = t.isEmptySingleTreeData(tree1)
+console.log(isEmpty1) // true
+
+// children 是空数组，视为空
+const tree2 = {
+  id: 1,
+  name: 'node1',
+  children: [],
+};
+const isEmpty2 = t.isEmptySingleTreeData(tree2)
+console.log(isEmpty2) // true
+
+// 有子节点，不为空
+const tree3 = {
   id: 1,
   name: 'node1',
   children: [
     { id: 2, name: 'node2' },
-    { id: 3, name: 'node3' },
   ],
 };
+const isEmpty3 = t.isEmptySingleTreeData(tree3)
+console.log(isEmpty3) // false
 
-const isValid = t.isSingleTree(tree)
-console.log(isValid) // true
-
-// 无效的树结构
-const invalidTree = {
+// 有子节点，即使子节点本身是空的，树也不为空
+const tree4 = {
   id: 1,
-  children: null, // children 不能是 null
+  name: 'node1',
+  children: [
+    { id: 2, name: 'node2', children: [] },
+    { id: 3, name: 'node3' }, // 没有children字段
+  ],
 };
-
-const isInvalid = t.isSingleTree(invalidTree)
-console.log(isInvalid) // false
+const isEmpty4 = t.isEmptySingleTreeData(tree4)
+console.log(isEmpty4) // false（因为有子节点，即使子节点是空的）
 
 // 支持自定义字段名
 const customTree = {
   nodeId: 1,
   name: 'node1',
-  subNodes: [
-    { nodeId: 2, name: 'node2' },
+  subNodes: [],
+};
+const fieldNames = { children: 'subNodes', id: 'nodeId' };
+const isEmptyCustom = t.isEmptySingleTreeData(customTree, fieldNames)
+console.log(isEmptyCustom) // true
+```
+
+### isSingleTreeData（判断数据是否是单个树结构数据）
+
+判断数据是否是单个树结构数据（单个对象）。树结构数据必须是一个对象（不能是数组、null、undefined 或基本类型），如果存在 children 字段，必须是数组类型，并且会递归检查所有子节点。
+
+```javascript
+// 有效的单个树结构数据
+const tree = {
+  id: 1,
+  name: 'node1',
+  children: [
+    { id: 2, name: 'node2' },
+    { id: 3, name: 'node3' },
   ],
 };
+const isValid = t.isSingleTreeData(tree)
+console.log(isValid) // true
+
+// 没有 children 字段也是有效的（只有根节点）
+const singleNode = { id: 1, name: 'node1' }
+console.log(t.isSingleTreeData(singleNode)) // true
+
+// 数组不是单个树结构数据
+console.log(t.isSingleTreeData([])) // false
 
+// null 或 undefined 不是有效的树结构数据
+console.log(t.isSingleTreeData(null)) // false
+console.log(t.isSingleTreeData(undefined)) // false
+
+// children 不能是 null
+const invalidTree = { id: 1, children: null }
+console.log(t.isSingleTreeData(invalidTree)) // false
+
+// 支持自定义字段名
+const customTree = {
+  nodeId: 1,
+  name: 'node1',
+  subNodes: [{ nodeId: 2, name: 'node2' }],
+};
 const fieldNames = { children: 'subNodes', id: 'nodeId' };
-const isValidCustom = t.isSingleTree(customTree, fieldNames)
-console.log(isValidCustom) // true
+console.log(t.isSingleTreeData(customTree, fieldNames)) // true
 ```
 
-### isMultipleTrees（判断数据是否是多个树结构）
+### isTreeData（判断数据是否是树结构数据）
 
-判断数据是否是多个树结构（数组）。多个树结构必须是一个数组，数组中的每个元素都必须是有效的单个树结构。
+判断数据是否是树结构数据（数组）。树结构数据必须是一个数组，数组中的每个元素都必须是有效的单个树结构数据。
 
 ```javascript
-// 有效的多个树结构
+// 有效的树结构数据（森林）
 const forest = [
   {
     id: 1,
     name: 'node1',
-    children: [
-      { id: 2, name: 'node2' },
-    ],
+    children: [{ id: 2, name: 'node2' }],
   },
   {
     id: 3,
@@ -341,38 +626,35 @@ const forest = [
     children: [{ id: 4, name: 'node4' }],
   },
 ];
+console.log(t.isTreeData(forest)) // true
 
-const isValid = t.isMultipleTrees(forest)
-console.log(isValid) // true
+// 空数组也是有效的树结构数据（空森林）
+console.log(t.isTreeData([])) // true
 
-// 空数组也是有效的多个树结构
-const emptyForest = []
-const isEmptyValid = t.isMultipleTrees(emptyForest)
-console.log(isEmptyValid) // true
+// 单个对象不是树结构数据（应该用 isSingleTreeData）
+console.log(t.isTreeData({ id: 1 })) // false
 
-// 无效的多个树结构
+// 数组包含非树结构元素，返回 false
 const invalidForest = [
   { id: 1, children: [{ id: 2 }] },
-  'not a tree', // 数组元素必须是树结构
+  'not a tree', // 无效元素
 ];
+console.log(t.isTreeData(invalidForest)) // false
 
-const isInvalid = t.isMultipleTrees(invalidForest)
-console.log(isInvalid) // false
+// null 或 undefined 不是有效的树结构数据
+console.log(t.isTreeData(null)) // false
+console.log(t.isTreeData(undefined)) // false
 
 // 支持自定义字段名
 const customForest = [
   {
     nodeId: 1,
     name: 'node1',
-    subNodes: [
-      { nodeId: 2, name: 'node2' },
-    ],
+    subNodes: [{ nodeId: 2, name: 'node2' }],
   },
 ];
-
 const fieldNames = { children: 'subNodes', id: 'nodeId' };
-const isValidCustom = t.isMultipleTrees(customForest, fieldNames)
-console.log(isValidCustom) // true
+console.log(t.isTreeData(customForest, fieldNames)) // true
 ```
 
 ## 自定义字段名
@@ -380,10 +662,16 @@ console.log(isValidCustom) // true
 所有方法都支持自定义 children 和 id 的属性名，通过最后一个参数传入配置对象：
 
 ```javascript
+// 使用默认字段名
+const foundNode1 = t.findTree(treeData, (node) => node.id === 2)
+
+// 使用自定义字段名
 const fieldNames = { children: 'subNodes', id: 'nodeId' };
-const result = t.findTree(treeData, (item) => item.nodeId === 2, fieldNames);
+const foundNode2 = t.findTree(customTreeData, (node) => node.nodeId === 2, fieldNames);
 ```
 
+**注意：** 所有 25 个函数都支持 `fieldNames` 参数，保持 API 一致性。即使某些函数（如 `isEmptyTreeData`）中该参数不生效，也可以传入以保持代码风格一致。
+
 ## 测试
 
 ### 运行测试

package/dist/index.d.ts

@@ -16,15 +16,19 @@ export declare function everyTree(tree: TreeData, filterFn: (node: TreeNode) =>
 export declare function atTree(tree: TreeData, parentId: any, nodeIndex: number, fieldNames?: FieldNames): TreeNode | null;
 export declare function indexOfTree(tree: TreeData, targetId: any, fieldNames?: FieldNames): number[] | null;
 export declare function atIndexOfTree(tree: TreeData, path: number[], fieldNames?: FieldNames): TreeNode | null;
-export declare function nodeDepthMap(tree: TreeData, fieldNames?: FieldNames): Record<string, number>;
+export declare function getNodeDepthMap(tree: TreeData, fieldNames?: FieldNames): Record<string, number>;
+export declare function getNodeDepth(tree: TreeData, targetId: any, fieldNames?: FieldNames): number | null;
 export declare function dedupTree(tree: TreeData, key: string, fieldNames?: FieldNames): TreeData;
 export declare function removeTree(tree: TreeData, targetId: any, fieldNames?: FieldNames): boolean;
 export declare function forEachTree(tree: TreeData, callback: (node: TreeNode) => void, fieldNames?: FieldNames): void;
-export declare function isEmptyTree(tree: TreeData): boolean;
+export declare function isEmptyTreeData(tree: TreeData, fieldNames?: FieldNames): boolean;
+export declare function isEmptySingleTreeData(data: any, fieldNames?: FieldNames): boolean;
+export declare function getChildrenTree(tree: TreeData, targetId: any, fieldNames?: FieldNames): TreeNode[];
+export declare function getSiblingsTree(tree: TreeData, targetId: any, fieldNames?: FieldNames): TreeNode[];
 export declare function getParentTree(tree: TreeData, targetId: any, fieldNames?: FieldNames): TreeNode | null;
 export declare function includesTree(tree: TreeData, targetId: any, fieldNames?: FieldNames): boolean;
-export declare function isSingleTree(data: any, fieldNames?: FieldNames): boolean;
-export declare function isMultipleTrees(data: any, fieldNames?: FieldNames): boolean;
+export declare function isSingleTreeData(data: any, fieldNames?: FieldNames): boolean;
+export declare function isTreeData(data: any, fieldNames?: FieldNames): boolean;
 declare const treeProcessor: {
     mapTree: typeof mapTree;
     filterTree: typeof filterTree;
@@ -38,15 +42,19 @@ declare const treeProcessor: {
     atTree: typeof atTree;
     indexOfTree: typeof indexOfTree;
     atIndexOfTree: typeof atIndexOfTree;
-    nodeDepthMap: typeof nodeDepthMap;
+    getNodeDepthMap: typeof getNodeDepthMap;
+    getNodeDepth: typeof getNodeDepth;
     dedupTree: typeof dedupTree;
     removeTree: typeof removeTree;
     forEachTree: typeof forEachTree;
-    isEmptyTree: typeof isEmptyTree;
+    isEmptyTreeData: typeof isEmptyTreeData;
+    isEmptySingleTreeData: typeof isEmptySingleTreeData;
     getParentTree: typeof getParentTree;
+    getChildrenTree: typeof getChildrenTree;
+    getSiblingsTree: typeof getSiblingsTree;
     includesTree: typeof includesTree;
-    isSingleTree: typeof isSingleTree;
-    isMultipleTrees: typeof isMultipleTrees;
+    isSingleTreeData: typeof isSingleTreeData;
+    isTreeData: typeof isTreeData;
 };
 export default treeProcessor;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;CACZ;AAaD,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAK3C,MAAM,MAAM,QAAQ,GAAG,QAAQ,EAAE,CAAC;AASlC,wBAAgB,OAAO,CACrB,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,GAAG,EACjC,UAAU,GAAE,UAAgC,GAC3C,GAAG,EAAE,CAeP;AASD,wBAAgB,UAAU,CACxB,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,EACpD,UAAU,GAAE,UAAgC,GAC3C,QAAQ,CAiBV;AASD,wBAAgB,QAAQ,CACtB,IAAI,EAAE,QAAQ,EACd,WAAW,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,OAAO,EACxC,UAAU,GAAE,UAAgC,GAC3C,QAAQ,GAAG,IAAI,CAcjB;AAUD,wBAAgB,QAAQ,CACtB,IAAI,EAAE,QAAQ,EACd,cAAc,EAAE,GAAG,EACnB,OAAO,EAAE,QAAQ,EACjB,UAAU,GAAE,UAAgC,GAC3C,OAAO,CAqBT;AAUD,wBAAgB,WAAW,CACzB,IAAI,EAAE,QAAQ,EACd,cAAc,EAAE,GAAG,EACnB,OAAO,EAAE,QAAQ,EACjB,UAAU,GAAE,UAAgC,GAC3C,OAAO,CAqBT;AASD,wBAAgB,OAAO,CACrB,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,GAAG,EACX,UAAU,GAAE,UAAgC,GAC3C,OAAO,CAsBT;AASD,wBAAgB,SAAS,CACvB,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,GAAG,EACX,UAAU,GAAE,UAAgC,GAC3C,OAAO,CAsBT;AASD,wBAAgB,QAAQ,CACtB,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,OAAO,EACrC,UAAU,GAAE,UAAgC,GAC3C,OAAO,CAaT;AASD,wBAAgB,SAAS,CACvB,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,OAAO,EACrC,UAAU,GAAE,UAAgC,GAC3C,OAAO,CAaT;AAUD,wBAAgB,MAAM,CACpB,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,GAAG,EACb,SAAS,EAAE,MAAM,EACjB,UAAU,GAAE,UAAgC,GAC3C,QAAQ,GAAG,IAAI,CAqCjB;AASD,wBAAgB,WAAW,CACzB,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,GAAG,EACb,UAAU,GAAE,UAAgC,GAC3C,MAAM,EAAE,GAAG,IAAI,CAsBjB;AASD,wBAAgB,aAAa,CAC3B,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,MAAM,EAAE,EACd,UAAU,GAAE,UAAgC,GAC3C,QAAQ,GAAG,IAAI,CA4BjB;AAQD,wBAAgB,eAAe,CAC7B,IAAI,EAAE,QAAQ,EACd,UAAU,GAAE,UAAgC,GAC3C,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAexB;AASD,wBAAgB,YAAY,CAC1B,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,GAAG,EACb,UAAU,GAAE,UAAgC,GAC3C,MAAM,GAAG,IAAI,CAqBf;AASD,wBAAgB,SAAS,CACvB,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,MAAM,EACX,UAAU,GAAE,UAAgC,GAC3C,QAAQ,CA+BV;AASD,wBAAgB,UAAU,CACxB,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,GAAG,EACb,UAAU,GAAE,UAAgC,GAC3C,OAAO,CAuBT;AAQD,wBAAgB,WAAW,CACzB,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,EAClC,UAAU,GAAE,UAAgC,GAC3C,IAAI,CAYN;AAQD,wBAAgB,eAAe,CAC7B,IAAI,EAAE,QAAQ,EACd,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAIT;AAQD,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,GAAG,EACT,UAAU,GAAE,UAAgC,GAC3C,OAAO,CAsBT;AASD,wBAAgB,eAAe,CAC7B,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,GAAG,EACb,UAAU,GAAE,UAAgC,GAC3C,QAAQ,EAAE,CAwBZ;AASD,wBAAgB,eAAe,CAC7B,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,GAAG,EACb,UAAU,GAAE,UAAgC,GAC3C,QAAQ,EAAE,CAiCZ;AASD,wBAAgB,aAAa,CAC3B,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,GAAG,EACb,UAAU,GAAE,UAAgC,GAC3C,QAAQ,GAAG,IAAI,CAqBjB;AASD,wBAAgB,YAAY,CAC1B,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,GAAG,EACb,UAAU,GAAE,UAAgC,GAC3C,OAAO,CAaT;AAQD,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,GAAG,EACT,UAAU,GAAE,UAAgC,GAC3C,OAAO,CA8BT;AAQD,wBAAgB,UAAU,CACxB,IAAI,EAAE,GAAG,EACT,UAAU,GAAE,UAAgC,GAC3C,OAAO,CAcT;AAKD,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BlB,CAAC;AAEF,eAAe,aAAa,CAAC"}

package/dist/stats.html

@@ -4929,7 +4929,7 @@ var drawChart = (function (exports) {
   </script>
   <script>
     /*<!--*/
-    const data = {"version":2,"tree":{"name":"root","children":[{"name":"tree-processor.esm.js","children":[{"name":"src/index.ts","uid":"3fa892f6-1"}]}],"isRoot":true},"nodeParts":{"3fa892f6-1":{"renderedLength":12266,"gzipLength":1681,"brotliLength":1475,"metaUid":"3fa892f6-0"}},"nodeMetas":{"3fa892f6-0":{"id":"\\src\\index.ts","moduleParts":{"tree-processor.esm.js":"3fa892f6-1"},"imported":[],"importedBy":[],"isEntry":true}},"env":{"rollup":"4.56.0"},"options":{"gzip":true,"brotli":true,"sourcemap":false}};
+    const data = {"version":2,"tree":{"name":"root","children":[{"name":"tree-processor.esm.js","children":[{"name":"src/index.ts","uid":"f5d7d230-1"}]}],"isRoot":true},"nodeParts":{"f5d7d230-1":{"renderedLength":14963,"gzipLength":1892,"brotliLength":1670,"metaUid":"f5d7d230-0"}},"nodeMetas":{"f5d7d230-0":{"id":"\\src\\index.ts","moduleParts":{"tree-processor.esm.js":"f5d7d230-1"},"imported":[],"importedBy":[],"isEntry":true}},"env":{"rollup":"4.56.0"},"options":{"gzip":true,"brotli":true,"sourcemap":false}};
 
     const run = () => {
       const width = window.innerWidth;

package/dist/tree-processor.cjs.js

@@ -6,65 +6,83 @@ return function r(n){for(const o of n){i.push(e(o))
 const n=o[t.children]
 Array.isArray(n)&&n.length>0&&r(n)}}(n),i}function e(n,e,t=r){const i=[]
 return function r(n){n.forEach((n,o)=>{e(n,o)&&i.push(n)
-const s=n[t.children]
-Array.isArray(s)&&s.length>0&&r(s,o)})}(n),i}function t(n,e,i=r){for(const r of n){if(e(r))return r
+const u=n[t.children]
+Array.isArray(u)&&u.length>0&&r(u,o)})}(n),i}function t(n,e,i=r){for(const r of n){if(e(r))return r
 const n=r[i.children]
 if(Array.isArray(n)&&n.length>0){const r=t(n,e,i)
 if(r)return r}}return null}function i(n,e,t,i=r){return function r(n){for(const o of n){if(o[i.id]===e)return o[i.children]||(o[i.children]=[]),o[i.children].push(t),!0
 const n=o[i.children]
 if(Array.isArray(n)&&n.length>0&&r(n))return!0}return!1}(n)}function o(n,e,t,i=r){return function r(n){for(const o of n){if(o[i.id]===e)return o[i.children]||(o[i.children]=[]),o[i.children].unshift(t),!0
 const n=o[i.children]
-if(Array.isArray(n)&&n.length>0&&r(n))return!0}return!1}(n)}function s(n,e,t=r){return function r(n){for(const i of n){if(i[t.id]===e){const r=i[t.children]
-return!!(Array.isArray(r)&&r.length>0)&&(r.pop(),!0)}const n=i[t.children]
 if(Array.isArray(n)&&n.length>0&&r(n))return!0}return!1}(n)}function u(n,e,t=r){return function r(n){for(const i of n){if(i[t.id]===e){const r=i[t.children]
+return!!(Array.isArray(r)&&r.length>0)&&(r.pop(),!0)}const n=i[t.children]
+if(Array.isArray(n)&&n.length>0&&r(n))return!0}return!1}(n)}function s(n,e,t=r){return function r(n){for(const i of n){if(i[t.id]===e){const r=i[t.children]
 return!!(Array.isArray(r)&&r.length>0)&&(r.shift(),!0)}const n=i[t.children]
-if(Array.isArray(n)&&n.length>0&&r(n))return!0}return!1}(n)}function f(n,e,t=r){for(const r of n){if(e(r))return!0
+if(Array.isArray(n)&&n.length>0&&r(n))return!0}return!1}(n)}function c(n,e,t=r){for(const r of n){if(e(r))return!0
 const n=r[t.children]
-if(Array.isArray(n)&&n.length>0&&f(n,e,t))return!0}return!1}function c(n,e,t=r){for(const r of n){if(!e(r))return!1
+if(Array.isArray(n)&&n.length>0&&c(n,e,t))return!0}return!1}function f(n,e,t=r){for(const r of n){if(!e(r))return!1
 const n=r[t.children]
-if(Array.isArray(n)&&n.length>0&&!c(n,e,t))return!1}return!0}function l(n,e,t,i=r){const o=function r(n){for(const t of n){if(t[i.id]===e)return t
+if(Array.isArray(n)&&n.length>0&&!f(n,e,t))return!1}return!0}function l(n,e,t,i=r){const o=function r(n){for(const t of n){if(t[i.id]===e)return t
 const n=t[i.children]
 if(Array.isArray(n)&&n.length>0){const e=r(n)
 if(e)return e}}return null}(n)
 if(!o)return null
-const s=o[i.children]
-if(!Array.isArray(s)||0===s.length)return null
-const u=t>=0?t:s.length+t
-return u>=0&&u<s.length?s[u]:null}function h(n,e,t=r){return function r(n,i=[]){for(let o=0;o<n.length;o++){const s=n[o],u=[...i,o]
-if(s[t.id]===e)return u
-const f=s[t.children]
-if(Array.isArray(f)&&f.length>0){const n=r(f,u)
-if(n)return n}}return null}(n)}function a(n,e,t=r){if(!Array.isArray(e)||0===e.length)return null
+const u=o[i.children]
+if(!Array.isArray(u)||0===u.length)return null
+const s=t>=0?t:u.length+t
+return s>=0&&s<u.length?u[s]:null}function a(n,e,t=r){return function r(n,i=[]){for(let o=0;o<n.length;o++){const u=n[o],s=[...i,o]
+if(u[t.id]===e)return s
+const c=u[t.children]
+if(Array.isArray(c)&&c.length>0){const n=r(c,s)
+if(n)return n}}return null}(n)}function h(n,e,t=r){if(!Array.isArray(e)||0===e.length)return null
 let i=n
 for(let r=0;r<e.length;r++){const n=e[r]
 if(!Array.isArray(i)||n<0||n>=i.length)return null
 const o=i[n]
 if(r===e.length-1)return o
-const s=o[t.children]
-if(!Array.isArray(s))return null
-i=s}return null}function d(n,e=r){const t={}
+const u=o[t.children]
+if(!Array.isArray(u))return null
+i=u}return null}function d(n,e=r){const t={}
 return function r(n,i=1){for(const o of n){t[o[e.id]]=i
 const n=o[e.children]
-Array.isArray(n)&&n.length>0&&r(n,i+1)}}(n),t}function y(n,e,t=r){const i=new Set
+Array.isArray(n)&&n.length>0&&r(n,i+1)}}(n),t}function y(n,e,t=r){return function r(n,i=1){for(const o of n){if(o[t.id]===e)return i
+const n=o[t.children]
+if(Array.isArray(n)&&n.length>0){const e=r(n,i+1)
+if(null!==e)return e}}return null}(n)}function A(n,e,t=r){const i=new Set
 return function r(n){const o=[]
-for(const s of n){const n=s[e]
+for(const u of n){const n=u[e]
 if(null!=n){if(i.has(n))continue
-i.add(n)}const u={...s},f=s[t.children]
-Array.isArray(f)&&f.length>0&&(u[t.children]=r(f)),o.push(u)}return o}(n)}function A(n,e,t=r){return function r(n){for(let i=0;i<n.length;i++){const o=n[i]
+i.add(n)}const s={...u},c=u[t.children]
+Array.isArray(c)&&c.length>0&&(s[t.children]=r(c)),o.push(s)}return o}(n)}function p(n,e,t=r){return function r(n){for(let i=0;i<n.length;i++){const o=n[i]
 if(o[t.id]===e)return n.splice(i,1),!0
-const s=o[t.children]
-if(Array.isArray(s)&&s.length>0&&r(s))return!0}return!1}(n)}function p(n,e,t=r){!function r(n){for(const i of n){e(i)
+const u=o[t.children]
+if(Array.isArray(u)&&u.length>0&&r(u))return!0}return!1}(n)}function g(n,e,t=r){!function r(n){for(const i of n){e(i)
 const n=i[t.children]
-Array.isArray(n)&&n.length>0&&r(n)}}(n)}function T(r){return!Array.isArray(r)||0===r.length}function g(n,e,t=r){return function r(n,i=null){for(const o of n){if(o[t.id]===e)return i
+Array.isArray(n)&&n.length>0&&r(n)}}(n)}function T(r){return!Array.isArray(r)||0===r.length}function x(n,e=r){if(!E(n,e))return!0
+const t=n[e.children]
+return void 0===t||(!Array.isArray(t)||0===t.length)}function D(n,e,t=r){const i=function r(n){for(const i of n){if(i[t.id]===e)return i
+const n=i[t.children]
+if(Array.isArray(n)&&n.length>0){const e=r(n)
+if(null!==e)return e}}return null}(n)
+if(!i)return[]
+const o=i[t.children]
+return Array.isArray(o)?o:[]}function m(n,e,t=r){const i=function r(n,i=null){for(const o of n){if(o[t.id]===e)return{node:o,parent:i}
+const n=o[t.children]
+if(Array.isArray(n)&&n.length>0){const e=r(n,o)
+if(null!==e)return e}}return null}(n)
+if(!i)return[]
+if(null===i.parent)return n
+const o=i.parent[t.children]
+return Array.isArray(o)?o:[]}function S(n,e,t=r){return function r(n,i=null){for(const o of n){if(o[t.id]===e)return i
 const n=o[t.children]
 if(Array.isArray(n)&&n.length>0){const e=r(n,o)
-if(null!==e)return e}}return null}(n)}function x(n,e,t=r){for(const r of n){if(r[t.id]===e)return!0
+if(null!==e)return e}}return null}(n)}function v(n,e,t=r){for(const r of n){if(r[t.id]===e)return!0
 const n=r[t.children]
-if(Array.isArray(n)&&n.length>0&&x(n,e,t))return!0}return!1}function m(n,e=r){if(!n||"object"!=typeof n||Array.isArray(n))return!1
+if(Array.isArray(n)&&n.length>0&&v(n,e,t))return!0}return!1}function E(n,e=r){if(!n||"object"!=typeof n||Array.isArray(n))return!1
 const t=n[e.children]
 if(void 0!==t){if(null===t)return!1
 if(!Array.isArray(t))return!1
-for(const r of t)if(!m(r,e))return!1}return!0}function v(n,e=r){if(!Array.isArray(n))return!1
-for(const r of n)if(!m(r,e))return!1
-return!0}const M={mapTree:n,filterTree:e,findTree:t,pushTree:i,unshiftTree:o,popTree:s,shiftTree:u,someTree:f,everyTree:c,atTree:l,indexOfTree:h,atIndexOfTree:a,nodeDepthMap:d,dedupTree:y,removeTree:A,forEachTree:p,isEmptyTree:T,getParentTree:g,includesTree:x,isSingleTree:m,isMultipleTrees:v}
-exports.atIndexOfTree=a,exports.atTree=l,exports.dedupTree=y,exports.default=M,exports.everyTree=c,exports.filterTree=e,exports.findTree=t,exports.forEachTree=p,exports.getParentTree=g,exports.includesTree=x,exports.indexOfTree=h,exports.isEmptyTree=T,exports.isMultipleTrees=v,exports.isSingleTree=m,exports.mapTree=n,exports.nodeDepthMap=d,exports.popTree=s,exports.pushTree=i,exports.removeTree=A,exports.shiftTree=u,exports.someTree=f,exports.unshiftTree=o
+for(const r of t)if(!E(r,e))return!1}return!0}function b(n,e=r){if(!Array.isArray(n))return!1
+for(const r of n)if(!E(r,e))return!1
+return!0}const O={mapTree:n,filterTree:e,findTree:t,pushTree:i,unshiftTree:o,popTree:u,shiftTree:s,someTree:c,everyTree:f,atTree:l,indexOfTree:a,atIndexOfTree:h,getNodeDepthMap:d,getNodeDepth:y,dedupTree:A,removeTree:p,forEachTree:g,isEmptyTreeData:T,isEmptySingleTreeData:x,getParentTree:S,getChildrenTree:D,getSiblingsTree:m,includesTree:v,isSingleTreeData:E,isTreeData:b}
+exports.atIndexOfTree=h,exports.atTree=l,exports.dedupTree=A,exports.default=O,exports.everyTree=f,exports.filterTree=e,exports.findTree=t,exports.forEachTree=g,exports.getChildrenTree=D,exports.getNodeDepth=y,exports.getNodeDepthMap=d,exports.getParentTree=S,exports.getSiblingsTree=m,exports.includesTree=v,exports.indexOfTree=a,exports.isEmptySingleTreeData=x,exports.isEmptyTreeData=T,exports.isSingleTreeData=E,exports.isTreeData=b,exports.mapTree=n,exports.popTree=u,exports.pushTree=i,exports.removeTree=p,exports.shiftTree=s,exports.someTree=c,exports.unshiftTree=o

package/dist/tree-processor.esm.js

@@ -4,17 +4,17 @@ return function r(n){for(const o of n){i.push(t(o))
 const n=o[e.children]
 Array.isArray(n)&&n.length>0&&r(n)}}(n),i}function t(n,t,e=r){const i=[]
 return function r(n){n.forEach((n,o)=>{t(n,o)&&i.push(n)
-const c=n[e.children]
-Array.isArray(c)&&c.length>0&&r(c,o)})}(n),i}function e(n,t,i=r){for(const r of n){if(t(r))return r
+const u=n[e.children]
+Array.isArray(u)&&u.length>0&&r(u,o)})}(n),i}function e(n,t,i=r){for(const r of n){if(t(r))return r
 const n=r[i.children]
 if(Array.isArray(n)&&n.length>0){const r=e(n,t,i)
 if(r)return r}}return null}function i(n,t,e,i=r){return function r(n){for(const o of n){if(o[i.id]===t)return o[i.children]||(o[i.children]=[]),o[i.children].push(e),!0
 const n=o[i.children]
 if(Array.isArray(n)&&n.length>0&&r(n))return!0}return!1}(n)}function o(n,t,e,i=r){return function r(n){for(const o of n){if(o[i.id]===t)return o[i.children]||(o[i.children]=[]),o[i.children].unshift(e),!0
 const n=o[i.children]
-if(Array.isArray(n)&&n.length>0&&r(n))return!0}return!1}(n)}function c(n,t,e=r){return function r(n){for(const i of n){if(i[e.id]===t){const r=i[e.children]
-return!!(Array.isArray(r)&&r.length>0)&&(r.pop(),!0)}const n=i[e.children]
 if(Array.isArray(n)&&n.length>0&&r(n))return!0}return!1}(n)}function u(n,t,e=r){return function r(n){for(const i of n){if(i[e.id]===t){const r=i[e.children]
+return!!(Array.isArray(r)&&r.length>0)&&(r.pop(),!0)}const n=i[e.children]
+if(Array.isArray(n)&&n.length>0&&r(n))return!0}return!1}(n)}function c(n,t,e=r){return function r(n){for(const i of n){if(i[e.id]===t){const r=i[e.children]
 return!!(Array.isArray(r)&&r.length>0)&&(r.shift(),!0)}const n=i[e.children]
 if(Array.isArray(n)&&n.length>0&&r(n))return!0}return!1}(n)}function f(n,t,e=r){for(const r of n){if(t(r))return!0
 const n=r[e.children]
@@ -25,44 +25,62 @@ const n=e[i.children]
 if(Array.isArray(n)&&n.length>0){const t=r(n)
 if(t)return t}}return null}(n)
 if(!o)return null
-const c=o[i.children]
-if(!Array.isArray(c)||0===c.length)return null
-const u=e>=0?e:c.length+e
-return u>=0&&u<c.length?c[u]:null}function h(n,t,e=r){return function r(n,i=[]){for(let o=0;o<n.length;o++){const c=n[o],u=[...i,o]
-if(c[e.id]===t)return u
-const f=c[e.children]
-if(Array.isArray(f)&&f.length>0){const n=r(f,u)
-if(n)return n}}return null}(n)}function a(n,t,e=r){if(!Array.isArray(t)||0===t.length)return null
+const u=o[i.children]
+if(!Array.isArray(u)||0===u.length)return null
+const c=e>=0?e:u.length+e
+return c>=0&&c<u.length?u[c]:null}function a(n,t,e=r){return function r(n,i=[]){for(let o=0;o<n.length;o++){const u=n[o],c=[...i,o]
+if(u[e.id]===t)return c
+const f=u[e.children]
+if(Array.isArray(f)&&f.length>0){const n=r(f,c)
+if(n)return n}}return null}(n)}function h(n,t,e=r){if(!Array.isArray(t)||0===t.length)return null
 let i=n
 for(let r=0;r<t.length;r++){const n=t[r]
 if(!Array.isArray(i)||n<0||n>=i.length)return null
 const o=i[n]
 if(r===t.length-1)return o
-const c=o[e.children]
-if(!Array.isArray(c))return null
-i=c}return null}function y(n,t=r){const e={}
+const u=o[e.children]
+if(!Array.isArray(u))return null
+i=u}return null}function y(n,t=r){const e={}
 return function r(n,i=1){for(const o of n){e[o[t.id]]=i
 const n=o[t.children]
-Array.isArray(n)&&n.length>0&&r(n,i+1)}}(n),e}function d(n,t,e=r){const i=new Set
+Array.isArray(n)&&n.length>0&&r(n,i+1)}}(n),e}function d(n,t,e=r){return function r(n,i=1){for(const o of n){if(o[e.id]===t)return i
+const n=o[e.children]
+if(Array.isArray(n)&&n.length>0){const t=r(n,i+1)
+if(null!==t)return t}}return null}(n)}function A(n,t,e=r){const i=new Set
 return function r(n){const o=[]
-for(const c of n){const n=c[t]
+for(const u of n){const n=u[t]
 if(null!=n){if(i.has(n))continue
-i.add(n)}const u={...c},f=c[e.children]
-Array.isArray(f)&&f.length>0&&(u[e.children]=r(f)),o.push(u)}return o}(n)}function A(n,t,e=r){return function r(n){for(let i=0;i<n.length;i++){const o=n[i]
+i.add(n)}const c={...u},f=u[e.children]
+Array.isArray(f)&&f.length>0&&(c[e.children]=r(f)),o.push(c)}return o}(n)}function g(n,t,e=r){return function r(n){for(let i=0;i<n.length;i++){const o=n[i]
 if(o[e.id]===t)return n.splice(i,1),!0
-const c=o[e.children]
-if(Array.isArray(c)&&c.length>0&&r(c))return!0}return!1}(n)}function g(n,t,e=r){!function r(n){for(const i of n){t(i)
+const u=o[e.children]
+if(Array.isArray(u)&&u.length>0&&r(u))return!0}return!1}(n)}function T(n,t,e=r){!function r(n){for(const i of n){t(i)
 const n=i[e.children]
-Array.isArray(n)&&n.length>0&&r(n)}}(n)}function T(r){return!Array.isArray(r)||0===r.length}function p(n,t,e=r){return function r(n,i=null){for(const o of n){if(o[e.id]===t)return i
+Array.isArray(n)&&n.length>0&&r(n)}}(n)}function p(r){return!Array.isArray(r)||0===r.length}function D(n,t=r){if(!x(n,t))return!0
+const e=n[t.children]
+return void 0===e||(!Array.isArray(e)||0===e.length)}function m(n,t,e=r){const i=function r(n){for(const i of n){if(i[e.id]===t)return i
+const n=i[e.children]
+if(Array.isArray(n)&&n.length>0){const t=r(n)
+if(null!==t)return t}}return null}(n)
+if(!i)return[]
+const o=i[e.children]
+return Array.isArray(o)?o:[]}function v(n,t,e=r){const i=function r(n,i=null){for(const o of n){if(o[e.id]===t)return{node:o,parent:i}
+const n=o[e.children]
+if(Array.isArray(n)&&n.length>0){const t=r(n,o)
+if(null!==t)return t}}return null}(n)
+if(!i)return[]
+if(null===i.parent)return n
+const o=i.parent[e.children]
+return Array.isArray(o)?o:[]}function E(n,t,e=r){return function r(n,i=null){for(const o of n){if(o[e.id]===t)return i
 const n=o[e.children]
 if(Array.isArray(n)&&n.length>0){const t=r(n,o)
-if(null!==t)return t}}return null}(n)}function m(n,t,e=r){for(const r of n){if(r[e.id]===t)return!0
+if(null!==t)return t}}return null}(n)}function S(n,t,e=r){for(const r of n){if(r[e.id]===t)return!0
 const n=r[e.children]
-if(Array.isArray(n)&&n.length>0&&m(n,t,e))return!0}return!1}function v(n,t=r){if(!n||"object"!=typeof n||Array.isArray(n))return!1
+if(Array.isArray(n)&&n.length>0&&S(n,t,e))return!0}return!1}function x(n,t=r){if(!n||"object"!=typeof n||Array.isArray(n))return!1
 const e=n[t.children]
 if(void 0!==e){if(null===e)return!1
 if(!Array.isArray(e))return!1
-for(const r of e)if(!v(r,t))return!1}return!0}function x(n,t=r){if(!Array.isArray(n))return!1
-for(const r of n)if(!v(r,t))return!1
-return!0}const E={mapTree:n,filterTree:t,findTree:e,pushTree:i,unshiftTree:o,popTree:c,shiftTree:u,someTree:f,everyTree:l,atTree:s,indexOfTree:h,atIndexOfTree:a,nodeDepthMap:y,dedupTree:d,removeTree:A,forEachTree:g,isEmptyTree:T,getParentTree:p,includesTree:m,isSingleTree:v,isMultipleTrees:x}
-export{a as atIndexOfTree,s as atTree,d as dedupTree,E as default,l as everyTree,t as filterTree,e as findTree,g as forEachTree,p as getParentTree,m as includesTree,h as indexOfTree,T as isEmptyTree,x as isMultipleTrees,v as isSingleTree,n as mapTree,y as nodeDepthMap,c as popTree,i as pushTree,A as removeTree,u as shiftTree,f as someTree,o as unshiftTree}
+for(const r of e)if(!x(r,t))return!1}return!0}function b(n,t=r){if(!Array.isArray(n))return!1
+for(const r of n)if(!x(r,t))return!1
+return!0}const N={mapTree:n,filterTree:t,findTree:e,pushTree:i,unshiftTree:o,popTree:u,shiftTree:c,someTree:f,everyTree:l,atTree:s,indexOfTree:a,atIndexOfTree:h,getNodeDepthMap:y,getNodeDepth:d,dedupTree:A,removeTree:g,forEachTree:T,isEmptyTreeData:p,isEmptySingleTreeData:D,getParentTree:E,getChildrenTree:m,getSiblingsTree:v,includesTree:S,isSingleTreeData:x,isTreeData:b}
+export{h as atIndexOfTree,s as atTree,A as dedupTree,N as default,l as everyTree,t as filterTree,e as findTree,T as forEachTree,m as getChildrenTree,d as getNodeDepth,y as getNodeDepthMap,E as getParentTree,v as getSiblingsTree,S as includesTree,a as indexOfTree,D as isEmptySingleTreeData,p as isEmptyTreeData,x as isSingleTreeData,b as isTreeData,n as mapTree,u as popTree,i as pushTree,g as removeTree,c as shiftTree,f as someTree,o as unshiftTree}

package/dist/tree-processor.umd.js

@@ -5,65 +5,83 @@ return function r(n){for(const o of n){i.push(e(o))
 const n=o[t.children]
 Array.isArray(n)&&n.length>0&&r(n)}}(r),i}function t(r,e,t=n){const i=[]
 return function r(n){n.forEach((n,o)=>{e(n,o)&&i.push(n)
-const f=n[t.children]
-Array.isArray(f)&&f.length>0&&r(f,o)})}(r),i}function i(r,e,t=n){for(const n of r){if(e(n))return n
+const u=n[t.children]
+Array.isArray(u)&&u.length>0&&r(u,o)})}(r),i}function i(r,e,t=n){for(const n of r){if(e(n))return n
 const r=n[t.children]
 if(Array.isArray(r)&&r.length>0){const n=i(r,e,t)
 if(n)return n}}return null}function o(r,e,t,i=n){return function r(n){for(const o of n){if(o[i.id]===e)return o[i.children]||(o[i.children]=[]),o[i.children].push(t),!0
 const n=o[i.children]
-if(Array.isArray(n)&&n.length>0&&r(n))return!0}return!1}(r)}function f(r,e,t,i=n){return function r(n){for(const o of n){if(o[i.id]===e)return o[i.children]||(o[i.children]=[]),o[i.children].unshift(t),!0
+if(Array.isArray(n)&&n.length>0&&r(n))return!0}return!1}(r)}function u(r,e,t,i=n){return function r(n){for(const o of n){if(o[i.id]===e)return o[i.children]||(o[i.children]=[]),o[i.children].unshift(t),!0
 const n=o[i.children]
-if(Array.isArray(n)&&n.length>0&&r(n))return!0}return!1}(r)}function u(r,e,t=n){return function r(n){for(const i of n){if(i[t.id]===e){const r=i[t.children]
+if(Array.isArray(n)&&n.length>0&&r(n))return!0}return!1}(r)}function f(r,e,t=n){return function r(n){for(const i of n){if(i[t.id]===e){const r=i[t.children]
 return!!(Array.isArray(r)&&r.length>0)&&(r.pop(),!0)}const n=i[t.children]
 if(Array.isArray(n)&&n.length>0&&r(n))return!0}return!1}(r)}function c(r,e,t=n){return function r(n){for(const i of n){if(i[t.id]===e){const r=i[t.children]
 return!!(Array.isArray(r)&&r.length>0)&&(r.shift(),!0)}const n=i[t.children]
-if(Array.isArray(n)&&n.length>0&&r(n))return!0}return!1}(r)}function s(r,e,t=n){for(const n of r){if(e(n))return!0
+if(Array.isArray(n)&&n.length>0&&r(n))return!0}return!1}(r)}function l(r,e,t=n){for(const n of r){if(e(n))return!0
 const r=n[t.children]
-if(Array.isArray(r)&&r.length>0&&s(r,e,t))return!0}return!1}function l(r,e,t=n){for(const n of r){if(!e(n))return!1
+if(Array.isArray(r)&&r.length>0&&l(r,e,t))return!0}return!1}function s(r,e,t=n){for(const n of r){if(!e(n))return!1
 const r=n[t.children]
-if(Array.isArray(r)&&r.length>0&&!l(r,e,t))return!1}return!0}function h(r,e,t,i=n){const o=function r(n){for(const t of n){if(t[i.id]===e)return t
+if(Array.isArray(r)&&r.length>0&&!s(r,e,t))return!1}return!0}function a(r,e,t,i=n){const o=function r(n){for(const t of n){if(t[i.id]===e)return t
 const n=t[i.children]
 if(Array.isArray(n)&&n.length>0){const e=r(n)
 if(e)return e}}return null}(r)
 if(!o)return null
-const f=o[i.children]
-if(!Array.isArray(f)||0===f.length)return null
-const u=t>=0?t:f.length+t
-return u>=0&&u<f.length?f[u]:null}function a(r,e,t=n){return function r(n,i=[]){for(let o=0;o<n.length;o++){const f=n[o],u=[...i,o]
-if(f[t.id]===e)return u
-const c=f[t.children]
-if(Array.isArray(c)&&c.length>0){const n=r(c,u)
+const u=o[i.children]
+if(!Array.isArray(u)||0===u.length)return null
+const f=t>=0?t:u.length+t
+return f>=0&&f<u.length?u[f]:null}function h(r,e,t=n){return function r(n,i=[]){for(let o=0;o<n.length;o++){const u=n[o],f=[...i,o]
+if(u[t.id]===e)return f
+const c=u[t.children]
+if(Array.isArray(c)&&c.length>0){const n=r(c,f)
 if(n)return n}}return null}(r)}function d(r,e,t=n){if(!Array.isArray(e)||0===e.length)return null
 let i=r
 for(let r=0;r<e.length;r++){const n=e[r]
 if(!Array.isArray(i)||n<0||n>=i.length)return null
 const o=i[n]
 if(r===e.length-1)return o
-const f=o[t.children]
-if(!Array.isArray(f))return null
-i=f}return null}function y(r,e=n){const t={}
+const u=o[t.children]
+if(!Array.isArray(u))return null
+i=u}return null}function y(r,e=n){const t={}
 return function r(n,i=1){for(const o of n){t[o[e.id]]=i
 const n=o[e.children]
-Array.isArray(n)&&n.length>0&&r(n,i+1)}}(r),t}function A(r,e,t=n){const i=new Set
+Array.isArray(n)&&n.length>0&&r(n,i+1)}}(r),t}function A(r,e,t=n){return function r(n,i=1){for(const o of n){if(o[t.id]===e)return i
+const n=o[t.children]
+if(Array.isArray(n)&&n.length>0){const e=r(n,i+1)
+if(null!==e)return e}}return null}(r)}function g(r,e,t=n){const i=new Set
 return function r(n){const o=[]
-for(const f of n){const n=f[e]
+for(const u of n){const n=u[e]
 if(null!=n){if(i.has(n))continue
-i.add(n)}const u={...f},c=f[t.children]
-Array.isArray(c)&&c.length>0&&(u[t.children]=r(c)),o.push(u)}return o}(r)}function T(r,e,t=n){return function r(n){for(let i=0;i<n.length;i++){const o=n[i]
+i.add(n)}const f={...u},c=u[t.children]
+Array.isArray(c)&&c.length>0&&(f[t.children]=r(c)),o.push(f)}return o}(r)}function T(r,e,t=n){return function r(n){for(let i=0;i<n.length;i++){const o=n[i]
 if(o[t.id]===e)return n.splice(i,1),!0
-const f=o[t.children]
-if(Array.isArray(f)&&f.length>0&&r(f))return!0}return!1}(r)}function g(r,e,t=n){!function r(n){for(const i of n){e(i)
+const u=o[t.children]
+if(Array.isArray(u)&&u.length>0&&r(u))return!0}return!1}(r)}function p(r,e,t=n){!function r(n){for(const i of n){e(i)
+const n=i[t.children]
+Array.isArray(n)&&n.length>0&&r(n)}}(r)}function m(r){return!Array.isArray(r)||0===r.length}function D(r,e=n){if(!E(r,e))return!0
+const t=r[e.children]
+return void 0===t||(!Array.isArray(t)||0===t.length)}function S(r,e,t=n){const i=function r(n){for(const i of n){if(i[t.id]===e)return i
 const n=i[t.children]
-Array.isArray(n)&&n.length>0&&r(n)}}(r)}function p(r){return!Array.isArray(r)||0===r.length}function m(r,e,t=n){return function r(n,i=null){for(const o of n){if(o[t.id]===e)return i
+if(Array.isArray(n)&&n.length>0){const e=r(n)
+if(null!==e)return e}}return null}(r)
+if(!i)return[]
+const o=i[t.children]
+return Array.isArray(o)?o:[]}function b(r,e,t=n){const i=function r(n,i=null){for(const o of n){if(o[t.id]===e)return{node:o,parent:i}
+const n=o[t.children]
+if(Array.isArray(n)&&n.length>0){const e=r(n,o)
+if(null!==e)return e}}return null}(r)
+if(!i)return[]
+if(null===i.parent)return r
+const o=i.parent[t.children]
+return Array.isArray(o)?o:[]}function v(r,e,t=n){return function r(n,i=null){for(const o of n){if(o[t.id]===e)return i
 const n=o[t.children]
 if(Array.isArray(n)&&n.length>0){const e=r(n,o)
-if(null!==e)return e}}return null}(r)}function v(r,e,t=n){for(const n of r){if(n[t.id]===e)return!0
+if(null!==e)return e}}return null}(r)}function x(r,e,t=n){for(const n of r){if(n[t.id]===e)return!0
 const r=n[t.children]
-if(Array.isArray(r)&&r.length>0&&v(r,e,t))return!0}return!1}function x(r,e=n){if(!r||"object"!=typeof r||Array.isArray(r))return!1
+if(Array.isArray(r)&&r.length>0&&x(r,e,t))return!0}return!1}function E(r,e=n){if(!r||"object"!=typeof r||Array.isArray(r))return!1
 const t=r[e.children]
 if(void 0!==t){if(null===t)return!1
 if(!Array.isArray(t))return!1
-for(const r of t)if(!x(r,e))return!1}return!0}function b(r,e=n){if(!Array.isArray(r))return!1
-for(const n of r)if(!x(n,e))return!1
-return!0}const M={mapTree:e,filterTree:t,findTree:i,pushTree:o,unshiftTree:f,popTree:u,shiftTree:c,someTree:s,everyTree:l,atTree:h,indexOfTree:a,atIndexOfTree:d,nodeDepthMap:y,dedupTree:A,removeTree:T,forEachTree:g,isEmptyTree:p,getParentTree:m,includesTree:v,isSingleTree:x,isMultipleTrees:b}
-r.atIndexOfTree=d,r.atTree=h,r.dedupTree=A,r.default=M,r.everyTree=l,r.filterTree=t,r.findTree=i,r.forEachTree=g,r.getParentTree=m,r.includesTree=v,r.indexOfTree=a,r.isEmptyTree=p,r.isMultipleTrees=b,r.isSingleTree=x,r.mapTree=e,r.nodeDepthMap=y,r.popTree=u,r.pushTree=o,r.removeTree=T,r.shiftTree=c,r.someTree=s,r.unshiftTree=f,Object.defineProperties(r,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})})
+for(const r of t)if(!E(r,e))return!1}return!0}function O(r,e=n){if(!Array.isArray(r))return!1
+for(const n of r)if(!E(n,e))return!1
+return!0}const M={mapTree:e,filterTree:t,findTree:i,pushTree:o,unshiftTree:u,popTree:f,shiftTree:c,someTree:l,everyTree:s,atTree:a,indexOfTree:h,atIndexOfTree:d,getNodeDepthMap:y,getNodeDepth:A,dedupTree:g,removeTree:T,forEachTree:p,isEmptyTreeData:m,isEmptySingleTreeData:D,getParentTree:v,getChildrenTree:S,getSiblingsTree:b,includesTree:x,isSingleTreeData:E,isTreeData:O}
+r.atIndexOfTree=d,r.atTree=a,r.dedupTree=g,r.default=M,r.everyTree=s,r.filterTree=t,r.findTree=i,r.forEachTree=p,r.getChildrenTree=S,r.getNodeDepth=A,r.getNodeDepthMap=y,r.getParentTree=v,r.getSiblingsTree=b,r.includesTree=x,r.indexOfTree=h,r.isEmptySingleTreeData=D,r.isEmptyTreeData=m,r.isSingleTreeData=E,r.isTreeData=O,r.mapTree=e,r.popTree=f,r.pushTree=o,r.removeTree=T,r.shiftTree=c,r.someTree=l,r.unshiftTree=u,Object.defineProperties(r,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tree-processor",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "description": "A lightweight TypeScript library for processing tree-structured data with comprehensive methods (map, filter, find, push, pop, remove, getParent, includes, etc.), supporting tree-shaking and custom field names",
   "main": "dist/tree-processor.cjs.js",
   "module": "dist/tree-processor.esm.js",