@cloudcome/utils-core 1.19.1 → 1.20.1

package/dist/tree.cjs

@@ -1,125 +1,220 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const array = require("./array.cjs");
-const type = require("./type.cjs");
+const require_type = require("./type.cjs");
+const require_array = require("./array.cjs");
+//#region src/tree.ts
+/**
+* 深度遍历数组中的每个元素，并对每个元素执行提供的回调函数。
+*
+* @param treeList - 要遍历的深度数组。
+* @param iterator - 对每个元素执行的回调函数。如果回调函数返回 `false`，则提前终止遍历。
+* @param breadthFist - 是否使用广度优先遍历，默认为 `false`（深度优先）。
+* @returns 无返回值。
+*
+* @example
+* ```typescript
+* const treeList = [
+*   { value: 1, children: [{ value: 2 }, { value: 3 }] },
+*   { value: 4 }
+* ];
+*
+* treeEach(treeList, (item) => {
+*   console.log(item.value);
+*   if (item.value === 2) return false; // 提前终止遍历
+* });
+* ```
+*/
 function treeEach(treeList, iterator, breadthFist = false) {
-  const treeInfoList = [];
-  let returnFalse = false;
-  const iterate = (info) => {
-    if (iterator(info) === false) {
-      returnFalse = true;
-      return false;
-    }
-  };
-  const next = (info, walk2) => {
-    const { item, level, parent, path } = info;
-    const { children } = item;
-    if (type.isArray(children)) {
-      returnFalse = walk2({
-        ...info,
-        parent: item,
-        list: children,
-        level: level + 1
-      }) === false;
-    }
-  };
-  const walk = (walker) => {
-    const { list, level, parent, path } = walker;
-    const path2 = [...path];
-    while (parent !== null && path2.length > 0 && path2[path2.length - 1] !== parent) {
-      path2.pop();
-    }
-    array.arrayEach(list, (item, index) => {
-      if (returnFalse) return false;
-      const info = {
-        ...walker,
-        item,
-        index,
-        path: [...path2, item]
-      };
-      if (breadthFist) {
-        treeInfoList.push(info);
-      } else {
-        iterate(info);
-        if (returnFalse) return false;
-        next(info, walk);
-      }
-    });
-    if (breadthFist) {
-      while (!returnFalse) {
-        const info = treeInfoList.shift();
-        if (!info) break;
-        iterate(info);
-        if (returnFalse) break;
-        next(info, walk);
-      }
-    }
-    return !returnFalse;
-  };
-  walk({
-    list: treeList,
-    level: 1,
-    parent: null,
-    path: []
-  });
+	const treeInfoList = [];
+	let returnFalse = false;
+	const iterate = (info) => {
+		if (iterator(info) === false) {
+			returnFalse = true;
+			return false;
+		}
+	};
+	const next = (info, walk) => {
+		const { item, level } = info;
+		const { children } = item;
+		if (require_type.isArray(children)) returnFalse = walk({
+			...info,
+			parent: item,
+			list: children,
+			level: level + 1
+		}) === false;
+	};
+	const walk = (walker) => {
+		const { list, parent, path } = walker;
+		const path2 = [...path];
+		while (parent !== null && path2.length > 0 && path2[path2.length - 1] !== parent) path2.pop();
+		require_array.arrayEach(list, (item, index) => {
+			if (returnFalse) return false;
+			const info = {
+				...walker,
+				item,
+				index,
+				path: [...path2, item]
+			};
+			if (breadthFist) treeInfoList.push(info);
+			else {
+				iterate(info);
+				if (returnFalse) return false;
+				next(info, walk);
+			}
+		});
+		if (breadthFist) while (!returnFalse) {
+			const info = treeInfoList.shift();
+			if (!info) break;
+			iterate(info);
+			if (returnFalse) break;
+			next(info, walk);
+		}
+		return !returnFalse;
+	};
+	walk({
+		list: treeList,
+		level: 1,
+		parent: null,
+		path: []
+	});
 }
+/**
+* 在深度数组中查找满足条件的第一个节点信息。
+*
+* @param treeList - 要查找的深度数组。
+* @param predicate - 判断节点是否满足条件的回调函数。
+* @param breadthFist - 是否使用广度优先查找，默认为 `false`（深度优先）。
+* @returns 如果找到满足条件的节点，则返回该节点的信息；否则返回 `undefined`。
+*
+* @example
+* ```typescript
+* const treeList = [
+*   { value: 1, children: [{ value: 2 }, { value: 3 }] },
+*   { value: 4 }
+* ];
+*
+* const found = treeFind(treeList, (info) => info.item.value === 3);
+* console.log(found);
+* // {
+* //    item: { value: 3 },
+* //    index: 1,
+* //    list: [{ value: 2 }, { value: 3 }],
+* //    parent: { value: 1, children: [{ value: 2 }, { value: 3 }] },
+* //    level: 2,
+* //    path: [{ value: 1, children: [{ value: 2 }, { value: 3 }] }, { value: 3 }]
+* // }
+* ```
+*/
 function treeFind(treeList, predicate, breadthFist = false) {
-  let found;
-  treeEach(
-    treeList,
-    (info) => {
-      if (predicate(info)) {
-        found = info;
-        return false;
-      }
-    },
-    breadthFist
-  );
-  return found;
+	let found;
+	treeEach(treeList, (info) => {
+		if (predicate(info)) {
+			found = info;
+			return false;
+		}
+	}, breadthFist);
+	return found;
 }
