@cloudcome/utils-core 1.19.0 → 1.20.0

package/README.md

@@ -117,7 +117,7 @@ UniApp 工具库，依赖 `@cloudcome/utils-core`、`@cloudcome/utils-vue`：
 
 ## 开发
 
-详见 [DEVELOPMENT.md](./DEVELOPMENT.md)。
+详见 [CONTRIBUTING.md](./CONTRIBUTING.md)。
 
 ## 许可
 

package/dist/array.cjs

@@ -1,144 +1,199 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const type = require("./type.cjs");
+const require_type = require("./type.cjs");
+//#region src/array.ts
+/**
+* 检查给定的值是否为类数组对象。
+*
+* 类数组对象是指具有 `length` 属性且 `length` 属性为非负数的对象。
+*
+* @param unknown - 要检查的值。
+* @returns 如果值是类数组对象，则返回 `true`，否则返回 `false`。
+*/
 function isArrayLike(unknown) {
-  if (type.isArray(unknown)) return true;
-  if (type.isObject(unknown)) {
-    const arrayLike = unknown;
-    return typeof arrayLike.length === "number" && arrayLike.length >= 0;
-  }
-  return false;
+	if (require_type.isArray(unknown)) return true;
+	if (require_type.isObject(unknown)) {
+		const arrayLike = unknown;
+		return typeof arrayLike.length === "number" && arrayLike.length >= 0;
+	}
+	return false;
 }
+/**
+* 从数组中选择指定索引的元素。
+*
+* @param array - 要从中选择元素的数组。
+* @param indexes - 要选择的元素的索引数组。
+* @returns 包含指定索引元素的新数组。
+*/
 function arrayPick(array, indexes) {
-  const indexes2 = [...indexes];
-  return array.filter((_, i) => {
-    const index = indexes2.indexOf(i);
-    if (index === -1) return false;
-    indexes2.splice(index, 1);
-    return true;
-  });
+	const indexes2 = [...indexes];
+	return array.filter((_, i) => {
+		const index = indexes2.indexOf(i);
+		if (index === -1) return false;
+		indexes2.splice(index, 1);
+		return true;
+	});
 }
+/**
+* 从数组中排除指定索引的元素。
+*
+* @param array - 要从中排除元素的数组。
+* @param indexes - 要排除的元素的索引数组。
+* @returns 包含排除指定索引元素后的新数组。
+*/
 function arrayOmit(array, indexes) {
-  const indexes2 = [...indexes];
-  return array.filter((_, i) => {
-    const index = indexes2.indexOf(i);
-    if (index === -1) return true;
-    indexes2.splice(index, 1);
-    return false;
-  });
+	const indexes2 = [...indexes];
+	return array.filter((_, i) => {
+		const index = indexes2.indexOf(i);
+		if (index === -1) return true;
+		indexes2.splice(index, 1);
+		return false;
+	});
 }
+/**
+* 遍历数组中的每个元素，并对每个元素执行提供的回调函数。
+*
+* @param array - 要遍历的数组。
+* @param iterator - 对每个元素执行的回调函数。如果回调函数返回 `false`，则提前终止遍历。
+* @param reverse - 是否以相反的顺序遍历数组。默认为 `false`。
+* @returns 无返回值。
+*
+* @example
+* ```typescript
+* const arr = [1, 2, 3];
+* arrayEach(arr, (item, index) => {
+*   console.log(item, index);
+*   if (index === 1) return false; // 提前终止遍历
+* });
+* ```
+*/
 function arrayEach(array, iterator, reverse = false) {
-  const _array = [...array];
-  const length = array.length;
-  if (reverse) {
-    for (let i = length - 1; i >= 0; i--) {
-      if (iterator(_array[i], i) === false) {
-        break;
-      }
-    }
-  } else {
-    for (let i = 0; i < length; i++) {
-      if (iterator(_array[i], i) === false) {
-        break;
-      }
-    }
-  }
+	const _array = [...array];
+	const length = array.length;
+	if (reverse) {
+		for (let i = length - 1; i >= 0; i--) if (iterator(_array[i], i) === false) break;
+	} else for (let i = 0; i < length; i++) if (iterator(_array[i], i) === false) break;
 }
