npm - @cloudcome/utils-core - Versions diffs - 1.19.1 → 1.20.0 - Mend

@cloudcome/utils-core 1.19.1 → 1.20.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (161) hide show

package/dist/tree.mjs CHANGED Viewed

@@ -1,125 +1,216 @@
+import { isArray, isNullish, isUndefined } from "./type.mjs";
 import { arrayEach } from "./array.mjs";
-import { isNullish, isUndefined, isArray } from "./type.mjs";
+//#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 (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();
-    }
-    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 (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();
+		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 (isNullish(parentKey)) {
-      roots.push(item);
-    } else {
-      const parent = keyMap.get(parentKey);
-      if (isUndefined(parent)) {
-        if (isFirst) freeSet.add(info);
-      } else {
-        options.appendChild(parent, info);
-      }
-    }
-  };
-  arrayEach(list, (item, index) => {
-    const selfKey = options.getSelfKey(item, index);
-    const parentKey = options.getParentKey(item, index);
-    if (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 (isNullish(parentKey)) roots.push(item);
+		else {
+			const parent = keyMap.get(parentKey);
+			if (isUndefined(parent)) {
+				if (isFirst) freeSet.add(info);
+			} else options.appendChild(parent, info);
+		}
+	};
+	arrayEach(list, (item, index) => {
+		const selfKey = options.getSelfKey(item, index);
+		const parentKey = options.getParentKey(item, index);
+		if (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;
 }
-export {
-  deepFlat,
-  treeEach,
-  treeFind,
-  treeFrom
-};
-//# sourceMappingURL=tree.mjs.map
+//#endregion
+export { deepFlat, treeEach, treeFind, treeFrom };
+//# sourceMappingURL=tree.mjs.map

package/dist/tree.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"tree.mjs","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"],"mappings":"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"}
1	+ {"version":3,"file":"tree.mjs","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> = (\n info: TreeInfo<I>,\n) => false \| unknown;\n\n/\n 深度遍历的异步迭代器函数类型。\n \n @template I - 节点对象的类型，必须继承自 `TreeItem`。\n * @param info - 当前节点的信息。\n * @returns 如果返回 `false`，则提前终止遍历。\n /\nexport type TreeEachIteratorAsync<I extends TreeItem> = (\n info: TreeInfo<I>,\n) => 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> = (\n walker: TreeWalker<I>,\n) => 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 (\n parent !== null &&\n path2.length > 0 &&\n path2[path2.length - 1] !== parent\n ) {\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>(\n list: I[],\n options: TreeFromOptions<I>,\n): 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":";;;;;;;;;;;;;;;;;;;;;;;;AAgIA,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,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,OACE,WAAW,QACX,MAAM,SAAS,KACf,MAAM,MAAM,SAAS,OAAO,QAE5B,MAAM,KAAK;EAGb,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,SACd,MACA,SACyB;CACzB,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,UAAU,UAAU,EACtB,MAAM,KAAK,KAAK;OAGb;GACH,MAAM,SAAS,OAAO,IAAI,UAAU;GAGpC,IAAI,YAAY,OAAO;QAEjB,SAAS,QAAQ,IAAI,KAAK;UAI9B,QAAQ,YAAY,QAAQ,KAAK;;;CAMvC,UAAU,OAAO,MAAM,UAAU;EAC/B,MAAM,UAAU,QAAQ,WAAW,MAAM,MAAM;EAC/C,MAAM,YAAY,QAAQ,aAAa,MAAM,MAAM;EAEnD,IAAI,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"}

package/dist/try/curry.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-export type Callback<T = void> = (err: null | undefined | void | Error, res: T) => unknown;
+export type Callback<T = void> = (err: null | undefined | undefined | Error, res: T) => unknown;
 export type CallbackFunction0<T = void> = (callback: Callback<T>) => unknown;
 export type CallbackFunction1<A, T = void> = (a: A, callback: Callback<T>) => unknown;
 export type CallbackFunction2<A, B, T = void> = (a: A, b: B, callback: Callback<T>) => unknown;

package/dist/try.cjs CHANGED Viewed

@@ -1,51 +1,50 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const type = require("./type.cjs");
-const error = require("./error.cjs");
+const require_type = require("./type.cjs");
+const require_error = require("./error.cjs");
+//#region src/try/curry.ts
 function callbackCurry(cf, ...args) {
-  return function callbackCurried(callback) {
-    cf.apply(this, [...args, callback]);
-  };
+	return function callbackCurried(callback) {
+		cf.apply(this, [...args, callback]);
+	};
 }
+//#endregion
+//#region src/try/callback.ts
 function tryCallback(cf, ...args) {
-  return new Promise((resolve) => {
-    callbackCurry.apply(this, [cf, ...args])((err, res) => {
-      if (err) {
-        resolve([error.errorNormalize(err), void 0]);
-      } else {
-        resolve([void 0, res]);
-      }
-    });
-  });
+	return new Promise((resolve) => {
+		callbackCurry.apply(this, [cf, ...args])((err, res) => {
+			if (err) resolve([require_error.errorNormalize(err), void 0]);
+			else resolve([void 0, res]);
+		});
+	});
 }
+//#endregion
+//#region src/try/function.ts
 function trySync(syncFn) {
-  try {
-    return [void 0, syncFn()];
-  } catch (err) {
-    return [error.errorNormalize(err), void 0];
-  }
+	try {
+		return [void 0, syncFn()];
+	} catch (err) {
+		return [require_error.errorNormalize(err), void 0];
+	}
 }
 function tryAsync(asyncFn) {
-  return asyncFn().then(
-    (res) => [void 0, res],
-    (err) => [error.errorNormalize(err), void 0]
-  );
+	return asyncFn().then((res) => [void 0, res], (err) => [require_error.errorNormalize(err), void 0]);
 }
+//#endregion
+//#region src/try/promise.ts
 function tryPromise(promise) {
-  return promise.then(
-    (res) => [void 0, res],
-    (err) => [error.errorNormalize(err), void 0]
-  );
+	return promise.then((res) => [void 0, res], (err) => [require_error.errorNormalize(err), void 0]);
 }
+//#endregion
+//#region src/try/main.ts
 function tryFlatten(flattenAble) {
-  if ("then" in flattenAble) {
-    return tryPromise(flattenAble);
-  }
-  if (flattenAble.length === 0) {
-    if (type.isAsyncFunction(flattenAble)) return tryAsync(flattenAble);
-    return trySync(flattenAble);
-  }
-  return tryCallback(flattenAble);
+	if ("then" in flattenAble) return tryPromise(flattenAble);
+	if (flattenAble.length === 0) {
+		if (require_type.isAsyncFunction(flattenAble)) return tryAsync(flattenAble);
+		return trySync(flattenAble);
+	}
+	return tryCallback(flattenAble);
 }
+//#endregion
 exports.tryFlatten = tryFlatten;
-//# sourceMappingURL=try.cjs.map
+//# sourceMappingURL=try.cjs.map

package/dist/try.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"try.cjs","sources":["../src/try/curry.ts","../src/try/callback.ts","../src/try/function.ts","../src/try/promise.ts","../src/try/main.ts"],"sourcesContent":["// ~~biome-ignore lint/suspicious/noConfusingVoidType: <explanation>\nexport~~ type Callback<T = void> = (err: null \| undefined \| ~~void~~ \| Error, res: T) => unknown;\n\nexport type CallbackFunction0<T = void> = (callback: Callback<T>) => unknown;\nexport type CallbackFunction1<A, T = void> = (a: A, callback: Callback<T>) => unknown;\nexport type CallbackFunction2<A, B, T = void> = (a: A, b: B, callback: Callback<T>) => unknown;\nexport type CallbackFunction3<A, B, C, T = void> = (a: A, b: B, c: C, callback: Callback<T>) => unknown;\nexport type CallbackFunction4<A, B, C, D, T = void> = (a: A, b: B, c: C, d: D, callback: Callback<T>) => unknown;\nexport type CallbackFunction5<A, B, C, D, E, T = void> = (\n a: A,\n b: B,\n c: C,\n d: D,\n e: E,\n callback: Callback<T>,\n) => unknown;\nexport type CallbackFunction6<A, B, C, D, E, F, T = void> = (\n a: A,\n b: B,\n c: C,\n d: D,\n e: E,\n f: F,\n callback: Callback<T>,\n) => unknown;\n\nexport type CallbackCurried<T> = (callback: Callback<T>) => unknown;\n\nexport function callbackCurry<T = void>(cf: CallbackFunction0<T>): CallbackCurried<T>;\nexport function callbackCurry<A, T = void>(cf: CallbackFunction1<A, T>, a: A): CallbackCurried<T>;\nexport function callbackCurry<A, B, T = void>(cf: CallbackFunction2<A, B, T>, a: A, b: B): CallbackCurried<T>;\nexport function callbackCurry<A, B, C, T = void>(\n cf: CallbackFunction3<A, B, C, T>,\n a: A,\n b: B,\n c: C,\n): CallbackCurried<T>;\nexport function callbackCurry<A, B, C, D, T = void>(\n cf: CallbackFunction4<A, B, C, D, T>,\n a: A,\n b: B,\n c: C,\n d: D,\n): CallbackCurried<T>;\nexport function callbackCurry<A, B, C, D, E, T = void>(\n cf: CallbackFunction5<A, B, C, D, E, T>,\n a: A,\n b: B,\n c: C,\n d: D,\n e: E,\n): CallbackCurried<T>;\nexport function callbackCurry<A, B, C, D, E, F, T = void>(\n cf: CallbackFunction6<A, B, C, D, E, F, T>,\n a: A,\n b: B,\n c: C,\n d: D,\n e: E,\n f: F,\n): CallbackCurried<T>;\nexport function callbackCurry(cf: unknown, ...args: unknown[]): CallbackCurried<unknown> {\n return function callbackCurried(callback: Callback<unknown>) {\n // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n // @ts-~~ignore~~\n cf.apply(this, [...args, callback]);\n };\n}\n","import { errorNormalize } from '@/error';\nimport type {\n CallbackFunction0,\n CallbackFunction1,\n CallbackFunction2,\n CallbackFunction3,\n CallbackFunction4,\n CallbackFunction5,\n CallbackFunction6,\n} from './curry';\nimport { callbackCurry } from './curry';\nimport type { FlattenReturn } from './types';\n\nexport function tryCallback(cf: CallbackFunction0): Promise<FlattenReturn>;\nexport function tryCallback<T = void>(cf: CallbackFunction0<T>): Promise<FlattenReturn<T>>;\nexport function tryCallback<A, T = void>(cf: CallbackFunction1<A, T>, a: A): Promise<FlattenReturn<T>>;\nexport function tryCallback<A, B, T = void>(cf: CallbackFunction2<A, B, T>, a: A, b: B): Promise<FlattenReturn<T>>;\nexport function tryCallback<A, B, C, T = void>(\n cf: CallbackFunction3<A, B, C, T>,\n a: A,\n b: B,\n c: C,\n): Promise<FlattenReturn<T>>;\nexport function tryCallback<A, B, C, D, T = void>(\n cf: CallbackFunction4<A, B, C, D>,\n a: A,\n b: B,\n c: C,\n d: D,\n): Promise<FlattenReturn<T>>;\nexport function tryCallback<A, B, C, D, E, T = void>(\n cf: CallbackFunction5<A, B, C, D, E, T>,\n a: A,\n b: B,\n c: C,\n d: D,\n e: E,\n): Promise<FlattenReturn<T>>;\nexport function tryCallback<A, B, C, D, E, F, T = void>(\n cf: CallbackFunction6<A, B, C, D, E, F, T>,\n a: A,\n b: B,\n c: C,\n d: D,\n e: E,\n f: F,\n): Promise<FlattenReturn<T>>;\nexport function tryCallback(cf: unknown, ...args: unknown[]): Promise<FlattenReturn<unknown>> {\n return new Promise((resolve) => {\n // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n // @ts-~~ignore~~\n callbackCurry.apply(this, [cf, ...args])((err, res) => {\n if (err) {\n resolve([errorNormalize(err), undefined] as const);\n } else {\n resolve([undefined, res] as const);\n }\n });\n });\n}\n","import { errorNormalize } from '@/error';\nimport type { FlattenReturn } from './types';\n\nexport type SyncFunction<T> = () => T;\n\nexport function trySync<T>(syncFn: SyncFunction<T>): FlattenReturn<T> {\n try {\n return [undefined, syncFn()] as const;\n } catch (err) {\n return [errorNormalize(err), undefined] as const;\n }\n}\n\nexport type AsyncFunction<T> = () => Promise<T>;\n\nexport function tryAsync<T>(asyncFn: AsyncFunction<T>): Promise<FlattenReturn<T>> {\n return asyncFn().then(\n (res) => [undefined, res] as const,\n (err) => [errorNormalize(err), undefined] as const,\n );\n}\n","import { errorNormalize } from '@/error';\nimport type { FlattenReturn } from './types';\n\nexport function tryPromise<T>(promise: PromiseLike<T>): PromiseLike<FlattenReturn<T>> {\n return promise.then(\n (res) => [undefined, res] as const,\n (err) => [errorNormalize(err), undefined] as const,\n );\n}\n","import { isAsyncFunction } from '@/type';\nimport { tryCallback } from './callback';\nimport type { CallbackFunction0 } from './curry';\nimport { type AsyncFunction, type SyncFunction, tryAsync, trySync } from './function';\nimport { tryPromise } from './promise';\nimport type { FlattenReturn } from './types';\n\nexport type FlattenAble<T> = SyncFunction<T> \| AsyncFunction<T> \| CallbackFunction0<T> \| PromiseLike<T>;\n\n// 注意顺序 AsyncFunction > SyncFunction > CallbackFunction0 > PromiseLike\n// 需要先匹配 AsyncFunction，否则会把入参当做同步函数\nexport function tryFlatten<T>(flattenAble: AsyncFunction<T>): Promise<FlattenReturn<T>>;\nexport function tryFlatten<T>(flattenAble: SyncFunction<T>): FlattenReturn<T>;\nexport function tryFlatten<T>(flattenAble: CallbackFunction0<T> \| PromiseLike<T>): Promise<FlattenReturn<T>>;\nexport function tryFlatten<T>(flattenAble: FlattenAble<T>): unknown {\n if ('then' in flattenAble) {\n return tryPromise<T>(flattenAble);\n }\n\n // SyncFunction \| AsyncFunction\n if (flattenAble.length === 0) {\n if (isAsyncFunction(flattenAble)) return tryAsync<T>(flattenAble as AsyncFunction<T>);\n return trySync<T>(flattenAble as SyncFunction<T>);\n }\n\n return tryCallback<T>(flattenAble);\n}\n"],"~~names":["errorNormalize","isAsyncFunction"],"~~mappings":";;;;~~AA6DgB~~,~~SAAA~~,~~cAAc~~,~~OAAgB~~,~~MAA2C~~;~~AAChF~~,~~SAAA~~,SAAS,gBAAgB,UAA6B;~~AAG3D~~,~~OAAG~~,MAAM,MAAM,CAAC,GAAG,MAAM,~~QAAQ~~,CAAC~~;AAAA~~,~~EACpC;AACF;ACpBgB~~,~~SAAA~~,~~YAAY~~,~~OAAgB~~,~~MAAkD~~;~~AACrF~~,~~SAAA~~,IAAI,~~QAAQ~~,~~CAAC,~~YAAY;~~AAGhB~~,~~kBAAA~~,MAAM,MAAM,CAAC,IAAI,GAAG,~~IAAI~~,CAAC,EAAE,~~CAAC,~~KAAK,QAAQ;~~AACrD~~,~~UAAI~~,~~KAAK;AACP~~,~~gBAAQ~~,~~CAACA~~,~~MAAA~~,eAAe,~~GAAG~~,~~GAAG~~,~~MAAS~~,CAAU;~~AAAA~~,~~MAAA~~,~~OAC5C;AACG~~,~~gBAAA~~,~~CAAC~~,~~QAAW~~,~~GAAG,~~CAAU;~~AAAA,MAAA~~;~~AAAA~~,~~IACnC~~,~~CACD;AAAA,EAAA,CACF;AACH;ACtDO,SAAS,~~QAAW,QAA2C;~~AAChE~~,~~MAAA~~;~~AACK~~,~~WAAA~~,CAAC,~~QAAW~~,QAAQ;~~AAAA~~,~~WACpB,~~KAAK;~~AACZ~~,~~WAAO~~,~~CAACA~~,~~MAAA~~,eAAe,~~GAAG~~,~~GAAG~~,~~MAAS;AAAA~~,~~EAAA;AAE1C;AAIO~~,~~SAAS~~,~~SAAY~~,~~SAAsD~~;~~AAChF~~,~~SAAO~~,~~QAAU~~,~~EAAA;AAAA~~,~~IACf~~,~~CAAC,~~QAAQ,CAAC,~~QAAW~~,~~GAAG;AAAA~~,~~IACxB~~,~~CAAC~~,QAAQ,~~CAACA~~,~~qBAAe~~,~~GAAG~~,~~GAAG~~,~~MAAS;AAAA~~,~~EAC1C;AACF;ACjBO~~,~~SAAS~~,~~WAAc~~,~~SAAwD~~;~~AACpF~~,~~SAAO~~,QAAQ~~;AAAA~~,~~IACb~~,~~CAAC,~~QAAQ,CAAC,~~QAAW~~,~~GAAG;AAAA~~,~~IACxB~~,~~CAAC~~,QAAQ,~~CAACA~~,~~qBAAe~~,~~GAAG~~,~~GAAG~~,~~MAAS;AAAA~~,~~EAC1C;AACF;ACMO~~,~~SAAS~~,WAAc,aAAsC;~~AAClE~~,~~MAAI~~,UAAU,~~aAAa;AACzB~~,~~WAAO~~,WAAc,~~WAAW~~;~~AAAA~~,~~EAAA;AAI9B~~,~~MAAA,~~YAAY,WAAW,GAAG;~~AAC5B~~,~~QAAIC~~,~~KAAgB~~,~~gBAAA~~,~~WAAW~~,~~EAAG~~,~~QAAO~~,SAAY,~~WAA+B~~;~~AACpF~~,~~WAAO~~,QAAW,~~WAA8B;AAAA~~,~~EAAA;AAGlD~~,~~SAAO,~~YAAe,~~WAAW;AACnC;;~~"}
1	+ {"version":3,"file":"try.cjs","names":[],"sources":["../src/try/curry.ts","../src/try/callback.ts","../src/try/function.ts","../src/try/promise.ts","../src/try/main.ts"],"sourcesContent":["export type Callback<T = void> = (\n err: null \| undefined \| undefined \| Error,\n res: T,\n) => unknown;\n\nexport type CallbackFunction0<T = void> = (callback: Callback<T>) => unknown;\nexport type CallbackFunction1<A, T = void> = (\n a: A,\n callback: Callback<T>,\n) => unknown;\nexport type CallbackFunction2<A, B, T = void> = (\n a: A,\n b: B,\n callback: Callback<T>,\n) => unknown;\nexport type CallbackFunction3<A, B, C, T = void> = (\n a: A,\n b: B,\n c: C,\n callback: Callback<T>,\n) => unknown;\nexport type CallbackFunction4<A, B, C, D, T = void> = (\n a: A,\n b: B,\n c: C,\n d: D,\n callback: Callback<T>,\n) => unknown;\nexport type CallbackFunction5<A, B, C, D, E, T = void> = (\n a: A,\n b: B,\n c: C,\n d: D,\n e: E,\n callback: Callback<T>,\n) => unknown;\nexport type CallbackFunction6<A, B, C, D, E, F, T = void> = (\n a: A,\n b: B,\n c: C,\n d: D,\n e: E,\n f: F,\n callback: Callback<T>,\n) => unknown;\n\nexport type CallbackCurried<T> = (callback: Callback<T>) => unknown;\n\nexport function callbackCurry<T = void>(\n cf: CallbackFunction0<T>,\n): CallbackCurried<T>;\nexport function callbackCurry<A, T = void>(\n cf: CallbackFunction1<A, T>,\n a: A,\n): CallbackCurried<T>;\nexport function callbackCurry<A, B, T = void>(\n cf: CallbackFunction2<A, B, T>,\n a: A,\n b: B,\n): CallbackCurried<T>;\nexport function callbackCurry<A, B, C, T = void>(\n cf: CallbackFunction3<A, B, C, T>,\n a: A,\n b: B,\n c: C,\n): CallbackCurried<T>;\nexport function callbackCurry<A, B, C, D, T = void>(\n cf: CallbackFunction4<A, B, C, D, T>,\n a: A,\n b: B,\n c: C,\n d: D,\n): CallbackCurried<T>;\nexport function callbackCurry<A, B, C, D, E, T = void>(\n cf: CallbackFunction5<A, B, C, D, E, T>,\n a: A,\n b: B,\n c: C,\n d: D,\n e: E,\n): CallbackCurried<T>;\nexport function callbackCurry<A, B, C, D, E, F, T = void>(\n cf: CallbackFunction6<A, B, C, D, E, F, T>,\n a: A,\n b: B,\n c: C,\n d: D,\n e: E,\n f: F,\n): CallbackCurried<T>;\nexport function callbackCurry(\n cf: unknown,\n ...args: unknown[]\n): CallbackCurried<unknown> {\n return function callbackCurried(callback: Callback<unknown>) {\n // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n // @ts-expect-error\n cf.apply(this, [...args, callback]);\n };\n}\n","import { errorNormalize } from '@/error';\nimport type {\n CallbackFunction0,\n CallbackFunction1,\n CallbackFunction2,\n CallbackFunction3,\n CallbackFunction4,\n CallbackFunction5,\n CallbackFunction6,\n} from './curry';\nimport { callbackCurry } from './curry';\nimport type { FlattenReturn } from './types';\n\nexport function tryCallback(cf: CallbackFunction0): Promise<FlattenReturn>;\nexport function tryCallback<T = void>(\n cf: CallbackFunction0<T>,\n): Promise<FlattenReturn<T>>;\nexport function tryCallback<A, T = void>(\n cf: CallbackFunction1<A, T>,\n a: A,\n): Promise<FlattenReturn<T>>;\nexport function tryCallback<A, B, T = void>(\n cf: CallbackFunction2<A, B, T>,\n a: A,\n b: B,\n): Promise<FlattenReturn<T>>;\nexport function tryCallback<A, B, C, T = void>(\n cf: CallbackFunction3<A, B, C, T>,\n a: A,\n b: B,\n c: C,\n): Promise<FlattenReturn<T>>;\nexport function tryCallback<A, B, C, D, T = void>(\n cf: CallbackFunction4<A, B, C, D>,\n a: A,\n b: B,\n c: C,\n d: D,\n): Promise<FlattenReturn<T>>;\nexport function tryCallback<A, B, C, D, E, T = void>(\n cf: CallbackFunction5<A, B, C, D, E, T>,\n a: A,\n b: B,\n c: C,\n d: D,\n e: E,\n): Promise<FlattenReturn<T>>;\nexport function tryCallback<A, B, C, D, E, F, T = void>(\n cf: CallbackFunction6<A, B, C, D, E, F, T>,\n a: A,\n b: B,\n c: C,\n d: D,\n e: E,\n f: F,\n): Promise<FlattenReturn<T>>;\nexport function tryCallback(\n cf: unknown,\n ...args: unknown[]\n): Promise<FlattenReturn<unknown>> {\n return new Promise((resolve) => {\n // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n // @ts-expect-error\n callbackCurry.apply(this, [cf, ...args])((err, res) => {\n if (err) {\n resolve([errorNormalize(err), undefined] as const);\n } else {\n resolve([undefined, res] as const);\n }\n });\n });\n}\n","import { errorNormalize } from '@/error';\nimport type { FlattenReturn } from './types';\n\nexport type SyncFunction<T> = () => T;\n\nexport function trySync<T>(syncFn: SyncFunction<T>): FlattenReturn<T> {\n try {\n return [undefined, syncFn()] as const;\n } catch (err) {\n return [errorNormalize(err), undefined] as const;\n }\n}\n\nexport type AsyncFunction<T> = () => Promise<T>;\n\nexport function tryAsync<T>(\n asyncFn: AsyncFunction<T>,\n): Promise<FlattenReturn<T>> {\n return asyncFn().then(\n (res) => [undefined, res] as const,\n (err) => [errorNormalize(err), undefined] as const,\n );\n}\n","import { errorNormalize } from '@/error';\nimport type { FlattenReturn } from './types';\n\nexport function tryPromise<T>(\n promise: PromiseLike<T>,\n): PromiseLike<FlattenReturn<T>> {\n return promise.then(\n (res) => [undefined, res] as const,\n (err) => [errorNormalize(err), undefined] as const,\n );\n}\n","import { isAsyncFunction } from '@/type';\nimport { tryCallback } from './callback';\nimport type { CallbackFunction0 } from './curry';\nimport {\n type AsyncFunction,\n type SyncFunction,\n tryAsync,\n trySync,\n} from './function';\nimport { tryPromise } from './promise';\nimport type { FlattenReturn } from './types';\n\nexport type FlattenAble<T> =\n \| SyncFunction<T>\n \| AsyncFunction<T>\n \| CallbackFunction0<T>\n \| PromiseLike<T>;\n\n// 注意顺序 AsyncFunction > SyncFunction > CallbackFunction0 > PromiseLike\n// 需要先匹配 AsyncFunction，否则会把入参当做同步函数\nexport function tryFlatten<T>(\n flattenAble: AsyncFunction<T>,\n): Promise<FlattenReturn<T>>;\nexport function tryFlatten<T>(flattenAble: SyncFunction<T>): FlattenReturn<T>;\nexport function tryFlatten<T>(\n flattenAble: CallbackFunction0<T> \| PromiseLike<T>,\n): Promise<FlattenReturn<T>>;\nexport function tryFlatten<T>(flattenAble: FlattenAble<T>): unknown {\n if ('then' in flattenAble) {\n return tryPromise<T>(flattenAble);\n }\n\n // SyncFunction \| AsyncFunction\n if (flattenAble.length === 0) {\n if (isAsyncFunction(flattenAble))\n return tryAsync<T>(flattenAble as AsyncFunction<T>);\n return trySync<T>(flattenAble as SyncFunction<T>);\n }\n\n return tryCallback<T>(flattenAble);\n}\n"],"mappings":";;;;AA0FA,SAAgB,cACd,IACA,GAAG,MACuB;CAC1B,OAAO,SAAS,gBAAgB,UAA6B;EAG3D,GAAG,MAAM,MAAM,CAAC,GAAG,MAAM,SAAS,CAAC;;;;;ACzCvC,SAAgB,YACd,IACA,GAAG,MAC8B;CACjC,OAAO,IAAI,SAAS,YAAY;EAG9B,cAAc,MAAM,MAAM,CAAC,IAAI,GAAG,KAAK,CAAC,EAAE,KAAK,QAAQ;GACrD,IAAI,KACF,QAAQ,CAAC,cAAA,eAAe,IAAI,EAAE,KAAA,EAAU,CAAU;QAElD,QAAQ,CAAC,KAAA,GAAW,IAAI,CAAU;IAEpC;GACF;;;;ACjEJ,SAAgB,QAAW,QAA2C;CACpE,IAAI;EACF,OAAO,CAAC,KAAA,GAAW,QAAQ,CAAC;UACrB,KAAK;EACZ,OAAO,CAAC,cAAA,eAAe,IAAI,EAAE,KAAA,EAAU;;;AAM3C,SAAgB,SACd,SAC2B;CAC3B,OAAO,SAAS,CAAC,MACd,QAAQ,CAAC,KAAA,GAAW,IAAI,GACxB,QAAQ,CAAC,cAAA,eAAe,IAAI,EAAE,KAAA,EAAU,CAC1C;;;;AClBH,SAAgB,WACd,SAC+B;CAC/B,OAAO,QAAQ,MACZ,QAAQ,CAAC,KAAA,GAAW,IAAI,GACxB,QAAQ,CAAC,cAAA,eAAe,IAAI,EAAE,KAAA,EAAU,CAC1C;;;;ACkBH,SAAgB,WAAc,aAAsC;CAClE,IAAI,UAAU,aACZ,OAAO,WAAc,YAAY;CAInC,IAAI,YAAY,WAAW,GAAG;EAC5B,IAAI,aAAA,gBAAgB,YAAY,EAC9B,OAAO,SAAY,YAAgC;EACrD,OAAO,QAAW,YAA+B;;CAGnD,OAAO,YAAe,YAAY"}

package/dist/try.mjs CHANGED Viewed

@@ -1,51 +1,49 @@
 import { isAsyncFunction } from "./type.mjs";
 import { errorNormalize } from "./error.mjs";
+//#region src/try/curry.ts
 function callbackCurry(cf, ...args) {
-  return function callbackCurried(callback) {
-    cf.apply(this, [...args, callback]);
-  };
+	return function callbackCurried(callback) {
+		cf.apply(this, [...args, callback]);
+	};
 }
+//#endregion
+//#region src/try/callback.ts
 function tryCallback(cf, ...args) {
-  return new Promise((resolve) => {
-    callbackCurry.apply(this, [cf, ...args])((err, res) => {
-      if (err) {
-        resolve([errorNormalize(err), void 0]);
-      } else {
-        resolve([void 0, res]);
-      }
-    });
-  });
+	return new Promise((resolve) => {
+		callbackCurry.apply(this, [cf, ...args])((err, res) => {
+			if (err) resolve([errorNormalize(err), void 0]);
+			else resolve([void 0, res]);
+		});
+	});
 }
+//#endregion
+//#region src/try/function.ts
 function trySync(syncFn) {
-  try {
-    return [void 0, syncFn()];
-  } catch (err) {
-    return [errorNormalize(err), void 0];
-  }
+	try {
+		return [void 0, syncFn()];
+	} catch (err) {
+		return [errorNormalize(err), void 0];
+	}
 }
 function tryAsync(asyncFn) {
-  return asyncFn().then(
-    (res) => [void 0, res],
-    (err) => [errorNormalize(err), void 0]
-  );
+	return asyncFn().then((res) => [void 0, res], (err) => [errorNormalize(err), void 0]);
 }
+//#endregion
+//#region src/try/promise.ts
 function tryPromise(promise) {
-  return promise.then(
-    (res) => [void 0, res],
-    (err) => [errorNormalize(err), void 0]
-  );
+	return promise.then((res) => [void 0, res], (err) => [errorNormalize(err), void 0]);
 }
+//#endregion
+//#region src/try/main.ts
 function tryFlatten(flattenAble) {
-  if ("then" in flattenAble) {
-    return tryPromise(flattenAble);
-  }
-  if (flattenAble.length === 0) {
-    if (isAsyncFunction(flattenAble)) return tryAsync(flattenAble);
-    return trySync(flattenAble);
-  }
-  return tryCallback(flattenAble);
+	if ("then" in flattenAble) return tryPromise(flattenAble);
+	if (flattenAble.length === 0) {
+		if (isAsyncFunction(flattenAble)) return tryAsync(flattenAble);
+		return trySync(flattenAble);
+	}
+	return tryCallback(flattenAble);
 }
-export {
-  tryFlatten
-};
-//# sourceMappingURL=try.mjs.map
+//#endregion
+export { tryFlatten };
+//# sourceMappingURL=try.mjs.map