+/**
+* 将深度嵌套的树形结构扁平化为一维数组，并对每个节点执行指定的转换函数。
+*
+* @template I - 树节点的类型，必须继承自 `TreeItem`。
+* @template T - 转换后的数据类型。
+* @param {TreeList<I>} deepList - 要扁平化的深度嵌套树形结构。
+* @param {(info: TreeInfo<I>) => T} flatten - 对每个节点执行的转换函数，返回转换后的数据。
+* @param {boolean} [breadthFist=false] - 是否使用广度优先遍历，默认为 `false`（深度优先）。
+* @returns {T[]} - 转换后的一维数组。
+* @example
+* ```typescript
+* const treeList = [
+*   { value: 1, children: [{ value: 2 }, { value: 3 }] },
+*   { value: 4 }
+* ];
+*
+* const flattened = deepFlat(treeList, (info) => info.item.value);
+* console.log(flattened); // [1, 2, 3, 4]
+* ```
+*/
 function deepFlat(deepList, flatten, breadthFist = false) {
-  const list2 = [];
-  treeEach(
-    deepList,
-    (info) => {
-      list2.push(flatten(info));
-    },
-    breadthFist
-  );
-  return list2;
+	const list2 = [];
+	treeEach(deepList, (info) => {
+		list2.push(flatten(info));
+	}, breadthFist);
+	return list2;
 }
+/**
+* 从扁平列表构建树形结构。
+*
+* @template I - 节点对象的类型，必须继承自 `AnyObject`。
+* @param {I[]} list - 扁平化的节点列表。
+* @param {TreeFromOptions<I>} options - 构建树形结构的配置选项。
+* @param {function} options.getSelfKey - 获取节点自身唯一标识的函数。
+* @param {function} options.getParentKey - 获取节点父节点唯一标识的函数。
+* @param {function} options.appendChild - 将子节点添加到父节点的函数。
+* @returns {I | undefined} - 构建的树形结构的根节点，如果未找到根节点则返回 `undefined`。
+*
+* @example
+* ```typescript
+* const list = [
+*   { id: 1, parentId: null, name: 'Root' },
+*   { id: 2, parentId: 1, name: 'Child 1' },
+*   { id: 3, parentId: 1, name: 'Child 2' }
+* ];
+*
+* const tree = treeFrom(list, {
+*   getSelfKey: (item) => item.id,
+*   getParentKey: (item) => item.parentId,
+*   appendChild: (parent, info) => {
+*     if (!parent.children) parent.children = [];
+*     parent.children.push(info.item);
+*   }
+* });
+*
+* console.log(tree);
+* // {
+* //   id: 1,
+* //   parentId: null,
+* //   name: 'Root',
+* //   children: [
+* //     { id: 2, parentId: 1, name: 'Child 1' },
+* //     { id: 3, parentId: 1, name: 'Child 2' }
+* //   ]
+* // }
+* ```
+*/
 function treeFrom(list, options) {
-  const keyMap = /* @__PURE__ */ new Map();
-  const freeSet = /* @__PURE__ */ new Set();
-  const roots = [];
-  const assign = (info, isFirst = false) => {
-    const { selfKey, parentKey, item, index } = info;
-    if (type.isNullish(parentKey)) {
-      roots.push(item);
-    } else {
-      const parent = keyMap.get(parentKey);
-      if (type.isUndefined(parent)) {
-        if (isFirst) freeSet.add(info);
-      } else {
-        options.appendChild(parent, info);
-      }
-    }
-  };
-  array.arrayEach(list, (item, index) => {
-    const selfKey = options.getSelfKey(item, index);
-    const parentKey = options.getParentKey(item, index);
-    if (type.isNullish(selfKey)) return;
-    const info = { selfKey, parentKey, item, index };
-    keyMap.set(selfKey, info);
-    assign(info, true);
-  });
-  for (const info of freeSet.values()) {
-    assign(info);
-  }
-  return roots;
+	const keyMap = /* @__PURE__ */ new Map();
+	const freeSet = /* @__PURE__ */ new Set();
+	const roots = [];
+	const assign = (info, isFirst = false) => {
+		const { parentKey, item } = info;
+		if (require_type.isNullish(parentKey)) roots.push(item);
+		else {
+			const parent = keyMap.get(parentKey);
+			if (require_type.isUndefined(parent)) {
+				if (isFirst) freeSet.add(info);
+			} else options.appendChild(parent, info);
+		}
+	};
+	require_array.arrayEach(list, (item, index) => {
+		const selfKey = options.getSelfKey(item, index);
+		const parentKey = options.getParentKey(item, index);
+		if (require_type.isNullish(selfKey)) return;
+		const info = {
+			selfKey,
+			parentKey,
+			item,
+			index
+		};
+		keyMap.set(selfKey, info);
+		assign(info, true);
+	});
+	for (const info of freeSet.values()) assign(info);
+	return roots;
 }