+/**
+* 异步遍历数组中的每个元素，并对每个元素执行提供的回调函数。
+*
+* @param array - 要遍历的数组。
+* @param iterator - 对每个元素执行的异步回调函数。如果回调函数返回 `false`，则提前终止遍历。
+* @param reverse - 是否以相反的顺序遍历数组。默认为 `false`。
+* @returns 无返回值。
+*
+* @example
+* ```typescript
+* const arr = [1, 2, 3];
+* await arrayEachAsync(arr, async (item, index) => {
+*   await someAsyncOperation(item);
+*   if (index === 1) return false; // 提前终止遍历
+* });
+* ```
+*/
 async function arrayEachAsync(array, iterator, reverse = false) {
-  const _array = [...array];
-  const length = array.length;
-  if (reverse) {
-    for (let i = length - 1; i >= 0; i--) {
-      if (await iterator(_array[i], i) === false) {
-        break;
-      }
-    }
-  } else {
-    for (let i = 0; i < length; i++) {
-      if (await iterator(_array[i], i) === false) {
-        break;
-      }
-    }
-  }
+	const _array = [...array];
+	const length = array.length;
+	if (reverse) {
+		for (let i = length - 1; i >= 0; i--) if (await iterator(_array[i], i) === false) break;
+	} else for (let i = 0; i < length; i++) if (await iterator(_array[i], i) === false) break;
 }
+/**
+* 将数组中的元素移动到指定位置。
+*
+* @param array - 要移动元素的数组。
+* @param from - 要移动的元素的起始位置。
+* @param to - 要移动的元素的目标位置。
+* @returns 新的数组，其中包含移动后的元素。
+*
+* @example
+* ```typescript
+* const arr = [1, 2, 3, 4, 5];
+* const newArr = arrayMove(arr, 1, 3);
+* // 返回 [1, 3, 4, 2, 5]
+* ```
+*/
 function arrayMove(array, from, to) {
-  const array2 = [...array];
-  if (from < 0 || from >= array2.length || to < 0 || to >= array2.length) {
-    return array2;
-  }
-  const item = array2[from];
-  array2.splice(from, 1);
-  array2.splice(to, 0, item);
-  return array2;
+	const array2 = [...array];
+	if (from < 0 || from >= array2.length || to < 0 || to >= array2.length) return array2;
+	const item = array2[from];
+	array2.splice(from, 1);
+	array2.splice(to, 0, item);
+	return array2;
 }
 function arrayDiff(refArray, curArray, options) {
-  const { getItemKey = (item) => item } = options || {};
-  const toKeyIndexes = (map, item) => {
-    const key = getItemKey(item);
-    return {
-      key,
-      indexes: map.get(key) || []
-    };
-  };
-  const buildMap = (arr) => {
-    const map = /* @__PURE__ */ new Map();
-    arr.forEach((item, index) => {
-      const { key, indexes } = toKeyIndexes(map, item);
-      indexes.push(index);
-      map.set(key, indexes);
-    });
-    return map;
-  };
-  const toIndexesArr = (arr, indexes) => {
-    return indexes.map((index) => arr[index]);
-  };
-  const refMap = buildMap(refArray);
-  const curMap = buildMap(curArray);
-  const deleteSet = /* @__PURE__ */ new Set();
-  const addSet = /* @__PURE__ */ new Set();
-  const equalSet = /* @__PURE__ */ new Set();
-  for (const key of refMap.keys()) {
-    if (curMap.has(key)) {
-      equalSet.add(key);
-    } else {
-      deleteSet.add(key);
-    }
-  }
-  for (const key of curMap.keys()) {
-    if (!refMap.has(key)) {
-      addSet.add(key);
-    }
-  }
-  return {
-    deletes: [...deleteSet].map((key) => {
-      const indexes = refMap.get(key) || [];
-      return {
-        refIndexes: indexes,
-        refValues: toIndexesArr(refArray, indexes)
-      };
-    }),
-    adds: [...addSet].map((key) => {
-      const indexes = curMap.get(key) || [];
-      return {
-        curIndexes: indexes,
-        curValues: toIndexesArr(curArray, indexes)
-      };
-    }),
-    equals: [...equalSet].map((key) => {
-      const refIndexes = refMap.get(key) || [];
-      const curIndexes = curMap.get(key) || [];
-      return {
-        refIndexes,
-        curIndexes,
-        refValues: toIndexesArr(refArray, refIndexes),
-        curValues: toIndexesArr(curArray, curIndexes)
-      };
-    })
-  };
+	const { getItemKey = (item) => item } = options || {};
+	const toKeyIndexes = (map, item) => {
+		const key = getItemKey(item);
+		return {
+			key,
+			indexes: map.get(key) || []
+		};
+	};
+	const buildMap = (arr) => {
+		const map = /* @__PURE__ */ new Map();
+		arr.forEach((item, index) => {
+			const { key, indexes } = toKeyIndexes(map, item);
+			indexes.push(index);
+			map.set(key, indexes);
+		});
+		return map;
+	};
+	const toIndexesArr = (arr, indexes) => {
+		return indexes.map((index) => arr[index]);
+	};
+	const refMap = buildMap(refArray);
+	const curMap = buildMap(curArray);
+	const deleteSet = /* @__PURE__ */ new Set();
+	const addSet = /* @__PURE__ */ new Set();
+	const equalSet = /* @__PURE__ */ new Set();
+	for (const key of refMap.keys()) if (curMap.has(key)) equalSet.add(key);
+	else deleteSet.add(key);
+	for (const key of curMap.keys()) if (!refMap.has(key)) addSet.add(key);
+	return {
+		deletes: [...deleteSet].map((key) => {
+			const indexes = refMap.get(key) || [];
+			return {
+				refIndexes: indexes,
+				refValues: toIndexesArr(refArray, indexes)
+			};
+		}),
+		adds: [...addSet].map((key) => {
+			const indexes = curMap.get(key) || [];
+			return {
+				curIndexes: indexes,
+				curValues: toIndexesArr(curArray, indexes)
+			};
+		}),
+		equals: [...equalSet].map((key) => {
+			const refIndexes = refMap.get(key) || [];
+			const curIndexes = curMap.get(key) || [];
+			return {
+				refIndexes,
+				curIndexes,
+				refValues: toIndexesArr(refArray, refIndexes),
+				curValues: toIndexesArr(curArray, curIndexes)
+			};
+		})
+	};
 }
