tree-processor 0.7.0 → 0.8.1

package/README.md

@@ -1,30 +1,104 @@
 # tree-processor
 
-一个轻量级的树结构数据处理工具库，使用 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、dedupTree、removeTree、getParentTree、getChildrenTree、getSiblingsTree、getNodeDepthMap、getNodeDepth、isEmptyTreeData、isEmptySingleTreeData、isSingleTreeData 和 isTreeData。每个方法的最后一个参数可以自定义 children 和 id 的属性名。
+<div align="center">
+
+![npm version](https://img.shields.io/npm/v/tree-processor?style=flat-square)
+![npm downloads](https://img.shields.io/npm/dm/tree-processor?style=flat-square)
+![bundle size](https://img.shields.io/badge/bundle-6.6KB-blue?style=flat-square)
+![TypeScript](https://img.shields.io/badge/TypeScript-5.7-blue?style=flat-square)
+![License](https://img.shields.io/badge/license-MIT-green?style=flat-square)
+![test coverage](https://img.shields.io/badge/coverage-272%20tests-brightgreen?style=flat-square)
+
+一个轻量级的树结构数据处理工具库，使用 TypeScript 编写，支持 tree-shaking，每个格式打包体积约 **6-7 KB**（ESM: 6.39 KB，CJS: 6.64 KB，UMD: 6.68 KB）。
+
+
+</div>
+
+## 📋 目录
+
+- [特性](#-特性)
+  - [使用场景](#-使用场景)
+- [安装](#-安装)
+- [快速开始](#-快速开始)
+- [API 文档](#-api-文档)
+  - [遍历方法](#遍历方法)
+  - [查找方法](#查找方法)
+  - [修改方法](#修改方法)
+  - [判断方法](#判断方法)
+  - [工具方法](#工具方法)
+- [自定义字段名](#自定义字段名)
+- [测试](#测试)
+- [开发](#开发)
+- [技术栈](#技术栈)
+- [贡献](#-贡献)
+- [更新日志](#-更新日志)
+- [许可证](#-许可证)
+- [相关链接](#-相关链接)
 
 ## ✨ 特性
 
-- 🚀 **轻量级** - 每个格式约 3-4 KB（ESM: 3.25 KB，CJS: 3.42 KB，UMD: 3.56 KB）
-- 📦 **支持 Tree-shaking** - 按需导入，只打包使用的代码
-- 🔧 **TypeScript 支持** - 完整的类型定义和类型提示
-- 🎯 **类似数组 API** - 提供 map、filter、find 等熟悉的数组方法
-- ⚙️ **自定义字段名** - 支持自定义 children 和 id 字段名
-- ✅ **零依赖** - 无外部依赖，开箱即用
-- 🧪 **完善的测试覆盖** - 包含 200 个测试用例，覆盖基础功能、边界情况、异常处理、复杂场景、npm 包导入等
+- **轻量级** - 每个格式打包体积仅 6-7 KB（ESM: 6.39 KB，CJS: 6.64 KB，UMD: 6.68 KB），对项目体积影响极小
+- **支持 Tree-shaking** - 支持按需导入，只打包实际使用的代码，进一步减小打包体积
+- **完整的 TypeScript 支持** - 提供完整的类型定义和智能提示，提升开发体验
+- **灵活的自定义字段名** - 支持自定义 children 和 id 字段名，适配各种数据结构
+- **零依赖** - 无任何外部依赖，开箱即用，无需担心依赖冲突
+- **完善的测试覆盖** - 包含 272 个测试用例，覆盖基础功能、边界情况、异常处理、复杂场景等
+- **丰富的 API** - 提供 30+ 个方法，包含类似数组的 API（map、filter、find、some、every、includes、at、indexOf 等），以及树结构特有的操作（获取父子节点、深度计算、数据验证等），涵盖遍历、查找、修改、判断等完整场景
+
+**已支持的方法：** mapTree、forEachTree、filterTree、findTree、pushTree、unshiftTree、popTree、shiftTree、someTree、everyTree、includesTree、atTree、indexOfTree、atIndexOfTree、dedupTree、removeTree、getParentTree、getChildrenTree、getSiblingsTree、getNodeDepthMap、getNodeDepth、isLeafNode、isRootNode、isEmptyTreeData、isEmptySingleTreeData、isTreeData、isSingleTreeData、isValidTreeNode、isTreeNodeWithCircularCheck、isSafeTreeDepth。每个方法的最后一个参数可以自定义 children 和 id 的属性名。
+
+### 💡 使用场景
+
+- **导航系统** - 多级菜单、路由配置的展开、折叠、搜索、过滤
+- **文件系统** - 文件目录的遍历、查找、移动、删除
+- **权限系统** - 组织架构、角色权限的树形结构管理和验证
+- **框架开发** - 组件树、路由树等树形结构的构建和管理
+- **数据管理** - 分类管理、评论系统、树形选择器等数据操作
 
 ## 📦 安装
 
 ```bash
+npm install tree-processor
+# 或
 yarn add tree-processor
 # 或
-npm i tree-processor
+pnpm add tree-processor
 ```
 
-## 使用说明
+## 🚀 快速开始
 
-### 引入
+```javascript
+import { mapTree, findTree, filterTree } from 'tree-processor'
+
+const treeData = [
+  {
+    id: 1,
+    name: 'node1',
+    children: [
+      { id: 2, name: 'node2' },
+      { id: 3, name: 'node3' },
+    ],
+  },
+]
+
+// 获取所有节点名称
+const names = mapTree(treeData, (node) => node.name)
+console.log(names) // ['node1', 'node2', 'node3']
+
+// 查找节点
+const node = findTree(treeData, (n) => n.id === 2)
+console.log(node) // { id: 2, name: 'node2' }
+
+// 过滤节点
+const filtered = filterTree(treeData, (n) => n.id > 1)
+console.log(filtered) // [{ id: 2, name: 'node2' }, { id: 3, name: 'node3' }]
+```
+
+## 📖 API 文档
+
+### 引入方式
+
+#### 默认导入（推荐用于需要多个方法的场景）
 
 #### 默认导入（推荐用于需要多个方法的场景）
 
@@ -59,7 +133,7 @@ const { mapTree, filterTree } = require('tree-processor')
 - 只有在需要显式声明变量类型时才需要引入类型（如 `const treeData: TreeData = [...]`）
 - 使用 `import type` 导入类型不会增加运行时体积（类型在编译时会被移除）
 
-### 示例树结构数据
+### 示例数据
 
 以下示例数据将用于后续所有方法的演示：
 
@@ -87,7 +161,11 @@ const treeData = [
 ];
 ```
 
-### mapTree（遍历树结构数据的方法）
+---
+
+## 遍历方法
+
+### mapTree
 
 遍历树结构数据，对每个节点执行回调函数，返回映射后的数组。
 
@@ -108,7 +186,7 @@ const modifiedNodes = t.mapTree(treeData, (node) => ({
 console.log(modifiedNodes) // 返回包含 label 字段的新数组
 ```
 
-### forEachTree（遍历树结构数据的方法，不返回值）
+### forEachTree
 
 遍历树结构数据，对每个节点执行回调函数。与 mapTree 的区别是不返回值，性能更好，适合只需要遍历而不需要返回结果的场景。
 
@@ -132,7 +210,7 @@ t.forEachTree(treeData, () => {
 console.log(nodeCount) // 节点总数
 ```
 
-### filterTree（树结构数据的filter方法）
+### filterTree
 
 过滤树结构数据，返回满足条件的节点。
 
@@ -154,7 +232,11 @@ const leafNodes = t.filterTree(treeData, (node) => {
 console.log(leafNodes) // 返回所有叶子节点
 ```
 
-### findTree（树结构数据的find方法）
+---
+
+## 查找方法
+
+### findTree
 
 查找树结构数据中满足条件的第一个节点。如果未找到，返回 null。
 
@@ -172,85 +254,7 @@ const nodeNotFound = t.findTree(treeData, (node) => node.id === 999)
 console.log(nodeNotFound) // null
 ```
 
-### pushTree（在指定节点下添加子节点到末尾）
-
-在指定节点下添加子节点到末尾。返回 true 表示添加成功，false 表示未找到目标节点。
-
-```javascript
-// 在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（在指定节点下添加子节点到开头）
-
-在指定节点下添加子节点到开头。返回 true 表示添加成功，false 表示未找到目标节点。
-
-```javascript
-// 在ID为1的节点下添加新子节点到开头
-const unshiftSuccess = t.unshiftTree(treeData, 1, { id: 7, name: 'node7' })
-console.log(unshiftSuccess) // true
-console.log(treeData) // 新节点已添加到 children 数组开头
-```
-
-### popTree（删除指定节点下的最后一个子节点）
-
-删除指定节点下的最后一个子节点。返回被删除的节点，如果节点不存在或没有子节点则返回 false。
-
-```javascript
-// 删除ID为1的节点下的最后一个子节点
-const removedNode = t.popTree(treeData, 1)
-console.log(removedNode) // 返回被删除的节点对象，或 false
-
-// 尝试删除不存在的节点下的子节点
-const popFailed = t.popTree(treeData, 999)
-console.log(popFailed) // false
-```
-
-### shiftTree（删除指定节点下的第一个子节点）
-
-删除指定节点下的第一个子节点。返回被删除的节点，如果节点不存在或没有子节点则返回 false。
-
-```javascript
-// 删除ID为1的节点下的第一个子节点
-const shiftedNode = t.shiftTree(treeData, 1)
-console.log(shiftedNode) // 返回被删除的节点对象，或 false
-```
-
-### someTree（树结构数据的some方法）
-
-检查树结构数据中是否存在满足条件的节点。只要有一个节点满足条件就返回 true。
-
-```javascript
-// 检查是否存在名称为 'node2' 的节点
-const hasNode2 = t.someTree(treeData, node => node.name === 'node2')
-console.log(hasNode2) // true
-
-// 检查是否存在ID大于10的节点
-const hasLargeId = t.someTree(treeData, node => node.id > 10)
-console.log(hasLargeId) // false
-```
-
-### everyTree（树结构数据的every方法）
-
-检查树结构数据中是否所有节点都满足条件。只有所有节点都满足条件才返回 true。
-
-```javascript
-// 检查所有节点的ID是否都大于0
-const allIdsPositive = t.everyTree(treeData, node => node.id > 0)
-console.log(allIdsPositive) // true
-
-// 检查所有节点是否都有 name 属性
-const allHaveName = t.everyTree(treeData, node => node.name)
-console.log(allHaveName) // 根据实际数据返回 true 或 false
-```
-
-### includesTree（检查树中是否包含指定节点）
+### includesTree
 
 检查树结构数据中是否包含指定ID的节点。
 
@@ -261,7 +265,7 @@ const hasNode = t.includesTree(treeData, nodeId)
 console.log(hasNode) // true 表示包含该节点，false 表示不包含
 ```
 
-### atTree（根据父节点ID和子节点索引获取节点）
+### atTree
 
 根据父节点ID和子节点索引获取节点。支持负数索引，和数组的 at 方法一样。未找到返回 null。
 
@@ -279,7 +283,7 @@ const nodeNotFound = t.atTree(treeData, 1, 10)
 console.log(nodeNotFound) // null
 ```
 
-### indexOfTree（返回从根节点到目标节点的索引路径）
+### indexOfTree
 
 返回一个数组，值为从根节点开始到 targetId 所在节点的索引路径。未找到返回 null。返回值可以传入 atIndexOfTree 的第二个参数进行取值。
 
@@ -298,7 +302,7 @@ const nodeByPath = t.atIndexOfTree(treeData, indexPath)
 console.log(nodeByPath) // 获取到ID为4的节点
 ```
 
-### atIndexOfTree（根据索引路径获取节点）
+### atIndexOfTree
 
 根据索引路径获取节点。路径无效或超出范围返回 null。
 
@@ -317,7 +321,73 @@ const invalidPath = t.atIndexOfTree(treeData, [999])
 console.log(invalidPath) // null
 ```
 
-### dedupTree（树结构对象数组去重方法）
+---
+
+## 修改方法
+
+### pushTree
+
+在指定节点下添加子节点到末尾。返回 true 表示添加成功，false 表示未找到目标节点。
+
+```javascript
+// 在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
+
+在指定节点下添加子节点到开头。返回 true 表示添加成功，false 表示未找到目标节点。
+
+```javascript
+// 在ID为1的节点下添加新子节点到开头
+const unshiftSuccess = t.unshiftTree(treeData, 1, { id: 7, name: 'node7' })
+console.log(unshiftSuccess) // true
+console.log(treeData) // 新节点已添加到 children 数组开头
+```
+
+### popTree
+
+删除指定节点下的最后一个子节点。返回被删除的节点，如果节点不存在或没有子节点则返回 false。
+
+```javascript
+// 删除ID为1的节点下的最后一个子节点
+const removedNode = t.popTree(treeData, 1)
+console.log(removedNode) // 返回被删除的节点对象，或 false
+
+// 尝试删除不存在的节点下的子节点
+const popFailed = t.popTree(treeData, 999)
+console.log(popFailed) // false
+```
+
+### shiftTree
+
+删除指定节点下的第一个子节点。返回被删除的节点，如果节点不存在或没有子节点则返回 false。
+
+```javascript
+// 删除ID为1的节点下的第一个子节点
+const shiftedNode = t.shiftTree(treeData, 1)
+console.log(shiftedNode) // 返回被删除的节点对象，或 false
+```
+
+### removeTree
+
+删除树结构数据中指定ID的节点，包括根节点和子节点。
+
+```javascript
+const nodeIdToRemove = 2
+const removeSuccess = t.removeTree(treeData, nodeIdToRemove)
+
+console.log(removeSuccess) // true 表示删除成功，false 表示未找到节点
+console.log(treeData) // 删除后的树结构
+```
+
+### dedupTree
 
 树结构对象数组去重方法，根据指定的键去除重复节点。保留第一次出现的节点。
 
@@ -331,19 +401,39 @@ const uniqueByNameTree = t.dedupTree(treeData, 'name')
 console.log(uniqueByNameTree) // 返回根据 name 去重后的数据
 ```
 
-### removeTree（删除指定节点）
+---
 
-删除树结构数据中指定ID的节点，包括根节点和子节点。
+## 判断方法
+
+### someTree
+
+检查树结构数据中是否存在满足条件的节点。只要有一个节点满足条件就返回 true。
 
 ```javascript
-const nodeIdToRemove = 2
-const removeSuccess = t.removeTree(treeData, nodeIdToRemove)
+// 检查是否存在名称为 'node2' 的节点
+const hasNode2 = t.someTree(treeData, node => node.name === 'node2')
+console.log(hasNode2) // true
 
-console.log(removeSuccess) // true 表示删除成功，false 表示未找到节点
-console.log(treeData) // 删除后的树结构
+// 检查是否存在ID大于10的节点
+const hasLargeId = t.someTree(treeData, node => node.id > 10)
+console.log(hasLargeId) // false
 ```
 
-### getParentTree（获取节点的父节点）
+### everyTree
+
+检查树结构数据中是否所有节点都满足条件。只有所有节点都满足条件才返回 true。
+
+```javascript
+// 检查所有节点的ID是否都大于0
+const allIdsPositive = t.everyTree(treeData, node => node.id > 0)
+console.log(allIdsPositive) // true
+
+// 检查所有节点是否都有 name 属性
+const allHaveName = t.everyTree(treeData, node => node.name)
+console.log(allHaveName) // 根据实际数据返回 true 或 false
+```
+
+### getParentTree
 
 获取指定节点的父节点。如果节点是根节点或未找到，返回 null。
 
@@ -361,7 +451,7 @@ const parentNotFound = t.getParentTree(treeData, 999)
 console.log(parentNotFound) // null
 ```
 
-### getChildrenTree（获取节点的所有直接子节点）
+### getChildrenTree
 
 获取指定节点的所有直接子节点。如果未找到节点或没有子节点，返回空数组。
 
@@ -394,7 +484,7 @@ const customChildren = t.getChildrenTree(customTree, 1, fieldNames)
 console.log(customChildren) // 返回子节点数组
 ```
 
-### getSiblingsTree（获取节点的所有兄弟节点）
+### getSiblingsTree
 
 获取指定节点的所有兄弟节点（包括自己）。如果未找到节点，返回空数组。根节点的兄弟节点是其他根节点。
 
@@ -432,7 +522,11 @@ const customSiblings = t.getSiblingsTree(customTree, 2, fieldNames)
 console.log(customSiblings) // 返回兄弟节点数组（包括自己）
 ```
 
-### getNodeDepthMap（返回节点ID到深度的映射）
+---
+
+## 工具方法
+
+### getNodeDepthMap
 
 返回一个字典，键代表节点的 id，值代表该节点在数据的第几层。深度从1开始，根节点深度为1。
 
@@ -450,7 +544,7 @@ const emptyDepthMap = t.getNodeDepthMap([])
 console.log(emptyDepthMap) // {}
 ```
 
-### getNodeDepth（获取单个节点的深度）
+### getNodeDepth
 
 获取指定节点的深度。深度从1开始，根节点深度为1。
 
@@ -490,7 +584,107 @@ console.log(depth) // 2
 - `getNodeDepthMap` - 批量获取所有节点的深度（一次性计算所有节点）
 - `getNodeDepth` - 只获取单个节点的深度（只计算目标节点，效率更高）
 
-### isEmptyTreeData（检查树结构数据是否为空）
+### isLeafNode
+
+检查节点是否是叶子节点（没有子节点）。轻量级方法，只检查节点本身，不遍历树。
+
+```javascript
+// 没有 children 字段的节点是叶子节点
+const leafNode1 = { id: 1, name: 'node1' };
+console.log(t.isLeafNode(leafNode1)) // true
+
+// children 为空数组的节点是叶子节点
+const leafNode2 = { id: 2, name: 'node2', children: [] };
+console.log(t.isLeafNode(leafNode2)) // true
+
+// 有子节点的节点不是叶子节点
+const parentNode = {
+  id: 3,
+  name: 'node3',
+  children: [{ id: 4, name: 'node4' }],
+};
+console.log(t.isLeafNode(parentNode)) // false
+
+// 在 filterTree 中使用（过滤出所有叶子节点）
+const leafNodes = t.filterTree(treeData, (node) => t.isLeafNode(node))
+console.log(leafNodes) // 返回所有叶子节点
+
+// 在 forEachTree 中使用
+t.forEachTree(treeData, (node) => {
+  if (t.isLeafNode(node)) {
+    console.log('叶子节点:', node.name)
+  }
+})
+
+// 支持自定义字段名
+const customNode = {
+  nodeId: 1,
+  name: 'node1',
+  subNodes: [],
+};
+const fieldNames = { children: 'subNodes', id: 'nodeId' };
+console.log(t.isLeafNode(customNode, fieldNames)) // true
+```
+
+**与现有方法的区别：**
+- `isLeafNode` - 只检查单个节点，轻量级（O(1)），适合在遍历时使用
+- `getChildrenTree` - 获取子节点数组，需要传入 tree 和 nodeId，需要查找节点（O(n)）
+
+### isRootNode
+
+检查节点是否是根节点（没有父节点）。根节点是树结构数据数组中的顶层节点。
+
+```javascript
+// 检查根节点
+const treeData = [
+  {
+    id: 1,
+    name: 'root1',
+    children: [{ id: 2, name: 'child1' }],
+  },
+];
+console.log(t.isRootNode(treeData, 1)) // true
+console.log(t.isRootNode(treeData, 2)) // false
+
+// 多个根节点的情况
+const multiRoot = [
+  { id: 1, name: 'root1' },
+  { id: 2, name: 'root2' },
+  { id: 3, name: 'root3' },
+];
+console.log(t.isRootNode(multiRoot, 1)) // true
+console.log(t.isRootNode(multiRoot, 2)) // true
+console.log(t.isRootNode(multiRoot, 3)) // true
+
+// 在遍历时使用
+t.forEachTree(treeData, (node) => {
+  if (t.isRootNode(treeData, node.id)) {
+    console.log('根节点:', node.name)
+  }
+})
+
+// 支持自定义字段名
+const customTree = [
+  {
+    nodeId: 1,
+    name: 'root1',
+    subNodes: [{ nodeId: 2, name: 'child1' }],
+  },
+];
+const fieldNames = { children: 'subNodes', id: 'nodeId' };
+console.log(t.isRootNode(customTree, 1, fieldNames)) // true
+console.log(t.isRootNode(customTree, 2, fieldNames)) // false
+
+// 节点不存在时返回 false
+console.log(t.isRootNode(treeData, 999)) // false
+```
+
+**与现有方法的区别：**
+- `isRootNode` - 语义化方法，直接返回布尔值
+- `getParentTree` - 返回父节点对象，需要判断是否为 null
+- `getNodeDepth` - 返回深度，需要判断是否等于 1
+
+### isEmptyTreeData
 
 检查树结构数据（数组）是否为空。空数组、null、undefined 都视为空。此函数支持 fieldNames 参数以保持 API 一致性，但该参数不生效（因为只检查数组是否为空，不访问 children 或 id 字段）。
 
@@ -513,7 +707,7 @@ const isEmptyWithFieldNames = t.isEmptyTreeData(treeData, fieldNames)
 console.log(isEmptyWithFieldNames) // false（结果与不传 fieldNames 相同）
 ```
 
-### isEmptySingleTreeData（检查单个树结构数据是否为空）
+### isEmptySingleTreeData
 
 检查单个树结构数据是否为空。如果数据不是有效的单个树结构数据、没有 children 字段，或者 children 是空数组，则视为空。如果有子节点（children 数组不为空），即使子节点本身是空的，树也不为空。
 
@@ -566,7 +760,56 @@ const isEmptyCustom = t.isEmptySingleTreeData(customTree, fieldNames)
 console.log(isEmptyCustom) // true
 ```
 
-### isSingleTreeData（判断数据是否是单个树结构数据）
+### isTreeData
+
+判断数据是否是树结构数据（数组）。树结构数据必须是一个数组，数组中的每个元素都必须是有效的单个树结构数据。
+
+```javascript
+// 有效的树结构数据（森林）
+const forest = [
+  {
+    id: 1,
+    name: 'node1',
+    children: [{ id: 2, name: 'node2' }],
+  },
+  {
+    id: 3,
+    name: 'node3',
+    children: [{ id: 4, name: 'node4' }],
+  },
+];
+console.log(t.isTreeData(forest)) // true
+
+// 空数组也是有效的树结构数据（空森林）
+console.log(t.isTreeData([])) // true
+
+// 单个对象不是树结构数据（应该用 isSingleTreeData）
+console.log(t.isTreeData({ id: 1 })) // false
+
+// 数组包含非树结构元素，返回 false
+const invalidForest = [
+  { id: 1, children: [{ id: 2 }] },
+  'not a tree', // 无效元素
+];
+console.log(t.isTreeData(invalidForest)) // 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' }],
+  },
+];
+const fieldNames = { children: 'subNodes', id: 'nodeId' };
+console.log(t.isTreeData(customForest, fieldNames)) // true
+```
+
+### isSingleTreeData
 
 判断数据是否是单个树结构数据（单个对象）。树结构数据必须是一个对象（不能是数组、null、undefined 或基本类型），如果存在 children 字段，必须是数组类型，并且会递归检查所有子节点。
 
@@ -608,55 +851,136 @@ const fieldNames = { children: 'subNodes', id: 'nodeId' };
 console.log(t.isSingleTreeData(customTree, fieldNames)) // true
 ```
 
-### isTreeData（判断数据是否是树结构数据）
+### isValidTreeNode
 
-判断数据是否是树结构数据（数组）。树结构数据必须是一个数组，数组中的每个元素都必须是有效的单个树结构数据。
+检查单个节点是否是有效的树节点结构（轻量级，不递归检查子节点）。只检查节点本身的结构，不检查子节点。
 
 ```javascript
-// 有效的树结构数据（森林）
-const forest = [
+// 有效的树节点（有 children 数组）
+const node1 = {
+  id: 1,
+  name: 'node1',
+  children: [{ id: 2 }],
+};
+console.log(t.isValidTreeNode(node1)) // true
+
+// 有效的树节点（没有 children 字段）
+const node2 = { id: 1, name: 'node1' };
+console.log(t.isValidTreeNode(node2)) // true
+
+// 无效的树节点（children 不是数组）
+const invalidNode = {
+  id: 1,
+  children: 'not an array',
+};
+console.log(t.isValidTreeNode(invalidNode)) // false
+
+// 支持自定义字段名
+const customNode = {
+  nodeId: 1,
+  subNodes: [{ nodeId: 2 }],
+};
+const fieldNames = { children: 'subNodes', id: 'nodeId' };
+console.log(t.isValidTreeNode(customNode, fieldNames)) // true
+```
+
+**与 isSingleTreeData 的区别：**
+- `isValidTreeNode` - 只检查单个节点的基本结构，不递归检查子节点（轻量级）
+- `isSingleTreeData` - 递归检查整个树结构，确保所有子节点都是有效的树结构
+
+### isTreeNodeWithCircularCheck
+
+检查节点是否是有效的树节点结构，并检测循环引用。使用 WeakSet 跟踪已访问的节点，如果发现循环引用则返回 false。
+
+```javascript
+// 有效的树节点（无循环引用）
+const validNode = {
+  id: 1,
+  children: [
+    { id: 2, children: [{ id: 3 }] },
+  ],
+};
+console.log(t.isTreeNodeWithCircularCheck(validNode)) // true
+
+// 检测循环引用
+const node1 = { id: 1, children: [] };
+const node2 = { id: 2, children: [] };
+node1.children.push(node2);
+node2.children.push(node1); // 循环引用
+console.log(t.isTreeNodeWithCircularCheck(node1)) // false
+
+// 检测自引用
+const selfRefNode = { id: 1, children: [] };
+selfRefNode.children.push(selfRefNode); // 自引用
+console.log(t.isTreeNodeWithCircularCheck(selfRefNode)) // false
+
+// 支持自定义字段名
+const customNode = {
+  nodeId: 1,
+  subNodes: [{ nodeId: 2 }],
+};
+const fieldNames = { children: 'subNodes', id: 'nodeId' };
+console.log(t.isTreeNodeWithCircularCheck(customNode, fieldNames)) // true
+```
+
+**使用场景：**
+- 在接收用户输入或外部数据时，检查是否有循环引用
+- 数据验证，防止无限递归
+- 调试时检查数据结构是否正确
+
+### isSafeTreeDepth
+
+检查树结构数据的深度是否安全（防止递归爆栈）。如果树的深度超过 `maxDepth`，返回 false。
+
+```javascript
+// 深度安全的树
+const safeTree = [
   {
     id: 1,
-    name: 'node1',
-    children: [{ id: 2, name: 'node2' }],
+    children: [
+      { id: 2, children: [{ id: 3 }] },
+    ],
   },
+];
+console.log(t.isSafeTreeDepth(safeTree, 10)) // true（深度为3，小于10）
+
+// 深度超过最大深度
+const deepTree = [
   {
-    id: 3,
-    name: 'node3',
-    children: [{ id: 4, name: 'node4' }],
+    id: 1,
+    children: [
+      { id: 2, children: [{ id: 3 }] },
+    ],
   },
 ];
-console.log(t.isTreeData(forest)) // true
+console.log(t.isSafeTreeDepth(deepTree, 2)) // false（深度为3，超过2）
 
-// 空数组也是有效的树结构数据（空森林）
-console.log(t.isTreeData([])) // true
+// 空树总是安全的
+console.log(t.isSafeTreeDepth([], 10)) // true
 
-// 单个对象不是树结构数据（应该用 isSingleTreeData）
-console.log(t.isTreeData({ id: 1 })) // false
-
-// 数组包含非树结构元素，返回 false
-const invalidForest = [
-  { id: 1, children: [{ id: 2 }] },
-  'not a tree', // 无效元素
-];
-console.log(t.isTreeData(invalidForest)) // false
-
-// null 或 undefined 不是有效的树结构数据
-console.log(t.isTreeData(null)) // false
-console.log(t.isTreeData(undefined)) // false
+// 单层树
+const singleLayer = [{ id: 1 }, { id: 2 }];
+console.log(t.isSafeTreeDepth(singleLayer, 1)) // true
 
 // 支持自定义字段名
-const customForest = [
+const customTree = [
   {
     nodeId: 1,
-    name: 'node1',
-    subNodes: [{ nodeId: 2, name: 'node2' }],
+    subNodes: [
+      { nodeId: 2, subNodes: [{ nodeId: 3 }] },
+    ],
   },
 ];
 const fieldNames = { children: 'subNodes', id: 'nodeId' };
-console.log(t.isTreeData(customForest, fieldNames)) // true
+console.log(t.isSafeTreeDepth(customTree, 3, fieldNames)) // true
+console.log(t.isSafeTreeDepth(customTree, 2, fieldNames)) // false
 ```
 
+**使用场景：**
+- 在处理大型树之前，先检查深度是否安全
+- 防止递归调用栈溢出
+- 性能优化，避免处理过深的树结构
+
 ## 自定义字段名
 
 所有方法都支持自定义 children 和 id 的属性名，通过最后一个参数传入配置对象：
@@ -670,7 +994,7 @@ const fieldNames = { children: 'subNodes', id: 'nodeId' };
 const foundNode2 = t.findTree(customTreeData, (node) => node.nodeId === 2, fieldNames);
 ```
 
-**注意：** 所有 25 个函数都支持 `fieldNames` 参数，保持 API 一致性。即使某些函数（如 `isEmptyTreeData`）中该参数不生效，也可以传入以保持代码风格一致。
+**注意：** 所有 30 个函数都支持 `fieldNames` 参数，保持 API 一致性。即使某些函数（如 `isEmptyTreeData`）中该参数不生效，也可以传入以保持代码风格一致。
 
 ## 测试
 
@@ -707,6 +1031,36 @@ npm run build
 - **Terser** - JavaScript 压缩工具
 - **TypeScript** - 类型支持
 
-## License
+## 🤝 贡献
+
+欢迎贡献！如果你有任何想法或发现问题，请：
+
+1. Fork 本仓库
+2. 创建你的特性分支 (`git checkout -b feature/AmazingFeature`)
+3. 提交你的更改 (`git commit -m 'Add some AmazingFeature'`)
+4. 推送到分支 (`git push origin feature/AmazingFeature`)
+5. 开启一个 Pull Request
+
+## 📝 更新日志
+
+查看 [CHANGELOG.md](./CHANGELOG.md) 了解详细的版本更新记录。
+
+## 📄 许可证
+
+本项目采用 [MIT](./LICENSE) 许可证。
+
+## 🔗 相关链接
+
+- [GitHub 仓库](https://github.com/knott11/tree-processor)
+- [npm 包](https://www.npmjs.com/package/tree-processor)
+- [问题反馈](https://github.com/knott11/tree-processor/issues)
+
+---
+
+<div align="center">
+
+如果这个项目对你有帮助，请给它一个 ⭐️
+
+Made with ❤️ by [knott11](https://github.com/knott11)
 
-MIT
+</div>

package/dist/index.d.ts

@@ -29,6 +29,11 @@ export declare function getParentTree(tree: TreeData, targetId: any, fieldNames?
 export declare function includesTree(tree: TreeData, targetId: any, fieldNames?: FieldNames): boolean;
 export declare function isSingleTreeData(data: any, fieldNames?: FieldNames): boolean;
 export declare function isTreeData(data: any, fieldNames?: FieldNames): boolean;
+export declare function isValidTreeNode(value: unknown, fieldNames?: FieldNames): value is TreeNode;
+export declare function isTreeNodeWithCircularCheck(value: unknown, fieldNames?: FieldNames, visited?: WeakSet<object>): boolean;
+export declare function isSafeTreeDepth(tree: TreeData, maxDepth: number, fieldNames?: FieldNames): boolean;
+export declare function isLeafNode(node: TreeNode, fieldNames?: FieldNames): boolean;
+export declare function isRootNode(tree: TreeData, nodeId: any, fieldNames?: FieldNames): boolean;
 declare const treeProcessor: {
     mapTree: typeof mapTree;
     filterTree: typeof filterTree;
@@ -55,6 +60,11 @@ declare const treeProcessor: {
     includesTree: typeof includesTree;
     isSingleTreeData: typeof isSingleTreeData;
     isTreeData: typeof isTreeData;
+    isValidTreeNode: typeof isValidTreeNode;
+    isTreeNodeWithCircularCheck: typeof isTreeNodeWithCircularCheck;
+    isSafeTreeDepth: typeof isSafeTreeDepth;
+    isLeafNode: typeof isLeafNode;
+    isRootNode: typeof isRootNode;
 };
 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":"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"}

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":"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 data = {"version":2,"tree":{"name":"root","children":[{"name":"tree-processor.cjs.js","children":[{"name":"src/index.ts","uid":"7eca4295-1"}]}],"isRoot":true},"nodeParts":{"7eca4295-1":{"renderedLength":17081,"gzipLength":2155,"brotliLength":1901,"metaUid":"7eca4295-0"}},"nodeMetas":{"7eca4295-0":{"id":"\\src\\index.ts","moduleParts":{"tree-processor.cjs.js":"7eca4295-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

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

package/dist/tree-processor.esm.js

@@ -56,31 +56,43 @@ if(o[e.id]===t)return n.splice(i,1),!0
 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 p(r){return!Array.isArray(r)||0===r.length}function D(n,t=r){if(!x(n,t))return!0
+Array.isArray(n)&&n.length>0&&r(n)}}(n)}function p(r){return!Array.isArray(r)||0===r.length}function v(n,t=r){if(!b(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
+return void 0===e||(!Array.isArray(e)||0===e.length)}function D(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}
+return Array.isArray(o)?o:[]}function N(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
+return Array.isArray(o)?o:[]}function S(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 S(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 m(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&&S(n,t,e))return!0}return!1}function x(n,t=r){if(!n||"object"!=typeof n||Array.isArray(n))return!1
+if(Array.isArray(n)&&n.length>0&&m(n,t,e))return!0}return!1}function b(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(!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}
+for(const r of e)if(!b(r,t))return!1}return!0}function E(n,t=r){if(!Array.isArray(n))return!1
+for(const r of n)if(!b(r,t))return!1
+return!0}function j(n,t=r){if(!n||"object"!=typeof n||Array.isArray(n))return!1
+const e=n[t.children]
+return void 0===e||Array.isArray(e)}function x(n,t=r,e=new WeakSet){if(!n||"object"!=typeof n||Array.isArray(n))return!1
+if(e.has(n))return!1
+e.add(n)
+const i=n[t.children]
+if(void 0!==i){if(null===i)return!1
+if(!Array.isArray(i))return!1
+for(const r of i)if(!x(r,t,e))return!1}return!0}function C(n,t,e=r){if(t<=0)return!1
+return function r(n,i){if(i>t)return!1
+for(const t of n){const n=t[e.children]
+if(Array.isArray(n)&&n.length>0&&!r(n,i+1))return!1}return!0}(n,1)}function k(n,t=r){const e=n[t.children]
+return void 0===e||!Array.isArray(e)||0===e.length}function w(n,t,e=r){return!!m(n,t,e)&&null===S(n,t,e)}const O={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:v,getParentTree:S,getChildrenTree:D,getSiblingsTree:N,includesTree:m,isSingleTreeData:b,isTreeData:E,isValidTreeNode:j,isTreeNodeWithCircularCheck:x,isSafeTreeDepth:C,isLeafNode:k,isRootNode:w}
+export{h as atIndexOfTree,s as atTree,A as dedupTree,O as default,l as everyTree,t as filterTree,e as findTree,T as forEachTree,D as getChildrenTree,d as getNodeDepth,y as getNodeDepthMap,S as getParentTree,N as getSiblingsTree,m as includesTree,a as indexOfTree,v as isEmptySingleTreeData,p as isEmptyTreeData,k as isLeafNode,w as isRootNode,C as isSafeTreeDepth,b as isSingleTreeData,E as isTreeData,x as isTreeNodeWithCircularCheck,j as isValidTreeNode,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,67 +5,67 @@ 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 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 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 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 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
+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
 const n=o[i.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]
+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]
 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 l(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 s(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&&l(r,e,t))return!0}return!1}function s(r,e,t=n){for(const n of r){if(!e(n))return!1
+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
 const r=n[t.children]
-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
+if(Array.isArray(r)&&r.length>0&&!l(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 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)
+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 h(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)
 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 u=o[t.children]
-if(!Array.isArray(u))return null
-i=u}return null}function y(r,e=n){const t={}
+const f=o[t.children]
+if(!Array.isArray(f))return null
+i=f}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){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
+if(null!==e)return e}}return null}(r)}function T(r,e,t=n){const i=new Set
 return function r(n){const o=[]
-for(const u of n){const n=u[e]
+for(const f of n){const n=f[e]
 if(null!=n){if(i.has(n))continue
-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]
+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 g(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 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 f=o[t.children]
+if(Array.isArray(f)&&f.length>0&&r(f))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
+Array.isArray(n)&&n.length>0&&r(n)}}(r)}function D(r){return!Array.isArray(r)||0===r.length}function m(r,e=n){if(!x(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
+return void 0===t||(!Array.isArray(t)||0===t.length)}function N(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]
 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}
+return Array.isArray(o)?o:[]}function S(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)
@@ -75,13 +75,25 @@ 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 x(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 b(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&&x(r,e,t))return!0}return!1}function E(r,e=n){if(!r||"object"!=typeof r||Array.isArray(r))return!1
+if(Array.isArray(r)&&r.length>0&&b(r,e,t))return!0}return!1}function x(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(!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"}})})
+for(const r of t)if(!x(r,e))return!1}return!0}function E(r,e=n){if(!Array.isArray(r))return!1
+for(const n of r)if(!x(n,e))return!1
+return!0}function C(r,e=n){if(!r||"object"!=typeof r||Array.isArray(r))return!1
+const t=r[e.children]
+return void 0===t||Array.isArray(t)}function j(r,e=n,t=new WeakSet){if(!r||"object"!=typeof r||Array.isArray(r))return!1
+if(t.has(r))return!1
+t.add(r)
+const i=r[e.children]
+if(void 0!==i){if(null===i)return!1
+if(!Array.isArray(i))return!1
+for(const r of i)if(!j(r,e,t))return!1}return!0}function O(r,e,t=n){if(e<=0)return!1
+return function r(n,i){if(i>e)return!1
+for(const e of n){const n=e[t.children]
+if(Array.isArray(n)&&n.length>0&&!r(n,i+1))return!1}return!0}(r,1)}function M(r,e=n){const t=r[e.children]
+return void 0===t||!Array.isArray(t)||0===t.length}function P(r,e,t=n){return!!b(r,e,t)&&null===v(r,e,t)}const k={mapTree:e,filterTree:t,findTree:i,pushTree:o,unshiftTree:f,popTree:u,shiftTree:c,someTree:s,everyTree:l,atTree:a,indexOfTree:h,atIndexOfTree:d,getNodeDepthMap:y,getNodeDepth:A,dedupTree:T,removeTree:g,forEachTree:p,isEmptyTreeData:D,isEmptySingleTreeData:m,getParentTree:v,getChildrenTree:N,getSiblingsTree:S,includesTree:b,isSingleTreeData:x,isTreeData:E,isValidTreeNode:C,isTreeNodeWithCircularCheck:j,isSafeTreeDepth:O,isLeafNode:M,isRootNode:P}
+r.atIndexOfTree=d,r.atTree=a,r.dedupTree=T,r.default=k,r.everyTree=l,r.filterTree=t,r.findTree=i,r.forEachTree=p,r.getChildrenTree=N,r.getNodeDepth=A,r.getNodeDepthMap=y,r.getParentTree=v,r.getSiblingsTree=S,r.includesTree=b,r.indexOfTree=h,r.isEmptySingleTreeData=m,r.isEmptyTreeData=D,r.isLeafNode=M,r.isRootNode=P,r.isSafeTreeDepth=O,r.isSingleTreeData=x,r.isTreeData=E,r.isTreeNodeWithCircularCheck=j,r.isValidTreeNode=C,r.mapTree=e,r.popTree=u,r.pushTree=o,r.removeTree=g,r.shiftTree=c,r.someTree=s,r.unshiftTree=f,Object.defineProperties(r,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tree-processor",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "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",
@@ -42,7 +42,16 @@
     "every",
     "at",
     "indexOf",
+    "depth",
     "deduplicate",
+    "menu",
+    "navigation",
+    "file-tree",
+    "directory",
+    "category",
+    "comment",
+    "permission",
+    "tree-select",
     "tree-processor"
   ],
   "author": "",