+//#endregion
 exports.deepFlat = deepFlat;
 exports.treeEach = treeEach;
 exports.treeFind = treeFind;
 exports.treeFrom = treeFrom;
-//# sourceMappingURL=tree.cjs.map
+
+//# sourceMappingURL=tree.cjs.map

package/dist/tree.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"tree.cjs","sources":["../src/tree.ts"],"sourcesContent":["import { arrayEach } from './array';\nimport { isArray, isNullish, isUndefined } from './type';\nimport type { AnyObject } from './types';\n\n/**\n * 表示深度遍历中的节点对象，包含子节点列表。\n */\nexport type TreeItem = AnyObject & {\n  /**\n   * 子节点列表。\n   */\n  children?: TreeItem[];\n};\n\n/**\n * 表示深度遍历中的节点列表。\n *\n * @template I - 节点对象的类型，必须继承自 `TreeItem`。\n */\nexport type TreeList<I extends TreeItem> = I[];\n\n/**\n * 表示深度遍历中的遍历器状态。\n *\n * @template I - 节点对象的类型，必须继承自 `TreeItem`。\n */\nexport type TreeWalker<I extends TreeItem> = {\n  /**\n   * 当前层级的节点列表。\n   */\n  list: TreeList<I>;\n\n  /**\n   * 当前节点的父节点，如果为根节点则为 `null`。\n   */\n  parent: I | null;\n\n  /**\n   * 当前节点的层级，从 1 开始计数。\n   */\n  level: number;\n\n  /**\n   * 从根节点到当前节点的路径。\n   */\n  path: TreeList<I>;\n};\n\n/**\n * 表示深度遍历中的节点信息。\n *\n * @template I - 节点对象的类型，必须继承自 `TreeItem`。\n */\nexport type TreeInfo<I extends TreeItem> = TreeWalker<I> & {\n  /**\n   * 当前节点。\n   */\n  item: I;\n\n  /**\n   * 当前节点在 `list` 中的索引。\n   */\n  index: number;\n};\n\n/**\n * 深度遍历的同步迭代器函数类型。\n *\n * @template I - 节点对象的类型，必须继承自 `TreeItem`。\n * @param info - 当前节点的信息。\n * @returns 如果返回 `false`，则提前终止遍历。\n */\nexport type TreeEachIterator<I extends TreeItem> = (info: TreeInfo<I>) => false | unknown;\n\n/**\n * 深度遍历的异步迭代器函数类型。\n *\n * @template I - 节点对象的类型，必须继承自 `TreeItem`。\n * @param info - 当前节点的信息。\n * @returns 如果返回 `false`，则提前终止遍历。\n */\nexport type TreeEachIteratorAsync<I extends TreeItem> = (info: TreeInfo<I>) => Promise<boolean | unknown>;\n\n/**\n * 深度遍历的同步遍历器函数类型。\n *\n * @template I - 节点对象的类型，必须继承自 `TreeItem`。\n * @param walker - 遍历器状态。\n * @returns 遍历结果。\n */\nexport type TreeWalk<I extends TreeItem> = (walker: TreeWalker<I>) => unknown;\n\n/**\n * 深度遍历的异步遍历器函数类型。\n *\n * @template I - 节点对象的类型，必须继承自 `TreeItem`。\n * @param walker - 遍历器状态。\n * @returns 异步遍历结果。\n */\nexport type TreeWalkAsync<I extends TreeItem> = (walker: TreeWalker<I>) => Promise<unknown>;\n\n/**\n * 深度遍历数组中的每个元素，并对每个元素执行提供的回调函数。\n *\n * @param treeList - 要遍历的深度数组。\n * @param iterator - 对每个元素执行的回调函数。如果回调函数返回 `false`，则提前终止遍历。\n * @param breadthFist - 是否使用广度优先遍历，默认为 `false`（深度优先）。\n * @returns 无返回值。\n *\n * @example\n * ```typescript\n * const treeList = [\n *   { value: 1, children: [{ value: 2 }, { value: 3 }] },\n *   { value: 4 }\n * ];\n *\n * treeEach(treeList, (item) => {\n *   console.log(item.value);\n *   if (item.value === 2) return false; // 提前终止遍历\n * });\n * ```\n */\nexport function treeEach<I extends TreeItem = TreeItem>(\n  treeList: TreeList<I>,\n  iterator: TreeEachIterator<I>,\n  breadthFist = false,\n): void {\n  const treeInfoList: TreeInfo<I>[] = [];\n  let returnFalse = false;\n\n  const iterate = (info: TreeInfo<I>) => {\n    if (iterator(info) === false) {\n      returnFalse = true;\n      return false;\n    }\n  };\n\n  const next = (info: TreeInfo<I>, walk: TreeWalk<I>) => {\n    const { item, level, parent, path } = info;\n    const { children } = item;\n\n    if (isArray(children)) {\n      returnFalse =\n        walk({\n          ...info,\n          parent: item,\n          list: children as TreeList<I>,\n          level: level + 1,\n        }) === false;\n    }\n  };\n\n  const walk: TreeWalk<I> = (walker) => {\n    const { list, level, parent, path } = walker;\n\n    const path2 = [...path];\n    while (parent !== null && path2.length > 0 && path2[path2.length - 1] !== parent) {\n      path2.pop();\n    }\n\n    arrayEach(list, (item, index) => {\n      if (returnFalse) return false;\n\n      const info: TreeInfo<I> = {\n        ...walker,\n        item,\n        index,\n        path: [...path2, item],\n      };\n\n      // 广度优先\n      if (breadthFist) {\n        treeInfoList.push(info);\n      }\n      // 深度优先\n      else {\n        iterate(info);\n        if (returnFalse) return false;\n        next(info, walk);\n      }\n    });\n\n    if (breadthFist) {\n      while (!returnFalse) {\n        const info = treeInfoList.shift();\n        if (!info) break;\n\n        iterate(info);\n        if (returnFalse) break;\n\n        // 内部也会进入 walk\n        next(info, walk);\n      }\n    }\n\n    return !returnFalse;\n  };\n\n  walk({\n    list: treeList,\n    level: 1,\n    parent: null,\n    path: [],\n  });\n}\n\n/**\n * 在深度数组中查找满足条件的第一个节点信息。\n *\n * @param treeList - 要查找的深度数组。\n * @param predicate - 判断节点是否满足条件的回调函数。\n * @param breadthFist - 是否使用广度优先查找，默认为 `false`（深度优先）。\n * @returns 如果找到满足条件的节点，则返回该节点的信息；否则返回 `undefined`。\n *\n * @example\n * ```typescript\n * const treeList = [\n *   { value: 1, children: [{ value: 2 }, { value: 3 }] },\n *   { value: 4 }\n * ];\n *\n * const found = treeFind(treeList, (info) => info.item.value === 3);\n * console.log(found);\n * // {\n * //    item: { value: 3 },\n * //    index: 1,\n * //    list: [{ value: 2 }, { value: 3 }],\n * //    parent: { value: 1, children: [{ value: 2 }, { value: 3 }] },\n * //    level: 2,\n * //    path: [{ value: 1, children: [{ value: 2 }, { value: 3 }] }, { value: 3 }]\n * // }\n * ```\n */\nexport function treeFind<I extends TreeItem>(\n  treeList: TreeList<I>,\n  predicate: (info: TreeInfo<I>) => boolean,\n  breadthFist = false,\n): TreeInfo<I> | undefined {\n  let found: TreeInfo<I> | undefined;\n\n  treeEach(\n    treeList,\n    (info) => {\n      if (predicate(info)) {\n        found = info;\n        return false;\n      }\n    },\n    breadthFist,\n  );\n\n  return found;\n}\n\n/**\n * 将深度嵌套的树形结构扁平化为一维数组，并对每个节点执行指定的转换函数。\n *\n * @template I - 树节点的类型，必须继承自 `TreeItem`。\n * @template T - 转换后的数据类型。\n * @param {TreeList<I>} deepList - 要扁平化的深度嵌套树形结构。\n * @param {(info: TreeInfo<I>) => T} flatten - 对每个节点执行的转换函数，返回转换后的数据。\n * @param {boolean} [breadthFist=false] - 是否使用广度优先遍历，默认为 `false`（深度优先）。\n * @returns {T[]} - 转换后的一维数组。\n * @example\n * ```typescript\n * const treeList = [\n *   { value: 1, children: [{ value: 2 }, { value: 3 }] },\n *   { value: 4 }\n * ];\n *\n * const flattened = deepFlat(treeList, (info) => info.item.value);\n * console.log(flattened); // [1, 2, 3, 4]\n * ```\n */\nexport function deepFlat<I extends TreeItem, T>(\n  deepList: TreeList<I>,\n  flatten: (info: TreeInfo<I>) => T,\n  breadthFist = false,\n): T[] {\n  const list2: T[] = [];\n\n  treeEach(\n    deepList,\n    (info) => {\n      list2.push(flatten(info));\n    },\n    breadthFist,\n  );\n\n  return list2;\n}\n\ntype FromItemInfo<I> = {\n  selfKey: unknown;\n  parentKey: unknown;\n  item: I;\n  index: number;\n};\n\nexport type TreeFromOptions<I extends TreeItem> = {\n  getSelfKey: (item: I, index: number) => unknown;\n  getParentKey: (item: I, index: number) => unknown;\n  appendChild: (parentInfo: FromItemInfo<I>, info: FromItemInfo<I>) => unknown;\n};\n\n/**\n * 从扁平列表构建树形结构。\n *\n * @template I - 节点对象的类型，必须继承自 `AnyObject`。\n * @param {I[]} list - 扁平化的节点列表。\n * @param {TreeFromOptions<I>} options - 构建树形结构的配置选项。\n * @param {function} options.getSelfKey - 获取节点自身唯一标识的函数。\n * @param {function} options.getParentKey - 获取节点父节点唯一标识的函数。\n * @param {function} options.appendChild - 将子节点添加到父节点的函数。\n * @returns {I | undefined} - 构建的树形结构的根节点，如果未找到根节点则返回 `undefined`。\n *\n * @example\n * ```typescript\n * const list = [\n *   { id: 1, parentId: null, name: 'Root' },\n *   { id: 2, parentId: 1, name: 'Child 1' },\n *   { id: 3, parentId: 1, name: 'Child 2' }\n * ];\n *\n * const tree = treeFrom(list, {\n *   getSelfKey: (item) => item.id,\n *   getParentKey: (item) => item.parentId,\n *   appendChild: (parent, info) => {\n *     if (!parent.children) parent.children = [];\n *     parent.children.push(info.item);\n *   }\n * });\n *\n * console.log(tree);\n * // {\n * //   id: 1,\n * //   parentId: null,\n * //   name: 'Root',\n * //   children: [\n * //     { id: 2, parentId: 1, name: 'Child 1' },\n * //     { id: 3, parentId: 1, name: 'Child 2' }\n * //   ]\n * // }\n * ```\n */\nexport function treeFrom<I extends TreeItem>(list: I[], options: TreeFromOptions<I>): TreeList<I> | undefined {\n  const keyMap = new Map<unknown, FromItemInfo<I>>();\n  const freeSet = new Set<FromItemInfo<I>>();\n  const roots: TreeList<I> = [];\n\n  // 分配节点\n  const assign = (info: FromItemInfo<I>, isFirst = false) => {\n    const { selfKey, parentKey, item, index } = info;\n\n    // 父级指向为空\n    if (isNullish(parentKey)) {\n      roots.push(item);\n    }\n    // 父级指向不为空\n    else {\n      const parent = keyMap.get(parentKey);\n\n      // 未找到父级节点\n      if (isUndefined(parent)) {\n        // 游离节点\n        if (isFirst) freeSet.add(info);\n      }\n      // 已找到父级节点\n      else {\n        options.appendChild(parent, info);\n      }\n    }\n  };\n\n  // 构建 map\n  arrayEach(list, (item, index) => {\n    const selfKey = options.getSelfKey(item, index);\n    const parentKey = options.getParentKey(item, index);\n\n    if (isNullish(selfKey)) return;\n\n    const info = { selfKey, parentKey, item, index };\n    keyMap.set(selfKey, info);\n\n    assign(info, true);\n  });\n\n  // 处理游离节点\n  for (const info of freeSet.values()) {\n    assign(info);\n  }\n\n  return roots;\n}\n"],"names":["walk","isArray","arrayEach","isNullish","isUndefined"],"mappings":"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"}
+{"version":3,"file":"tree.cjs","names":[],"sources":["../src/tree.ts"],"sourcesContent":["import { arrayEach } from './array';\nimport { isArray, isNullish, isUndefined } from './type';\nimport type { AnyObject } from './types';\n\n/**\n * 表示深度遍历中的节点对象，包含子节点列表。\n */\nexport type TreeItem = AnyObject & {\n  /**\n   * 子节点列表。\n   */\n  children?: TreeItem[];\n};\n\n/**\n * 表示深度遍历中的节点列表。\n *\n * @template I - 节点对象的类型，必须继承自 `TreeItem`。\n */\nexport type TreeList<I extends TreeItem> = I[];\n\n/**\n * 表示深度遍历中的遍历器状态。\n *\n * @template I - 节点对象的类型，必须继承自 `TreeItem`。\n */\nexport type TreeWalker<I extends TreeItem> = {\n  /**\n   * 当前层级的节点列表。\n   */\n  list: TreeList<I>;\n\n  /**\n   * 当前节点的父节点，如果为根节点则为 `null`。\n   */\n  parent: I | null;\n\n  /**\n   * 当前节点的层级，从 1 开始计数。\n   */\n  level: number;\n\n  /**\n   * 从根节点到当前节点的路径。\n   */\n  path: TreeList<I>;\n};\n\n/**\n * 表示深度遍历中的节点信息。\n *\n * @template I - 节点对象的类型，必须继承自 `TreeItem`。\n */\nexport type TreeInfo<I extends TreeItem> = TreeWalker<I> & {\n  /**\n   * 当前节点。\n   */\n  item: I;\n\n  /**\n   * 当前节点在 `list` 中的索引。\n   */\n  index: number;\n};\n\n/**\n * 深度遍历的同步迭代器函数类型。\n *\n * @template I - 节点对象的类型，必须继承自 `TreeItem`。\n * @param info - 当前节点的信息。\n * @returns 如果返回 `false`，则提前终止遍历。\n */\nexport type TreeEachIterator<I extends TreeItem> = (info: TreeInfo<I>) => false | unknown;\n\n/**\n * 深度遍历的异步迭代器函数类型。\n *\n * @template I - 节点对象的类型，必须继承自 `TreeItem`。\n * @param info - 当前节点的信息。\n * @returns 如果返回 `false`，则提前终止遍历。\n */\nexport type TreeEachIteratorAsync<I extends TreeItem> = (info: TreeInfo<I>) => Promise<boolean | unknown>;\n\n/**\n * 深度遍历的同步遍历器函数类型。\n *\n * @template I - 节点对象的类型，必须继承自 `TreeItem`。\n * @param walker - 遍历器状态。\n * @returns 遍历结果。\n */\nexport type TreeWalk<I extends TreeItem> = (walker: TreeWalker<I>) => unknown;\n\n/**\n * 深度遍历的异步遍历器函数类型。\n *\n * @template I - 节点对象的类型，必须继承自 `TreeItem`。\n * @param walker - 遍历器状态。\n * @returns 异步遍历结果。\n */\nexport type TreeWalkAsync<I extends TreeItem> = (walker: TreeWalker<I>) => Promise<unknown>;\n\n/**\n * 深度遍历数组中的每个元素，并对每个元素执行提供的回调函数。\n *\n * @param treeList - 要遍历的深度数组。\n * @param iterator - 对每个元素执行的回调函数。如果回调函数返回 `false`，则提前终止遍历。\n * @param breadthFist - 是否使用广度优先遍历，默认为 `false`（深度优先）。\n * @returns 无返回值。\n *\n * @example\n * ```typescript\n * const treeList = [\n *   { value: 1, children: [{ value: 2 }, { value: 3 }] },\n *   { value: 4 }\n * ];\n *\n * treeEach(treeList, (item) => {\n *   console.log(item.value);\n *   if (item.value === 2) return false; // 提前终止遍历\n * });\n * ```\n */\nexport function treeEach<I extends TreeItem = TreeItem>(\n  treeList: TreeList<I>,\n  iterator: TreeEachIterator<I>,\n  breadthFist = false,\n): void {\n  const treeInfoList: TreeInfo<I>[] = [];\n  let returnFalse = false;\n\n  const iterate = (info: TreeInfo<I>) => {\n    if (iterator(info) === false) {\n      returnFalse = true;\n      return false;\n    }\n  };\n\n  const next = (info: TreeInfo<I>, walk: TreeWalk<I>) => {\n    const { item, level } = info;\n    const { children } = item;\n\n    if (isArray(children)) {\n      returnFalse =\n        walk({\n          ...info,\n          parent: item,\n          list: children as TreeList<I>,\n          level: level + 1,\n        }) === false;\n    }\n  };\n\n  const walk: TreeWalk<I> = (walker) => {\n    const { list, parent, path } = walker;\n\n    const path2 = [...path];\n    while (parent !== null && path2.length > 0 && path2[path2.length - 1] !== parent) {\n      path2.pop();\n    }\n\n    arrayEach(list, (item, index) => {\n      if (returnFalse) return false;\n\n      const info: TreeInfo<I> = {\n        ...walker,\n        item,\n        index,\n        path: [...path2, item],\n      };\n\n      // 广度优先\n      if (breadthFist) {\n        treeInfoList.push(info);\n      }\n      // 深度优先\n      else {\n        iterate(info);\n        if (returnFalse) return false;\n        next(info, walk);\n      }\n    });\n\n    if (breadthFist) {\n      while (!returnFalse) {\n        const info = treeInfoList.shift();\n        if (!info) break;\n\n        iterate(info);\n        if (returnFalse) break;\n\n        // 内部也会进入 walk\n        next(info, walk);\n      }\n    }\n\n    return !returnFalse;\n  };\n\n  walk({\n    list: treeList,\n    level: 1,\n    parent: null,\n    path: [],\n  });\n}\n\n/**\n * 在深度数组中查找满足条件的第一个节点信息。\n *\n * @param treeList - 要查找的深度数组。\n * @param predicate - 判断节点是否满足条件的回调函数。\n * @param breadthFist - 是否使用广度优先查找，默认为 `false`（深度优先）。\n * @returns 如果找到满足条件的节点，则返回该节点的信息；否则返回 `undefined`。\n *\n * @example\n * ```typescript\n * const treeList = [\n *   { value: 1, children: [{ value: 2 }, { value: 3 }] },\n *   { value: 4 }\n * ];\n *\n * const found = treeFind(treeList, (info) => info.item.value === 3);\n * console.log(found);\n * // {\n * //    item: { value: 3 },\n * //    index: 1,\n * //    list: [{ value: 2 }, { value: 3 }],\n * //    parent: { value: 1, children: [{ value: 2 }, { value: 3 }] },\n * //    level: 2,\n * //    path: [{ value: 1, children: [{ value: 2 }, { value: 3 }] }, { value: 3 }]\n * // }\n * ```\n */\nexport function treeFind<I extends TreeItem>(\n  treeList: TreeList<I>,\n  predicate: (info: TreeInfo<I>) => boolean,\n  breadthFist = false,\n): TreeInfo<I> | undefined {\n  let found: TreeInfo<I> | undefined;\n\n  treeEach(\n    treeList,\n    (info) => {\n      if (predicate(info)) {\n        found = info;\n        return false;\n      }\n    },\n    breadthFist,\n  );\n\n  return found;\n}\n\n/**\n * 将深度嵌套的树形结构扁平化为一维数组，并对每个节点执行指定的转换函数。\n *\n * @template I - 树节点的类型，必须继承自 `TreeItem`。\n * @template T - 转换后的数据类型。\n * @param {TreeList<I>} deepList - 要扁平化的深度嵌套树形结构。\n * @param {(info: TreeInfo<I>) => T} flatten - 对每个节点执行的转换函数，返回转换后的数据。\n * @param {boolean} [breadthFist=false] - 是否使用广度优先遍历，默认为 `false`（深度优先）。\n * @returns {T[]} - 转换后的一维数组。\n * @example\n * ```typescript\n * const treeList = [\n *   { value: 1, children: [{ value: 2 }, { value: 3 }] },\n *   { value: 4 }\n * ];\n *\n * const flattened = deepFlat(treeList, (info) => info.item.value);\n * console.log(flattened); // [1, 2, 3, 4]\n * ```\n */\nexport function deepFlat<I extends TreeItem, T>(\n  deepList: TreeList<I>,\n  flatten: (info: TreeInfo<I>) => T,\n  breadthFist = false,\n): T[] {\n  const list2: T[] = [];\n\n  treeEach(\n    deepList,\n    (info) => {\n      list2.push(flatten(info));\n    },\n    breadthFist,\n  );\n\n  return list2;\n}\n\ntype FromItemInfo<I> = {\n  selfKey: unknown;\n  parentKey: unknown;\n  item: I;\n  index: number;\n};\n\nexport type TreeFromOptions<I extends TreeItem> = {\n  getSelfKey: (item: I, index: number) => unknown;\n  getParentKey: (item: I, index: number) => unknown;\n  appendChild: (parentInfo: FromItemInfo<I>, info: FromItemInfo<I>) => unknown;\n};\n\n/**\n * 从扁平列表构建树形结构。\n *\n * @template I - 节点对象的类型，必须继承自 `AnyObject`。\n * @param {I[]} list - 扁平化的节点列表。\n * @param {TreeFromOptions<I>} options - 构建树形结构的配置选项。\n * @param {function} options.getSelfKey - 获取节点自身唯一标识的函数。\n * @param {function} options.getParentKey - 获取节点父节点唯一标识的函数。\n * @param {function} options.appendChild - 将子节点添加到父节点的函数。\n * @returns {I | undefined} - 构建的树形结构的根节点，如果未找到根节点则返回 `undefined`。\n *\n * @example\n * ```typescript\n * const list = [\n *   { id: 1, parentId: null, name: 'Root' },\n *   { id: 2, parentId: 1, name: 'Child 1' },\n *   { id: 3, parentId: 1, name: 'Child 2' }\n * ];\n *\n * const tree = treeFrom(list, {\n *   getSelfKey: (item) => item.id,\n *   getParentKey: (item) => item.parentId,\n *   appendChild: (parent, info) => {\n *     if (!parent.children) parent.children = [];\n *     parent.children.push(info.item);\n *   }\n * });\n *\n * console.log(tree);\n * // {\n * //   id: 1,\n * //   parentId: null,\n * //   name: 'Root',\n * //   children: [\n * //     { id: 2, parentId: 1, name: 'Child 1' },\n * //     { id: 3, parentId: 1, name: 'Child 2' }\n * //   ]\n * // }\n * ```\n */\nexport function treeFrom<I extends TreeItem>(list: I[], options: TreeFromOptions<I>): TreeList<I> | undefined {\n  const keyMap = new Map<unknown, FromItemInfo<I>>();\n  const freeSet = new Set<FromItemInfo<I>>();\n  const roots: TreeList<I> = [];\n\n  // 分配节点\n  const assign = (info: FromItemInfo<I>, isFirst = false) => {\n    const { parentKey, item } = info;\n\n    // 父级指向为空\n    if (isNullish(parentKey)) {\n      roots.push(item);\n    }\n    // 父级指向不为空\n    else {\n      const parent = keyMap.get(parentKey);\n\n      // 未找到父级节点\n      if (isUndefined(parent)) {\n        // 游离节点\n        if (isFirst) freeSet.add(info);\n      }\n      // 已找到父级节点\n      else {\n        options.appendChild(parent, info);\n      }\n    }\n  };\n\n  // 构建 map\n  arrayEach(list, (item, index) => {\n    const selfKey = options.getSelfKey(item, index);\n    const parentKey = options.getParentKey(item, index);\n\n    if (isNullish(selfKey)) return;\n\n    const info = { selfKey, parentKey, item, index };\n    keyMap.set(selfKey, info);\n\n    assign(info, true);\n  });\n\n  // 处理游离节点\n  for (const info of freeSet.values()) {\n    assign(info);\n  }\n\n  return roots;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA0HA,SAAgB,SACd,UACA,UACA,cAAc,OACR;CACN,MAAM,eAA8B,EAAE;CACtC,IAAI,cAAc;CAElB,MAAM,WAAW,SAAsB;EACrC,IAAI,SAAS,KAAK,KAAK,OAAO;GAC5B,cAAc;GACd,OAAO;;;CAIX,MAAM,QAAQ,MAAmB,SAAsB;EACrD,MAAM,EAAE,MAAM,UAAU;EACxB,MAAM,EAAE,aAAa;EAErB,IAAI,aAAA,QAAQ,SAAS,EACnB,cACE,KAAK;GACH,GAAG;GACH,QAAQ;GACR,MAAM;GACN,OAAO,QAAQ;GAChB,CAAC,KAAK;;CAIb,MAAM,QAAqB,WAAW;EACpC,MAAM,EAAE,MAAM,QAAQ,SAAS;EAE/B,MAAM,QAAQ,CAAC,GAAG,KAAK;EACvB,OAAO,WAAW,QAAQ,MAAM,SAAS,KAAK,MAAM,MAAM,SAAS,OAAO,QACxE,MAAM,KAAK;EAGb,cAAA,UAAU,OAAO,MAAM,UAAU;GAC/B,IAAI,aAAa,OAAO;GAExB,MAAM,OAAoB;IACxB,GAAG;IACH;IACA;IACA,MAAM,CAAC,GAAG,OAAO,KAAK;IACvB;GAGD,IAAI,aACF,aAAa,KAAK,KAAK;QAGpB;IACH,QAAQ,KAAK;IACb,IAAI,aAAa,OAAO;IACxB,KAAK,MAAM,KAAK;;IAElB;EAEF,IAAI,aACF,OAAO,CAAC,aAAa;GACnB,MAAM,OAAO,aAAa,OAAO;GACjC,IAAI,CAAC,MAAM;GAEX,QAAQ,KAAK;GACb,IAAI,aAAa;GAGjB,KAAK,MAAM,KAAK;;EAIpB,OAAO,CAAC;;CAGV,KAAK;EACH,MAAM;EACN,OAAO;EACP,QAAQ;EACR,MAAM,EAAE;EACT,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BJ,SAAgB,SACd,UACA,WACA,cAAc,OACW;CACzB,IAAI;CAEJ,SACE,WACC,SAAS;EACR,IAAI,UAAU,KAAK,EAAE;GACnB,QAAQ;GACR,OAAO;;IAGX,YACD;CAED,OAAO;;;;;;;;;;;;;;;;;;;;;;AAuBT,SAAgB,SACd,UACA,SACA,cAAc,OACT;CACL,MAAM,QAAa,EAAE;CAErB,SACE,WACC,SAAS;EACR,MAAM,KAAK,QAAQ,KAAK,CAAC;IAE3B,YACD;CAED,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDT,SAAgB,SAA6B,MAAW,SAAsD;CAC5G,MAAM,yBAAS,IAAI,KAA+B;CAClD,MAAM,0BAAU,IAAI,KAAsB;CAC1C,MAAM,QAAqB,EAAE;CAG7B,MAAM,UAAU,MAAuB,UAAU,UAAU;EACzD,MAAM,EAAE,WAAW,SAAS;EAG5B,IAAI,aAAA,UAAU,UAAU,EACtB,MAAM,KAAK,KAAK;OAGb;GACH,MAAM,SAAS,OAAO,IAAI,UAAU;GAGpC,IAAI,aAAA,YAAY,OAAO;QAEjB,SAAS,QAAQ,IAAI,KAAK;UAI9B,QAAQ,YAAY,QAAQ,KAAK;;;CAMvC,cAAA,UAAU,OAAO,MAAM,UAAU;EAC/B,MAAM,UAAU,QAAQ,WAAW,MAAM,MAAM;EAC/C,MAAM,YAAY,QAAQ,aAAa,MAAM,MAAM;EAEnD,IAAI,aAAA,UAAU,QAAQ,EAAE;EAExB,MAAM,OAAO;GAAE;GAAS;GAAW;GAAM;GAAO;EAChD,OAAO,IAAI,SAAS,KAAK;EAEzB,OAAO,MAAM,KAAK;GAClB;CAGF,KAAK,MAAM,QAAQ,QAAQ,QAAQ,EACjC,OAAO,KAAK;CAGd,OAAO"}