+/**
+* 从数组中移除指定索引的元素
+* @template T - 数组元素的类型
+* @param {T[]} array - 原始数组
+* @param {number[]} indexes - 要移除的元素索引数组
+* @returns {T[]} 移除指定索引元素后的新数组
+*
+* @example
+* ```typescript
+* const arr = [1, 2, 3, 4, 5];
+* const newArr = arrayRemove(arr, [1, 3]);
+* // 返回结果: [1, 3, 5]
+* ```
+*/
 function arrayRemove(array, indexes) {
-  return array.filter((item, index) => !indexes.includes(index));
+	return array.filter((_item, index) => !indexes.includes(index));
 }
+//#endregion
 exports.arrayDiff = arrayDiff;
 exports.arrayEach = arrayEach;
 exports.arrayEachAsync = arrayEachAsync;
@@ -147,4 +202,5 @@ exports.arrayOmit = arrayOmit;
 exports.arrayPick = arrayPick;
 exports.arrayRemove = arrayRemove;
 exports.isArrayLike = isArrayLike;
-//# sourceMappingURL=array.cjs.map
+
+//# sourceMappingURL=array.cjs.map

package/dist/array.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"array.cjs","sources":["../src/array.ts"],"sourcesContent":["import { isArray, isObject } from './type';\nimport type { MaybePromise } from './types';\n\n/**\n * 检查给定的值是否为类数组对象。\n *\n * 类数组对象是指具有 `length` 属性且 `length` 属性为非负数的对象。\n *\n * @param unknown - 要检查的值。\n * @returns 如果值是类数组对象，则返回 `true`，否则返回 `false`。\n */\nexport function isArrayLike(unknown: unknown) {\n  if (isArray(unknown)) return true;\n\n  if (isObject(unknown)) {\n    const arrayLike = unknown as { length: unknown };\n    return typeof arrayLike.length === 'number' && arrayLike.length >= 0;\n  }\n\n  return false;\n}\n\n/**\n * 从数组中选择指定索引的元素。\n *\n * @param array - 要从中选择元素的数组。\n * @param indexes - 要选择的元素的索引数组。\n * @returns 包含指定索引元素的新数组。\n */\nexport function arrayPick<T>(array: T[], indexes: number[]) {\n  const indexes2 = [...indexes];\n  return array.filter((_, i) => {\n    const index = indexes2.indexOf(i);\n    if (index === -1) return false;\n    indexes2.splice(index, 1);\n    return true;\n  });\n}\n\n/**\n * 从数组中排除指定索引的元素。\n *\n * @param array - 要从中排除元素的数组。\n * @param indexes - 要排除的元素的索引数组。\n * @returns 包含排除指定索引元素后的新数组。\n */\nexport function arrayOmit<T>(array: T[], indexes: number[]) {\n  const indexes2 = [...indexes];\n  return array.filter((_, i) => {\n    const index = indexes2.indexOf(i);\n    if (index === -1) return true;\n    indexes2.splice(index, 1);\n    return false;\n  });\n}\n\n/**\n * 遍历数组中的每个元素，并对每个元素执行提供的回调函数。\n *\n * @param array - 要遍历的数组。\n * @param iterator - 对每个元素执行的回调函数。如果回调函数返回 `false`，则提前终止遍历。\n * @param reverse - 是否以相反的顺序遍历数组。默认为 `false`。\n * @returns 无返回值。\n *\n * @example\n * ```typescript\n * const arr = [1, 2, 3];\n * arrayEach(arr, (item, index) => {\n *   console.log(item, index);\n *   if (index === 1) return false; // 提前终止遍历\n * });\n * ```\n */\nexport function arrayEach<T>(array: T[], iterator: (item: T, index: number) => false | unknown, reverse = false) {\n  const _array = [...array];\n  const length = array.length;\n\n  if (reverse) {\n    for (let i = length - 1; i >= 0; i--) {\n      if (iterator(_array[i], i) === false) {\n        break;\n      }\n    }\n  } else {\n    for (let i = 0; i < length; i++) {\n      if (iterator(_array[i], i) === false) {\n        break;\n      }\n    }\n  }\n}\n\n/**\n * 异步遍历数组中的每个元素，并对每个元素执行提供的回调函数。\n *\n * @param array - 要遍历的数组。\n * @param iterator - 对每个元素执行的异步回调函数。如果回调函数返回 `false`，则提前终止遍历。\n * @param reverse - 是否以相反的顺序遍历数组。默认为 `false`。\n * @returns 无返回值。\n *\n * @example\n * ```typescript\n * const arr = [1, 2, 3];\n * await arrayEachAsync(arr, async (item, index) => {\n *   await someAsyncOperation(item);\n *   if (index === 1) return false; // 提前终止遍历\n * });\n * ```\n */\nexport async function arrayEachAsync<T>(\n  array: T[],\n  iterator: (item: T, index: number) => MaybePromise<false | unknown>,\n  reverse = false,\n) {\n  const _array = [...array];\n  const length = array.length;\n\n  if (reverse) {\n    for (let i = length - 1; i >= 0; i--) {\n      if ((await iterator(_array[i], i)) === false) {\n        break;\n      }\n    }\n  } else {\n    for (let i = 0; i < length; i++) {\n      if ((await iterator(_array[i], i)) === false) {\n        break;\n      }\n    }\n  }\n}\n\n/**\n * 将数组中的元素移动到指定位置。\n *\n * @param array - 要移动元素的数组。\n * @param from - 要移动的元素的起始位置。\n * @param to - 要移动的元素的目标位置。\n * @returns 新的数组，其中包含移动后的元素。\n *\n * @example\n * ```typescript\n * const arr = [1, 2, 3, 4, 5];\n * const newArr = arrayMove(arr, 1, 3);\n * // 返回 [1, 3, 4, 2, 5]\n * ```\n */\nexport function arrayMove<T>(array: T[], from: number, to: number) {\n  const array2 = [...array];\n\n  if (from < 0 || from >= array2.length || to < 0 || to >= array2.length) {\n    return array2;\n  }\n\n  const item = array2[from];\n\n  array2.splice(from, 1);\n  array2.splice(to, 0, item);\n\n  return array2;\n}\n\n/**\n * 比较两个数组的差异，返回包含删除、新增和相同元素信息的对象\n *\n * @template T - 数组元素的类型\n * @param {T[]} refArray - 参考数组（原始数组）\n * @param {T[]} curArray - 当前数组（比较数组）\n * @returns {ArrayDiffs<T>} 包含差异信息的对象\n *\n * @example\n * ```typescript\n * const ref = [1, 2, 3];\n * const cur = [2, 3, 4];\n * const diff = arrayDiff(ref, cur);\n * // 返回结果:\n * // {\n * //   deletes: [{refIndexes: [0], refValue: 1}],\n * //   adds: [{curIndexes: [2], curValue: 4}],\n * //   equals: [\n * //     {refIndexes: [1], curIndexes: [0], refValue: 2, curValue: 2},\n * //     {refIndexes: [2], curIndexes: [1], refValue: 3, curValue: 3}\n * //   ]\n * // }\n * ```\n */\nexport type ArrayDiffs<T> = {\n  /**\n   * 被删除的元素列表\n   * @type {Array}\n   * @property {number[]} refIndexes - 元素在参考数组中的所有索引位置\n   * @property {T} refValue - 被删除的元素值\n   */\n  deletes: {\n    /**\n     * 元素在参考数组中的所有索引位置\n     * @type {number[]}\n     */\n    refIndexes: number[];\n    /**\n     * 被删除的元素值\n     * @type {T[]}\n     */\n    refValues: T[];\n  }[];\n\n  /**\n   * 新增的元素列表\n   * @type {Array}\n   * @property {number[]} curIndexes - 元素在当前数组中的所有索引位置\n   * @property {T} curValue - 新增的元素值\n   */\n  adds: {\n    /**\n     * 元素在当前数组中的所有索引位置\n     * @type {number[]}\n     */\n    curIndexes: number[];\n    /**\n     * 新增的元素值\n     * @type {T[]}\n     */\n    curValues: T[];\n  }[];\n\n  /**\n   * 相同的元素列表\n   * @type {Array}\n   * @property {number[]} refIndexes - 元素在参考数组中的所有索引位置\n   * @property {number[]} curIndexes - 元素在当前数组中的所有索引位置\n   * @property {T} refValue - 参考数组中的元素值\n   * @property {T} curValue - 当前数组中的元素值\n   */\n  equals: {\n    /**\n     * 元素在参考数组中的所有索引位置\n     * @type {number[]}\n     */\n    refIndexes: number[];\n    /**\n     * 元素在当前数组中的所有索引位置\n     * @type {number[]}\n     */\n    curIndexes: number[];\n    /**\n     * 参考数组中的元素值\n     * @type {T[]}\n     */\n    refValues: T[];\n    /**\n     * 当前数组中的元素值\n     * @type {T[]}\n     */\n    curValues: T[];\n  }[];\n};\n\nexport type ArrayDiffOptions<T> = {\n  getItemKey: (item: T) => unknown;\n};\n\nexport function arrayDiff<T>(refArray: T[], curArray: T[], options?: ArrayDiffOptions<T>): ArrayDiffs<T> {\n  const { getItemKey = (item: T) => item } = options || {};\n\n  // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n  type Key = any;\n\n  const toKeyIndexes = (map: Map<Key, number[]>, item: T) => {\n    const key = getItemKey(item);\n    return {\n      key,\n      indexes: map.get(key) || [],\n    };\n  };\n\n  const buildMap = (arr: T[]) => {\n    const map = new Map<Key, number[]>();\n\n    arr.forEach((item, index) => {\n      const { key, indexes } = toKeyIndexes(map, item);\n      indexes.push(index);\n      map.set(key, indexes);\n    });\n\n    return map;\n  };\n\n  const toIndexesArr = (arr: T[], indexes: number[]) => {\n    return indexes.map((index) => arr[index]);\n  };\n\n  const refMap = buildMap(refArray);\n  const curMap = buildMap(curArray);\n  const deleteSet = new Set<Key>();\n  const addSet = new Set<Key>();\n  const equalSet = new Set<Key>();\n\n  for (const key of refMap.keys()) {\n    if (curMap.has(key)) {\n      equalSet.add(key);\n    } else {\n      deleteSet.add(key);\n    }\n  }\n\n  for (const key of curMap.keys()) {\n    if (!refMap.has(key)) {\n      addSet.add(key);\n    }\n  }\n\n  return {\n    deletes: [...deleteSet].map((key) => {\n      const indexes = refMap.get(key) || [];\n      return {\n        refIndexes: indexes,\n        refValues: toIndexesArr(refArray, indexes),\n      };\n    }),\n\n    adds: [...addSet].map((key) => {\n      const indexes = curMap.get(key) || [];\n      return {\n        curIndexes: indexes,\n        curValues: toIndexesArr(curArray, indexes),\n      };\n    }),\n\n    equals: [...equalSet].map((key) => {\n      const refIndexes = refMap.get(key) || [];\n      const curIndexes = curMap.get(key) || [];\n      return {\n        refIndexes,\n        curIndexes,\n        refValues: toIndexesArr(refArray, refIndexes),\n        curValues: toIndexesArr(curArray, curIndexes),\n      };\n    }),\n  };\n}\n\n/**\n * 从数组中移除指定索引的元素\n * @template T - 数组元素的类型\n * @param {T[]} array - 原始数组\n * @param {number[]} indexes - 要移除的元素索引数组\n * @returns {T[]} 移除指定索引元素后的新数组\n *\n * @example\n * ```typescript\n * const arr = [1, 2, 3, 4, 5];\n * const newArr = arrayRemove(arr, [1, 3]);\n * // 返回结果: [1, 3, 5]\n * ```\n */\nexport function arrayRemove<T>(array: T[], indexes: number[]) {\n  return array.filter((item, index) => !indexes.includes(index));\n}\n"],"names":["isArray","isObject"],"mappings":"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"}
+{"version":3,"file":"array.cjs","names":[],"sources":["../src/array.ts"],"sourcesContent":["import { isArray, isObject } from './type';\nimport type { MaybePromise } from './types';\n\n/**\n * 检查给定的值是否为类数组对象。\n *\n * 类数组对象是指具有 `length` 属性且 `length` 属性为非负数的对象。\n *\n * @param unknown - 要检查的值。\n * @returns 如果值是类数组对象，则返回 `true`，否则返回 `false`。\n */\nexport function isArrayLike(unknown: unknown) {\n  if (isArray(unknown)) return true;\n\n  if (isObject(unknown)) {\n    const arrayLike = unknown as { length: unknown };\n    return typeof arrayLike.length === 'number' && arrayLike.length >= 0;\n  }\n\n  return false;\n}\n\n/**\n * 从数组中选择指定索引的元素。\n *\n * @param array - 要从中选择元素的数组。\n * @param indexes - 要选择的元素的索引数组。\n * @returns 包含指定索引元素的新数组。\n */\nexport function arrayPick<T>(array: T[], indexes: number[]) {\n  const indexes2 = [...indexes];\n  return array.filter((_, i) => {\n    const index = indexes2.indexOf(i);\n    if (index === -1) return false;\n    indexes2.splice(index, 1);\n    return true;\n  });\n}\n\n/**\n * 从数组中排除指定索引的元素。\n *\n * @param array - 要从中排除元素的数组。\n * @param indexes - 要排除的元素的索引数组。\n * @returns 包含排除指定索引元素后的新数组。\n */\nexport function arrayOmit<T>(array: T[], indexes: number[]) {\n  const indexes2 = [...indexes];\n  return array.filter((_, i) => {\n    const index = indexes2.indexOf(i);\n    if (index === -1) return true;\n    indexes2.splice(index, 1);\n    return false;\n  });\n}\n\n/**\n * 遍历数组中的每个元素，并对每个元素执行提供的回调函数。\n *\n * @param array - 要遍历的数组。\n * @param iterator - 对每个元素执行的回调函数。如果回调函数返回 `false`，则提前终止遍历。\n * @param reverse - 是否以相反的顺序遍历数组。默认为 `false`。\n * @returns 无返回值。\n *\n * @example\n * ```typescript\n * const arr = [1, 2, 3];\n * arrayEach(arr, (item, index) => {\n *   console.log(item, index);\n *   if (index === 1) return false; // 提前终止遍历\n * });\n * ```\n */\nexport function arrayEach<T>(\n  array: T[],\n  iterator: (item: T, index: number) => false | unknown,\n  reverse = false,\n) {\n  const _array = [...array];\n  const length = array.length;\n\n  if (reverse) {\n    for (let i = length - 1; i >= 0; i--) {\n      if (iterator(_array[i], i) === false) {\n        break;\n      }\n    }\n  } else {\n    for (let i = 0; i < length; i++) {\n      if (iterator(_array[i], i) === false) {\n        break;\n      }\n    }\n  }\n}\n\n/**\n * 异步遍历数组中的每个元素，并对每个元素执行提供的回调函数。\n *\n * @param array - 要遍历的数组。\n * @param iterator - 对每个元素执行的异步回调函数。如果回调函数返回 `false`，则提前终止遍历。\n * @param reverse - 是否以相反的顺序遍历数组。默认为 `false`。\n * @returns 无返回值。\n *\n * @example\n * ```typescript\n * const arr = [1, 2, 3];\n * await arrayEachAsync(arr, async (item, index) => {\n *   await someAsyncOperation(item);\n *   if (index === 1) return false; // 提前终止遍历\n * });\n * ```\n */\nexport async function arrayEachAsync<T>(\n  array: T[],\n  iterator: (item: T, index: number) => MaybePromise<false | unknown>,\n  reverse = false,\n) {\n  const _array = [...array];\n  const length = array.length;\n\n  if (reverse) {\n    for (let i = length - 1; i >= 0; i--) {\n      if ((await iterator(_array[i], i)) === false) {\n        break;\n      }\n    }\n  } else {\n    for (let i = 0; i < length; i++) {\n      if ((await iterator(_array[i], i)) === false) {\n        break;\n      }\n    }\n  }\n}\n\n/**\n * 将数组中的元素移动到指定位置。\n *\n * @param array - 要移动元素的数组。\n * @param from - 要移动的元素的起始位置。\n * @param to - 要移动的元素的目标位置。\n * @returns 新的数组，其中包含移动后的元素。\n *\n * @example\n * ```typescript\n * const arr = [1, 2, 3, 4, 5];\n * const newArr = arrayMove(arr, 1, 3);\n * // 返回 [1, 3, 4, 2, 5]\n * ```\n */\nexport function arrayMove<T>(array: T[], from: number, to: number) {\n  const array2 = [...array];\n\n  if (from < 0 || from >= array2.length || to < 0 || to >= array2.length) {\n    return array2;\n  }\n\n  const item = array2[from];\n\n  array2.splice(from, 1);\n  array2.splice(to, 0, item);\n\n  return array2;\n}\n\n/**\n * 比较两个数组的差异，返回包含删除、新增和相同元素信息的对象\n *\n * @template T - 数组元素的类型\n * @param {T[]} refArray - 参考数组（原始数组）\n * @param {T[]} curArray - 当前数组（比较数组）\n * @returns {ArrayDiffs<T>} 包含差异信息的对象\n *\n * @example\n * ```typescript\n * const ref = [1, 2, 3];\n * const cur = [2, 3, 4];\n * const diff = arrayDiff(ref, cur);\n * // 返回结果:\n * // {\n * //   deletes: [{refIndexes: [0], refValue: 1}],\n * //   adds: [{curIndexes: [2], curValue: 4}],\n * //   equals: [\n * //     {refIndexes: [1], curIndexes: [0], refValue: 2, curValue: 2},\n * //     {refIndexes: [2], curIndexes: [1], refValue: 3, curValue: 3}\n * //   ]\n * // }\n * ```\n */\nexport type ArrayDiffs<T> = {\n  /**\n   * 被删除的元素列表\n   * @type {Array}\n   * @property {number[]} refIndexes - 元素在参考数组中的所有索引位置\n   * @property {T} refValue - 被删除的元素值\n   */\n  deletes: {\n    /**\n     * 元素在参考数组中的所有索引位置\n     * @type {number[]}\n     */\n    refIndexes: number[];\n    /**\n     * 被删除的元素值\n     * @type {T[]}\n     */\n    refValues: T[];\n  }[];\n\n  /**\n   * 新增的元素列表\n   * @type {Array}\n   * @property {number[]} curIndexes - 元素在当前数组中的所有索引位置\n   * @property {T} curValue - 新增的元素值\n   */\n  adds: {\n    /**\n     * 元素在当前数组中的所有索引位置\n     * @type {number[]}\n     */\n    curIndexes: number[];\n    /**\n     * 新增的元素值\n     * @type {T[]}\n     */\n    curValues: T[];\n  }[];\n\n  /**\n   * 相同的元素列表\n   * @type {Array}\n   * @property {number[]} refIndexes - 元素在参考数组中的所有索引位置\n   * @property {number[]} curIndexes - 元素在当前数组中的所有索引位置\n   * @property {T} refValue - 参考数组中的元素值\n   * @property {T} curValue - 当前数组中的元素值\n   */\n  equals: {\n    /**\n     * 元素在参考数组中的所有索引位置\n     * @type {number[]}\n     */\n    refIndexes: number[];\n    /**\n     * 元素在当前数组中的所有索引位置\n     * @type {number[]}\n     */\n    curIndexes: number[];\n    /**\n     * 参考数组中的元素值\n     * @type {T[]}\n     */\n    refValues: T[];\n    /**\n     * 当前数组中的元素值\n     * @type {T[]}\n     */\n    curValues: T[];\n  }[];\n};\n\nexport type ArrayDiffOptions<T> = {\n  getItemKey: (item: T) => unknown;\n};\n\nexport function arrayDiff<T>(\n  refArray: T[],\n  curArray: T[],\n  options?: ArrayDiffOptions<T>,\n): ArrayDiffs<T> {\n  const { getItemKey = (item: T) => item } = options || {};\n\n  // biome-ignore lint/suspicious/noExplicitAny: 内部使用\n  type Key = any;\n\n  const toKeyIndexes = (map: Map<Key, number[]>, item: T) => {\n    const key = getItemKey(item);\n    return {\n      key,\n      indexes: map.get(key) || [],\n    };\n  };\n\n  const buildMap = (arr: T[]) => {\n    const map = new Map<Key, number[]>();\n\n    arr.forEach((item, index) => {\n      const { key, indexes } = toKeyIndexes(map, item);\n      indexes.push(index);\n      map.set(key, indexes);\n    });\n\n    return map;\n  };\n\n  const toIndexesArr = (arr: T[], indexes: number[]) => {\n    return indexes.map((index) => arr[index]);\n  };\n\n  const refMap = buildMap(refArray);\n  const curMap = buildMap(curArray);\n  const deleteSet = new Set<Key>();\n  const addSet = new Set<Key>();\n  const equalSet = new Set<Key>();\n\n  for (const key of refMap.keys()) {\n    if (curMap.has(key)) {\n      equalSet.add(key);\n    } else {\n      deleteSet.add(key);\n    }\n  }\n\n  for (const key of curMap.keys()) {\n    if (!refMap.has(key)) {\n      addSet.add(key);\n    }\n  }\n\n  return {\n    deletes: [...deleteSet].map((key) => {\n      const indexes = refMap.get(key) || [];\n      return {\n        refIndexes: indexes,\n        refValues: toIndexesArr(refArray, indexes),\n      };\n    }),\n\n    adds: [...addSet].map((key) => {\n      const indexes = curMap.get(key) || [];\n      return {\n        curIndexes: indexes,\n        curValues: toIndexesArr(curArray, indexes),\n      };\n    }),\n\n    equals: [...equalSet].map((key) => {\n      const refIndexes = refMap.get(key) || [];\n      const curIndexes = curMap.get(key) || [];\n      return {\n        refIndexes,\n        curIndexes,\n        refValues: toIndexesArr(refArray, refIndexes),\n        curValues: toIndexesArr(curArray, curIndexes),\n      };\n    }),\n  };\n}\n\n/**\n * 从数组中移除指定索引的元素\n * @template T - 数组元素的类型\n * @param {T[]} array - 原始数组\n * @param {number[]} indexes - 要移除的元素索引数组\n * @returns {T[]} 移除指定索引元素后的新数组\n *\n * @example\n * ```typescript\n * const arr = [1, 2, 3, 4, 5];\n * const newArr = arrayRemove(arr, [1, 3]);\n * // 返回结果: [1, 3, 5]\n * ```\n */\nexport function arrayRemove<T>(array: T[], indexes: number[]) {\n  return array.filter((_item, index) => !indexes.includes(index));\n}\n"],"mappings":"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"}