@pawover/kit 0.0.0-alpha.2 → 0.0.0-alpha.21

package/dist/index.js

@@ -1,2 +1,1124 @@
-export * from "./enums";
-export * from "./utils";
+//#region src/utils/typeof/types.ts
+const prototypeStrings = {
+	string: "[object String]",
+	number: "[object Number]",
+	boolean: "[object Boolean]",
+	object: "[object Object]",
+	array: "[object Array]",
+	bigInt: "[object BigInt]",
+	symbol: "[object Symbol]",
+	function: "[object Function]",
+	generatorFunction: "[object GeneratorFunction]",
+	asyncFunction: "[object AsyncFunction]",
+	promise: "[object Promise]",
+	null: "[object Null]",
+	undefined: "[object Undefined]",
+	date: "[object Date]",
+	regExp: "[object RegExp]",
+	error: "[object Error]",
+	file: "[object File]",
+	map: "[object Map]",
+	weakMap: "[object WeakMap]",
+	set: "[object Set]",
+	weakSet: "[object WeakSet]",
+	window: "[object Window]",
+	webSocket: "[object WebSocket]",
+	URLSearchParams: "[object URLSearchParams]"
+};
+function resolvePrototypeString(value) {
+	return Object.prototype.toString.call(value);
+}
+
+//#endregion
+//#region src/utils/typeof/isArray.ts
+function isArray(value) {
+	return resolvePrototypeString(value) === prototypeStrings.array;
+}
+
+//#endregion
+//#region src/utils/typeof/isAsyncFunction.ts
+function isAsyncFunction(value) {
+	return resolvePrototypeString(value) === prototypeStrings.asyncFunction;
+}
+
+//#endregion
+//#region src/utils/typeof/isBigInt.ts
+function isBigInt(value) {
+	return resolvePrototypeString(value) === prototypeStrings.bigInt;
+}
+
+//#endregion
+//#region src/utils/typeof/isBoolean.ts
+function isBoolean(value) {
+	return resolvePrototypeString(value) === prototypeStrings.boolean;
+}
+
+//#endregion
+//#region src/utils/typeof/isClass.ts
+function isClass(value) {
+	return resolvePrototypeString(value).startsWith("class ");
+}
+
+//#endregion
+//#region src/utils/typeof/isDate.ts
+function isDate(value) {
+	return resolvePrototypeString(value) === prototypeStrings.date;
+}
+
+//#endregion
+//#region src/utils/typeof/isEqual.ts
+/**
+* 判断给定的值是否相等
+* @reference https://github.com/radashi-org/radashi/blob/main/src/typed/isEqual.ts
+*
+* @param {T} x
+* @param {T} y
+*/
+function isEqual(x, y) {
+	if (Object.is(x, y)) return true;
+	if (x instanceof Date && y instanceof Date) return x.getTime() === y.getTime();
+	if (x instanceof RegExp && y instanceof RegExp) return x.toString() === y.toString();
+	if (typeof x !== "object" || x === null || typeof y !== "object" || y === null) return false;
+	const keysX = Reflect.ownKeys(x);
+	const keysY = Reflect.ownKeys(y);
+	if (keysX.length !== keysY.length) return false;
+	for (const key of keysX) {
+		if (!Reflect.has(y, key)) return false;
+		if (!isEqual(x[key], y[key])) return false;
+	}
+	return true;
+}
+
+//#endregion
+//#region src/utils/typeof/isError.ts
+function isError(value) {
+	return resolvePrototypeString(value) === prototypeStrings.error;
+}
+
+//#endregion
+//#region src/utils/typeof/isFile.ts
+function isFile(value) {
+	return resolvePrototypeString(value) === prototypeStrings.file;
+}
+
+//#endregion
+//#region src/utils/typeof/isFunction.ts
+function isFunction(value) {
+	return [
+		prototypeStrings.function,
+		prototypeStrings.generatorFunction,
+		prototypeStrings.asyncFunction
+	].includes(resolvePrototypeString(value));
+}
+
+//#endregion
+//#region src/utils/typeof/isGeneratorFunction.ts
+function isGeneratorFunction(value) {
+	return resolvePrototypeString(value) === prototypeStrings.generatorFunction;
+}
+
+//#endregion
+//#region src/utils/typeof/isInteger.ts
+function isInteger(value) {
+	return Number.isInteger(value);
+}
+
+//#endregion
+//#region src/utils/typeof/isObject.ts
+function isObject(value) {
+	return resolvePrototypeString(value) === prototypeStrings.object;
+}
+
+//#endregion
+//#region src/utils/typeof/isIterable.ts
+function isIterable(value) {
+	return isObject(value) && Symbol.iterator in value;
+}
+
+//#endregion
+//#region src/utils/typeof/isMap.ts
+function isMap(value) {
+	return resolvePrototypeString(value) === prototypeStrings.map;
+}
+
+//#endregion
+//#region src/utils/typeof/isNull.ts
+function isNull(value) {
+	return resolvePrototypeString(value) === prototypeStrings.null;
+}
+
+//#endregion
+//#region src/utils/typeof/isNumber.ts
+function isNumber(value) {
+	return resolvePrototypeString(value) === prototypeStrings.number;
+}
+
+//#endregion
+//#region src/utils/typeof/isPromise.ts
+function isPromise(value) {
+	return resolvePrototypeString(value) === prototypeStrings.promise;
+}
+
+//#endregion
+//#region src/utils/typeof/isPromiseLike.ts
+function isPromiseLike(value) {
+	return isPromise(value) || isObject(value) && isFunction(value["then"]);
+}
+
+//#endregion
+//#region src/utils/typeof/isRegExp.ts
+function isRegExp(value) {
+	return resolvePrototypeString(value) === prototypeStrings.regExp;
+}
+
+//#endregion
+//#region src/utils/typeof/isSet.ts
+function isSet(value) {
+	return resolvePrototypeString(value) === prototypeStrings.set;
+}
+
+//#endregion
+//#region src/utils/typeof/isString.ts
+function isString(value) {
+	return resolvePrototypeString(value) === prototypeStrings.string;
+}
+
+//#endregion
+//#region src/utils/typeof/isSymbol.ts
+function isSymbol(value) {
+	return resolvePrototypeString(value) === prototypeStrings.symbol;
+}
+
+//#endregion
+//#region src/utils/typeof/isUndefined.ts
+function isUndefined(value) {
+	return resolvePrototypeString(value) === prototypeStrings.undefined;
+}
+
+//#endregion
+//#region src/utils/typeof/isURLSearchParams.ts
+function isURLSearchParams(value) {
+	return resolvePrototypeString(value) === prototypeStrings.URLSearchParams;
+}
+
+//#endregion
+//#region src/utils/typeof/isWeakMap.ts
+function isWeakMap(value) {
+	return resolvePrototypeString(value) === prototypeStrings.weakMap;
+}
+
+//#endregion
+//#region src/utils/typeof/isWeakSet.ts
+function isWeakSet(value) {
+	return resolvePrototypeString(value) === prototypeStrings.weakSet;
+}
+
+//#endregion
+//#region src/utils/typeof/isWebSocket.ts
+function isWebSocket(value) {
+	return resolvePrototypeString(value) === prototypeStrings.webSocket;
+}
+
+//#endregion
+//#region src/utils/typeof/isWindow.ts
+function isWindow(value) {
+	return resolvePrototypeString(value) === prototypeStrings.window;
+}
+
+//#endregion
+//#region src/utils/array/arrayCast.ts
+/**
+* 构造数组
+* @param candidate 待构造项
+* @param checkEmpty 是否检查 `undefined` 和 `null`
+*/
+function arrayCast(candidate, checkEmpty = true) {
+	if (checkEmpty && (isUndefined(candidate) || isNull(candidate))) return [];
+	return isArray(candidate) ? [...candidate] : [candidate];
+}
+
+//#endregion
+//#region src/utils/array/arrayCompete.ts
+/**
+* 数组竞争
+* - 返回在匹配函数的比较条件中获胜的最终项目，适用于更复杂的最小值/最大值计算
+*
+* @param initialList 数组
+* @param match 匹配函数
+*/
+function arrayCompete(initialList, match) {
+	if (!isArray(initialList) || initialList.length === 0 || !isFunction(match)) return null;
+	return initialList.reduce(match);
+}
+
+//#endregion
+//#region src/utils/array/arrayCounting.ts
+/**
+* 统计数组的项目出现次数
+* - 通过给定的标识符匹配函数，返回一个对象，其中键是回调函数返回的 key 值，每个值是一个整数，表示该 key 出现的次数
+*
+* @param initialList 初始数组
+* @param match 匹配函数
+*/
+function arrayCounting(initialList, match) {
+	if (!isArray(initialList) || !isFunction(match)) return {};
+	return initialList.reduce((prev, curr) => {
+		const id = match(curr).toString();
+		prev[id] = (prev[id] ?? 0) + 1;
+		return prev;
+	}, {});
+}
+
+//#endregion
+//#region src/utils/array/arrayDifference.ts
+/**
+* 求数组差集
+*
+* @param initialList 初始数组
+* @param diffList 对比数组
+* @param match 匹配函数
+*/
+function arrayDifference(initialList, diffList, match) {
+	if (!isArray(initialList) && !isArray(diffList)) return [];
+	if (!isArray(initialList) || !initialList.length) return [...diffList];
+	if (!isArray(diffList) || !diffList.length) return [...initialList];
+	if (!isFunction(match)) {
+		const arraySet = new Set(diffList);
+		return Array.from(new Set(initialList.filter((item) => !arraySet.has(item))));
+	}
+	const map = /* @__PURE__ */ new Map();
+	diffList.forEach((item) => {
+		map.set(match(item), true);
+	});
+	return initialList.filter((a) => !map.get(match(a)));
+}
+
+//#endregion
+//#region src/utils/array/arrayFirst.ts
+/**
+* 获取数组第一项
+*
+* @param initialList 初始数组
+* @param saveValue 安全值
+*/
+function arrayFirst(initialList, saveValue) {
+	if (!isArray(initialList) || initialList.length === 0) return saveValue;
+	return initialList[0];
+}
+
+//#endregion
+//#region src/utils/array/arrayFork.ts
+/**
+* 数组分组过滤
+* - 给定一个数组和一个条件，返回一个由两个数组组成的元组，其中第一个数组包含所有满足条件的项，第二个数组包含所有不满足条件的项
+*
+* @param initialList 初始数组
+* @param match 条件匹配函数
+*/
+function arrayFork(initialList, match) {
+	const forked = [[], []];
+	if (isArray(initialList)) for (const item of initialList) forked[match(item) ? 0 : 1].push(item);
+	return forked;
+}
+
+//#endregion
+//#region src/utils/array/arrayIntersection.ts
+/**
+* 求数组交集
+*
+* @param initialList 初始数组
+* @param diffList 对比数组
+* @param match 匹配函数
+*/
+function arrayIntersection(initialList, diffList, match) {
+	if (!isArray(initialList) && !isArray(diffList)) return [];
+	if (!isArray(initialList) || !initialList.length) return [...diffList];
+	if (!isArray(diffList) || !diffList.length) return [...initialList];
+	if (!isFunction(match)) {
+		const arraySet = new Set(diffList);
+		return Array.from(new Set(initialList.filter((item) => arraySet.has(item))));
+	}
+	const map = /* @__PURE__ */ new Map();
+	diffList.forEach((item) => {
+		map.set(match(item), true);
+	});
+	return initialList.filter((a) => map.get(match(a)));
+}
+
+//#endregion
+//#region src/utils/array/arrayLast.ts
+/**
+* 获取数组最后一项
+*
+* @param initialList 初始数组
+* @param saveValue 安全值
+*/
+function arrayLast(initialList, saveValue) {
+	if (!isArray(initialList) || initialList.length === 0) return saveValue;
+	return initialList[initialList.length - 1];
+}
+
+//#endregion
+//#region src/utils/array/arrayMerge.ts
+/**
+* 数组合并
+* - 通过给定的标识符匹配函数，用第二个数组中的匹配项替换第一个数组中匹配项的所有内容
+*
+* @param initialList 初始数组
+* @param mergeList 待合并数组
+* @param match 匹配函数
+*/
+function arrayMerge(initialList, mergeList, match) {
+	if (!isArray(initialList)) return [];
+	if (!isArray(mergeList)) return [...initialList];
+	if (!isFunction(match)) return Array.from(new Set([...initialList, ...mergeList]));
+	const keys = /* @__PURE__ */ new Map();
+	for (const item of mergeList) keys.set(match(item), item);
+	return initialList.map((prevItem) => {
+		const key = match(prevItem);
+		return keys.has(key) ? keys.get(key) : prevItem;
+	});
+}
+
+//#endregion
+//#region src/utils/array/arrayPick.ts
+/**
+* 数组选择
+* - 一次性应用 `filter` 和 `map` 操作
+*
+* @param initialList 初始数组
+* @param filter filter 函数
+* @param mapper map 函数
+*/
+function arrayPick(initialList, filter, mapper) {
+	if (!isArray(initialList)) return [];
+	if (!isFunction(filter)) return [...initialList];
+	const hasMapper = isFunction(mapper);
+	return initialList.reduce((prev, curr, index) => {
+		if (!filter(curr, index)) return prev;
+		if (hasMapper) prev.push(mapper(curr, index));
+		else prev.push(curr);
+		return prev;
+	}, []);
+}
+
+//#endregion
+//#region src/utils/array/arrayReplace.ts
+/**
+* 数组项替换
+* - 在给定的数组中，替换符合匹配函数结果的项目。只替换第一个匹配项。始终返回原始数组的副本。
+*
+* @param initialList 初始数组
+* @param newItem 替换项
+* @param match 匹配函数
+*/
+function arrayReplace(initialList, newItem, match) {
+	if (!initialList) return [];
+	if (newItem === void 0 || !isFunction(match)) return [...initialList];
+	for (let i = 0; i < initialList.length; i++) {
+		const item = initialList[i];
+		if (item !== void 0 && match(item, i)) return [
+			...initialList.slice(0, i),
+			newItem,
+			...initialList.slice(i + 1, initialList.length)
+		];
+	}
+	return [...initialList];
+}
+
+//#endregion
+//#region src/utils/array/arraySplit.ts
+/**
+* 数组切分
+* - 将数组以指定的长度切分后，组合在高维数组中
+*
+* @param initialList 初始数组
+* @param size 分割尺寸，默认 `10`
+*/
+function arraySplit(initialList, size = 10) {
+	if (!isArray(initialList)) return [];
+	const count = Math.ceil(initialList.length / size);
+	return Array.from({ length: count }).fill(null).map((_c, i) => {
+		return initialList.slice(i * size, i * size + size);
+	});
+}
+
+//#endregion
+//#region src/utils/function/to.ts
+/**
+* @param promise
+* @param errorExt - 可以传递给err对象的其他信息
+*/
+function to(promise, errorExt) {
+	return promise.then((data) => [null, data]).catch((err) => {
+		if (errorExt) return [{
+			...err,
+			...errorExt
+		}, void 0];
+		return [err ? err : /* @__PURE__ */ new Error("defaultError"), void 0];
+	});
+}
+
+//#endregion
+//#region src/utils/object/cloneDeep.ts
+const DefaultCloningStrategy = {
+	cloneMap(input, track, clone) {
+		const output = track(/* @__PURE__ */ new Map());
+		for (const [key, value] of input) output.set(key, clone(value));
+		return output;
+	},
+	cloneSet(input, track, clone) {
+		const output = track(/* @__PURE__ */ new Set());
+		for (const value of input) output.add(clone(value));
+		return output;
+	},
+	cloneArray(input, track, clone) {
+		const output = track(new Array(input.length));
+		input.forEach((value, index) => {
+			output[index] = clone(value);
+		});
+		return output;
+	},
+	cloneObject(input, track, clone) {
+		const output = track(Object.create(Object.getPrototypeOf(input)));
+		for (const key of Reflect.ownKeys(input)) {
+			const descriptor = Object.getOwnPropertyDescriptor(input, key);
+			if ("value" in descriptor) descriptor.value = clone(descriptor.value);
+			Object.defineProperty(output, key, descriptor);
+		}
+		return output;
+	},
+	cloneOther(input, track) {
+		return track(input);
+	}
+};
+/**
+* cloneDeep
+* @reference https://github.com/radashi-org/radashi/blob/main/src/object/cloneDeep.ts
+*/
+function cloneDeep(root, customStrategy) {
+	const strategy = {
+		...DefaultCloningStrategy,
+		...customStrategy
+	};
+	const tracked = /* @__PURE__ */ new Map();
+	const track = (parent, newParent) => {
+		tracked.set(parent, newParent);
+		return newParent;
+	};
+	const clone = (value) => {
+		return value && typeof value === "object" ? tracked.get(value) ?? cloneDeep$1(value, strategy) : value;
+	};
+	const cloneDeep$1 = (parent, strategy$1) => {
+		const newParent = (isObject(parent) ? strategy$1.cloneObject : isArray(parent) ? strategy$1.cloneArray : isMap(parent) ? strategy$1.cloneMap : isSet(parent) ? strategy$1.cloneSet : strategy$1.cloneOther)(parent, track.bind(null, parent), clone);
+		if (!newParent) return cloneDeep$1(parent, DefaultCloningStrategy);
+		tracked.set(parent, newParent);
+		return newParent;
+	};
+	return cloneDeep$1(root, strategy);
+}
+
+//#endregion
+//#region src/utils/object/objectKeys.ts
+/**
+* 返回对象的可枚举属性和方法的名称
+* - `Object.keys` 始终返回 `string[]` 类型，此函数可以返回具体类型
+*
+* @param obj 对象
+*/
+function objectKeys(obj) {
+	return Object.keys(obj);
+}
+
+//#endregion
+//#region src/utils/object/enumTypeCheck.ts
+function enumTypeCheck(enumeration) {
+	if (!isObject(enumeration)) throw Error(`function enumKeys expected parameter is a enum, but got ${typeof enumeration}`);
+	if (!objectKeys(enumeration).length) throw Error("Enum requires at least one member");
+	return enumeration;
+}
+
+//#endregion
+//#region src/utils/object/objectEntries.ts
+/**
+* 返回对象的可枚举属性的键/值数组
+*
+* @param obj 对象
+*/
+function objectEntries(obj) {
+	return Object.entries(obj);
+}
+
+//#endregion
+//#region src/utils/object/objectValues.ts
+/**
+* 返回对象的可枚举属性的值数组
+*
+* @param obj 对象
+*/
+function objectValues(obj) {
+	return Object.values(obj);
+}
+
+//#endregion
+//#region src/utils/object/enumEntries.ts
+/**
+* 返回枚举的属性的键/值数组
+*
+* @param enumeration 枚举
+*/
+function enumEntries(enumeration) {
+	const e = enumTypeCheck(enumeration);
+	const keys = objectKeys(e);
+	const values = objectValues(e);
+	const entries = objectEntries(e);
+	if (keys.every((k) => values.some((v) => `${v}` === k))) return entries.splice(keys.length / 2, keys.length / 2);
+	return entries;
+}
+
+//#endregion
+//#region src/utils/object/enumKeys.ts
+/**
+* 获取枚举所有属性的键
+*
+* @param enumeration 枚举
+*/
+function enumKeys(enumeration) {
+	const e = enumTypeCheck(enumeration);
+	const keys = objectKeys(e);
+	const values = objectValues(e);
+	if (keys.every((k) => values.some((v) => `${v}` === k))) return keys.splice(keys.length / 2, keys.length / 2);
+	return keys;
+}
+
+//#endregion
+//#region src/utils/object/enumValues.ts
+/**
+* 获取枚举所有属性的值
+*
+* @param enumeration 枚举
+*/
+function enumValues(enumeration) {
+	const e = enumTypeCheck(enumeration);
+	const keys = objectKeys(e);
+	const values = objectValues(e);
+	if (keys.every((k) => values.some((v) => `${v}` === k))) return values.splice(keys.length / 2, keys.length / 2);
+	return values;
+}
+
+//#endregion
+//#region src/utils/object/mapEntries.ts
+function mapEntries(obj, toEntry) {
+	const defaultResult = {};
+	if (!obj) return defaultResult;
+	return objectEntries(obj).reduce((acc, [key, value]) => {
+		const [newKey, newValue] = toEntry(key, value);
+		acc[newKey] = newValue;
+		return acc;
+	}, defaultResult);
+}
+
+//#endregion
+//#region node_modules/.pnpm/radashi@12.7.1/node_modules/radashi/dist/radashi.js
+function assign(initial, override) {
+	if (!initial || !override) return initial ?? override ?? {};
+	const proto = Object.getPrototypeOf(initial);
+	const merged = proto ? { ...initial } : Object.assign(Object.create(proto), initial);
+	for (const key of Object.keys(override)) merged[key] = isPlainObject(initial[key]) && isPlainObject(override[key]) ? assign(initial[key], override[key]) : override[key];
+	return merged;
+}
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null || Object.getPrototypeOf(prototype) === null;
+}
+
+//#endregion
+//#region src/utils/object/objectAssign.ts
+const objectAssign = assign;
+
+//#endregion
+//#region src/utils/object/objectPick.ts
+function objectPick(obj, keys) {
+	const result = {};
+	if (!isObject(obj)) return result;
+	if (!isArray(keys)) return obj;
+	return keys.reduce((acc, curr) => {
+		if (curr in obj) acc[curr] = obj[curr];
+		return acc;
+	}, result);
+}
+
+//#endregion
+//#region src/utils/object/objectSwitch.ts
+/**
+* 对象反转
+* - 返回交换了对象的可枚举属性的值/键对象
+*
+* @param obj 对象
+*/
+function objectSwitch(obj) {
+	const result = {};
+	if (!isObject(obj)) return result;
+	for (const [k, v] of objectEntries(obj)) result[v] = k;
+	return result;
+}
+
+//#endregion
+//#region src/utils/string/stringInitialCase.ts
+const m1 = /\S+/g;
+const m2 = /[^a-zA-Z\u00C0-\u017F]/;
+/**
+* 首字母大小写
+*/
+function stringInitialCase(value, type) {
+	if (!isString(value) || value.length === 0) return value;
+	return value.replace(m1, (word) => {
+		if (m2.test(word)) return word;
+		if (word === word.toLocaleUpperCase()) return word;
+		if (type === "lower" && word[0]) return word[0].toLocaleLowerCase() + word.slice(1);
+		if (type === "upper" && word[0]) return word[0].toLocaleUpperCase() + word.slice(1);
+		return word;
+	});
+}
+
+//#endregion
+//#region src/utils/string/stringReplace.ts
+function stringReplace(input, search, replacement) {
+	return input.replace(search, replacement);
+}
+
+//#endregion
+//#region src/utils/string/stringToJson.ts
+function stringToJson(data, safeValue) {
+	if (isString(data) && data) try {
+		return JSON.parse(data);
+	} catch (error) {
+		return safeValue;
+	}
+	else return safeValue;
+}
+
+//#endregion
+//#region src/utils/string/stringToValues.ts
+function stringToValues(data, valueType = "number", splitSymbol = ",") {
+	if (isString(data) && data) try {
+		const values = data.split(splitSymbol);
+		if (valueType === "number") return values.map((d) => Number(d));
+		return values;
+	} catch (error) {
+		return [];
+	}
+	else return [];
+}
+
+//#endregion
+//#region src/utils/tree/types.ts
+function getFinalChildrenKey(tree, meta, options) {
+	if (isFunction(options.getChildrenKey)) {
+		const dynamicChildrenKey = options.getChildrenKey(tree, meta);
+		if (dynamicChildrenKey && dynamicChildrenKey !== null) return dynamicChildrenKey;
+	}
+	return options.childrenKey;
+}
+
+//#endregion
+//#region src/utils/tree/treeFilter.ts
+function preImpl$3(row, callback, options) {
+	if (!callback(row, options)) return;
+	const finalChildrenKey = getFinalChildrenKey(row, options, options);
+	const children = row[finalChildrenKey];
+	let newChildren;
+	if (isArray(children)) {
+		const nextLevelOptions = {
+			...options,
+			parents: [...options.parents, row],
+			depth: options.depth + 1
+		};
+		newChildren = children.map((c) => preImpl$3(c, callback, nextLevelOptions)).filter((c) => !!c);
+	}
+	return {
+		...row,
+		[finalChildrenKey]: newChildren
+	};
+}
+function postImpl$3(row, callback, options) {
+	const finalChildrenKey = getFinalChildrenKey(row, options, options);
+	const children = row[finalChildrenKey];
+	let newChildren;
+	if (isArray(children)) {
+		const nextLevelOptions = {
+			...options,
+			parents: [...options.parents, row],
+			depth: options.depth + 1
+		};
+		newChildren = children.map((c) => preImpl$3(c, callback, nextLevelOptions)).filter((c) => !!c);
+	}
+	if (!callback(row, options)) return;
+	return {
+		...row,
+		[finalChildrenKey]: newChildren
+	};
+}
+function breadthImpl$3(row, callback, options) {
+	const queue = [{
+		queueRow: row,
+		queueOptions: options
+	}];
+	const resultCache = /* @__PURE__ */ new WeakMap();
+	const newNodeCache = /* @__PURE__ */ new WeakMap();
+	const childrenKeyCache = /* @__PURE__ */ new WeakMap();
+	let result;
+	const runQueue = () => {
+		if (queue.length === 0) return result;
+		const { queueRow, queueOptions } = queue.shift();
+		const finalChildrenKey = getFinalChildrenKey(queueRow, queueOptions, queueOptions);
+		const children = queueRow[finalChildrenKey];
+		if (isArray(children)) {
+			const nextLevelOptions = {
+				...queueOptions,
+				parents: [...queueOptions.parents, queueRow],
+				depth: queueOptions.depth + 1
+			};
+			const subQueueItems = children.map((queueRow$1) => ({
+				queueRow: queueRow$1,
+				queueOptions: nextLevelOptions
+			}));
+			queue.push(...subQueueItems);
+		}
+		const parent = arrayLast(queueOptions.parents);
+		const isTopNode = queueOptions.depth === 0;
+		const parentResult = parent && resultCache.get(parent);
+		if (!isTopNode && !parentResult) return runQueue();
+		const callbackResult = callback(queueRow, queueOptions);
+		if (isTopNode && !callbackResult) return;
+		const newNode = {
+			...queueRow,
+			[finalChildrenKey]: void 0
+		};
+		if (isTopNode) result = newNode;
+		resultCache.set(queueRow, callbackResult);
+		newNodeCache.set(queueRow, newNode);
+		childrenKeyCache.set(queueRow, finalChildrenKey);
+		if (callbackResult && parent) {
+			const parentNewNode = newNodeCache.get(parent);
+			const parentChildrenKey = childrenKeyCache.get(parent);
+			if (parentNewNode && parentChildrenKey) {
+				if (!parentNewNode[parentChildrenKey]) parentNewNode[parentChildrenKey] = [];
+				parentNewNode[parentChildrenKey].push(newNode);
+			}
+		}
+		return runQueue();
+	};
+	return runQueue();
+}
+const strategies$3 = {
+	pre: preImpl$3,
+	post: postImpl$3,
+	breadth: breadthImpl$3
+};
+function treeFilter(tree, callback, options = {}) {
+	const { childrenKey = "children", strategy = "pre", getChildrenKey } = options;
+	const traversalMethod = strategies$3[strategy];
+	const innerOptions = {
+		childrenKey,
+		depth: 0,
+		parents: [],
+		getChildrenKey
+	};
+	return isArray(tree) ? tree.map((row) => traversalMethod(row, callback, innerOptions)).filter((t) => !!t) : traversalMethod(tree, callback, innerOptions) || [];
+}
+
+//#endregion
+//#region src/utils/tree/treeFind.ts
+const strategies$2 = {
+	pre: preImpl$2,
+	post: postImpl$2,
+	breadth: breadthImpl$2
+};
+function preImpl$2(row, callback, options) {
+	if (callback(row, options)) return row;
+	const children = row[getFinalChildrenKey(row, options, options)];
+	if (isArray(children)) for (const child of children) {
+		const result = preImpl$2(child, callback, {
+			...options,
+			parents: [...options.parents, row],
+			depth: options.depth + 1
+		});
+		if (result) return result;
+	}
+}
+function postImpl$2(row, callback, options) {
+	const children = row[getFinalChildrenKey(row, options, options)];
+	if (isArray(children)) for (const child of children) {
+		const result = postImpl$2(child, callback, {
+			...options,
+			parents: [...options.parents, row],
+			depth: options.depth + 1
+		});
+		if (result) return result;
+	}
+	if (callback(row, options)) return row;
+}
+function breadthImpl$2(row, callback, options) {
+	const queue = [{
+		queueRow: row,
+		queueOptions: options
+	}];
+	const runQueue = () => {
+		if (queue.length === 0) return;
+		const { queueRow, queueOptions } = queue.shift();
+		const children = queueRow[getFinalChildrenKey(queueRow, queueOptions, queueOptions)];
+		if (isArray(children)) {
+			const nextLevelOptions = {
+				...queueOptions,
+				parents: [...queueOptions.parents, queueRow],
+				depth: queueOptions.depth + 1
+			};
+			const subQueueItems = children.map((queueRow$1) => ({
+				queueRow: queueRow$1,
+				queueOptions: nextLevelOptions
+			}));
+			queue.push(...subQueueItems);
+		}
+		if (callback(queueRow, queueOptions)) return queueRow;
+		return runQueue();
+	};
+	return runQueue();
+}
+/**
+* 查找树节点，找到第一个返回非空值的节点
+*/
+function treeFind(tree, callback, options = {}) {
+	const { childrenKey = "children", strategy = "pre", getChildrenKey } = options;
+	const traversalMethod = strategies$2[strategy];
+	const innerOptions = {
+		childrenKey,
+		depth: 0,
+		parents: [],
+		getChildrenKey
+	};
+	if (isArray(tree)) {
+		for (const row of tree) {
+			const result = traversalMethod(row, callback, innerOptions);
+			if (result) return result;
+		}
+		return;
+	}
+	return traversalMethod(tree, callback, innerOptions);
+}
+
+//#endregion
+//#region src/utils/tree/treeForEach.ts
+const strategies$1 = {
+	pre: preImpl$1,
+	post: postImpl$1,
+	breadth: breadthImpl$1
+};
+function preImpl$1(row, callback, options) {
+	callback(row, options);
+	const children = row[getFinalChildrenKey(row, options, options)];
+	if (isArray(children)) {
+		const nextLevelOptions = {
+			...options,
+			parents: [...options.parents, row],
+			depth: options.depth + 1
+		};
+		for (const child of children) preImpl$1(child, callback, nextLevelOptions);
+	}
+}
+function postImpl$1(row, callback, options) {
+	const children = row[getFinalChildrenKey(row, options, options)];
+	if (isArray(children)) {
+		const nextLevelOptions = {
+			...options,
+			parents: [...options.parents, row],
+			depth: options.depth + 1
+		};
+		for (const child of children) postImpl$1(child, callback, nextLevelOptions);
+	}
+	callback(row, options);
+}
+function breadthImpl$1(row, callback, options) {
+	const queue = [{
+		queueRow: row,
+		queueOptions: options
+	}];
+	const runQueue = () => {
+		if (queue.length === 0) return;
+		const { queueRow, queueOptions } = queue.shift();
+		const children = queueRow[getFinalChildrenKey(queueRow, queueOptions, queueOptions)];
+		if (isArray(children)) {
+			const nextLevelOptions = {
+				...queueOptions,
+				parents: [...queueOptions.parents, queueRow],
+				depth: queueOptions.depth + 1
+			};
+			const subQueueItems = children.map((queueRow$1) => ({
+				queueRow: queueRow$1,
+				queueOptions: nextLevelOptions
+			}));
+			queue.push(...subQueueItems);
+		}
+		callback(queueRow, queueOptions);
+		runQueue();
+	};
+	runQueue();
+}
+function treeForEach(tree, callback, options = {}) {
+	const { childrenKey = "children", strategy = "pre", getChildrenKey } = options;
+	const traversalMethod = strategies$1[strategy];
+	const innerOptions = {
+		childrenKey,
+		depth: 0,
+		parents: [],
+		getChildrenKey
+	};
+	if (isArray(tree)) for (const row of tree) traversalMethod(row, callback, innerOptions);
+	else traversalMethod(tree, callback, innerOptions);
+}
+
+//#endregion
+//#region src/utils/tree/treeMap.ts
+const strategies = {
+	pre: preImpl,
+	post: postImpl,
+	breadth: breadthImpl
+};
+function preImpl(row, callback, options) {
+	const finalChildrenKey = getFinalChildrenKey(row, options, options);
+	const result = callback(row, options);
+	const children = row[finalChildrenKey];
+	let newChildren;
+	if (isArray(children)) {
+		const nextLevelOptions = {
+			...options,
+			parents: [...options.parents, row],
+			depth: options.depth + 1
+		};
+		newChildren = children.map((c) => preImpl(c, callback, nextLevelOptions));
+	}
+	return {
+		...result,
+		[finalChildrenKey]: newChildren
+	};
+}
+function postImpl(row, callback, options) {
+	const finalChildrenKey = getFinalChildrenKey(row, options, options);
+	const children = row[finalChildrenKey];
+	let newChildren;
+	if (isArray(children)) {
+		const nextLevelOptions = {
+			...options,
+			parents: [...options.parents, row],
+			depth: options.depth + 1
+		};
+		newChildren = children.map((c) => postImpl(c, callback, nextLevelOptions));
+	}
+	return {
+		...callback(row, options),
+		[finalChildrenKey]: newChildren
+	};
+}
+function breadthImpl(row, callback, options) {
+	const queue = [{
+		queueRow: row,
+		queueOptions: options
+	}];
+	const cache = /* @__PURE__ */ new WeakMap();
+	const childrenKeyCache = /* @__PURE__ */ new WeakMap();
+	let result;
+	const runQueue = () => {
+		if (queue.length === 0) return result;
+		const { queueRow, queueOptions } = queue.shift();
+		const finalChildrenKey = getFinalChildrenKey(queueRow, queueOptions, queueOptions);
+		const children = queueRow[finalChildrenKey];
+		if (isArray(children)) {
+			const nextLevelOptions = {
+				...queueOptions,
+				parents: [...queueOptions.parents, queueRow],
+				depth: queueOptions.depth + 1
+			};
+			const subQueueItems = children.map((queueRow$1) => ({
+				queueRow: queueRow$1,
+				queueOptions: nextLevelOptions
+			}));
+			queue.push(...subQueueItems);
+		}
+		const res = callback(queueRow, queueOptions);
+		cache.set(queueRow, res);
+		childrenKeyCache.set(queueRow, finalChildrenKey);
+		const parent = arrayLast(queueOptions.parents);
+		if (parent) {
+			const newParent = cache.get(parent);
+			const parentChildrenKey = childrenKeyCache.get(parent);
+			if (newParent && parentChildrenKey) if (newParent[parentChildrenKey]) newParent[parentChildrenKey].push(res);
+			else newParent[parentChildrenKey] = [res];
+		}
+		if (queueOptions.depth === 0) result = res;
+		return runQueue();
+	};
+	return runQueue();
+}
+function treeMap(tree, callback, options = {}) {
+	const { childrenKey = "children", strategy = "pre", getChildrenKey } = options;
+	const traversalMethod = strategies[strategy];
+	const innerOptions = {
+		childrenKey,
+		depth: 0,
+		parents: [],
+		getChildrenKey
+	};
+	return isArray(tree) ? tree.map((row) => traversalMethod(row, callback, innerOptions)) : traversalMethod(tree, callback, innerOptions);
+}
+
+//#endregion
+//#region src/utils/tree/rowsToTree.ts
+/**
+* 行结构 转 树结构
+*/
+function rowsToTree(rows, options) {
+	const { parentIdKey = "parentId", rowKey = "id", childrenKey = "children" } = options || {};
+	const result = [];
+	const map = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const id = row[rowKey];
+		if (!map.get(id)) map.set(id, row);
+	}
+	for (const row of rows) {
+		const parentId = row[parentIdKey];
+		const parent = map.get(parentId);
+		if (!parent || !parentId) {
+			result.push(row);
+			continue;
+		}
+		const siblings = parent[childrenKey];
+		if (isNull(siblings) || isUndefined(siblings)) parent[childrenKey] = [row];
+		else if (Array.isArray(siblings)) siblings.push(row);
+		else {
+			const message = `The key "${childrenKey.toString()}" in parent item is not an array.`;
+			throw new Error(message);
+		}
+	}
+	return result;
+}
+
+//#endregion
+//#region src/utils/tree/treeToRows.ts
+/**
+* 树结构 转 行结构
+*/
+function treeToRows(tree, options = {}) {
+	const { childrenKey = "children" } = options;
+	const result = [];
+	if (!tree) return result;
+	treeForEach(tree, (t) => result.push({
+		...t,
+		[childrenKey]: void 0
+	}), options);
+	return result;
+}
+
+//#endregion
+export { arrayCast, arrayCompete, arrayCounting, arrayDifference, arrayFirst, arrayFork, arrayIntersection, arrayLast, arrayMerge, arrayPick, arrayReplace, arraySplit, cloneDeep, enumEntries, enumKeys, enumTypeCheck, enumValues, isArray, isAsyncFunction, isBigInt, isBoolean, isClass, isDate, isEqual, isError, isFile, isFunction, isGeneratorFunction, isInteger, isIterable, isMap, isNull, isNumber, isObject, isPromise, isPromiseLike, isRegExp, isSet, isString, isSymbol, isURLSearchParams, isUndefined, isWeakMap, isWeakSet, isWebSocket, isWindow, mapEntries, objectAssign, objectEntries, objectKeys, objectPick, objectSwitch, objectValues, rowsToTree, stringInitialCase, stringReplace, stringToJson, stringToValues, to, treeFilter, treeFind, treeForEach, treeMap, treeToRows };
+//# sourceMappingURL=index.js.map