@nickyzj2023/utils 1.0.19 → 1.0.21

package/src/object.ts

@@ -2,53 +2,51 @@ import { isObject, isPrimitive } from "./is";
 
 /**
  * 深度合并两个对象，规则如下：
- * 1. 原始值覆盖：如果两个值都是原始类型（string、number、boolean、null、undefined、symbol、bigint），则用后者覆盖;
+ * 1. 原始值覆盖：如果两个值都是原始类型，则用后者覆盖;
  * 2. 数组拼接：如果两个值都是数组，则拼接为大数组；
  * 3. 对象递归合并：如果两个值都是对象，则进行递归深度合并；
- * 4. 类型不匹配覆盖：如果两个值的类型不同，则用后者覆盖；
- * 5. 独有属性保留：如果字段只存在于其中一个对象中，则保留它。
  *
  * @template T 第一个对象
  * @template U 第二个对象
- * @param {T} obj1 要合并的第一个对象，相同字段可能会被 obj2 覆盖
+ * @param {T} obj1 要合并的第一个对象，相同字段会被 obj2 覆盖
  * @param {U} obj2 要合并的第二个对象
  */
 export const mergeObjects = <
-  T extends Record<string, any>,
-  U extends Record<string, any>,
+	T extends Record<string, any>,
+	U extends Record<string, any>,
 >(
-  obj1: T,
-  obj2: U,
+	obj1: T,
+	obj2: U,
 ) => {
-  const result: Record<string, any> = { ...obj1 };
-
-  for (const key of Object.keys(obj2)) {
-    const val1 = result[key];
-    const val2 = obj2[key];
-
-    // 如果都是原始值，则用后者覆盖
-    if (isPrimitive(val1) && isPrimitive(val2)) {
-      result[key] = val2;
-      continue;
-    }
-
-    // 如果都是数组，则拼接为大数组
-    if (Array.isArray(val1) && Array.isArray(val2)) {
-      result[key] = val1.concat(val2);
-      continue;
-    }
-
-    // 如果都是对象，则深度递归合并
-    if (isObject(val1) && isObject(val2)) {
-      result[key] = mergeObjects(val1, val2);
-      continue;
-    }
-
-    // 如果类型不同，则用后者覆盖
-    result[key] = val2;
-  }
-
-  return result as T & U;
+	const result: Record<string, any> = { ...obj1 };
+
+	for (const key of Object.keys(obj2)) {
+		const val1 = result[key];
+		const val2 = obj2[key];
+
+		// 如果都是原始值，则用后者覆盖
+		if (isPrimitive(val1) && isPrimitive(val2)) {
+			result[key] = val2;
+			continue;
+		}
+
+		// 如果都是数组，则拼接为大数组
+		if (Array.isArray(val1) && Array.isArray(val2)) {
+			result[key] = val1.concat(val2);
+			continue;
+		}
+
+		// 如果都是对象，则深度递归合并
+		if (isObject(val1) && isObject(val2)) {
+			result[key] = mergeObjects(val1, val2);
+			continue;
+		}
+
+		// 其他情况用后者覆盖
+		result[key] = val2;
+	}
+
+	return result as T & U;
 };
 
 // --- mapKeys ---
@@ -56,11 +54,11 @@ export const mergeObjects = <
 // 这里的 DeepMapKeys 只能承诺 key 是 string，无法推断出 key 的具体字面量变化
 // 因为 TS 不支持根据任意函数反推 Key 的字面量类型
 export type DeepMapKeys<T> =
-  T extends Array<infer U>
-    ? Array<DeepMapKeys<U>>
-    : T extends object
-      ? { [key: string]: DeepMapKeys<T[keyof T]> }
-      : T;
+	T extends Array<infer U>
+		? Array<DeepMapKeys<U>>
+		: T extends object
+			? { [key: string]: DeepMapKeys<T[keyof T]> }
+			: T;
 
 /**
  * 递归处理对象里的 key
@@ -76,30 +74,30 @@ export type DeepMapKeys<T> =
  * console.log(result); // { A: { B: 1 } }
  */
 export const mapKeys = <T>(
-  obj: T,
-  getNewKey: (key: string) => string,
+	obj: T,
+	getNewKey: (key: string) => string,
 ): DeepMapKeys<T> => {
-  // 递归处理数组
-  if (Array.isArray(obj)) {
-    return obj.map((item) => mapKeys(item, getNewKey)) as any;
-  }
-
-  // 处理普通对象
-  if (isObject(obj)) {
-    const keys = Object.keys(obj);
-    return keys.reduce(
-      (result, key) => {
-        const newKey = getNewKey(key);
-        const value = (obj as any)[key];
-        result[newKey] = mapKeys(value, getNewKey);
-        return result;
-      },
-      {} as Record<string, any>,
-    ) as DeepMapKeys<T>;
-  }
-
-  // 处理非数组/对象
-  return obj as any;
+	// 递归处理数组
+	if (Array.isArray(obj)) {
+		return obj.map((item) => mapKeys(item, getNewKey)) as any;
+	}
+
+	// 处理普通对象
+	if (isObject(obj)) {
+		const keys = Object.keys(obj);
+		return keys.reduce(
+			(result, key) => {
+				const newKey = getNewKey(key);
+				const value = (obj as any)[key];
+				result[newKey] = mapKeys(value, getNewKey);
+				return result;
+			},
+			{} as Record<string, any>,
+		) as DeepMapKeys<T>;
+	}
+
+	// 处理非数组/对象
+	return obj as any;
 };
 
 // --- mapValues ---
@@ -107,11 +105,11 @@ export const mapKeys = <T>(
 // 这里的 DeepMapValues 尝试保留 key，但将 value 类型替换为 R
 // 注意：如果原 value 是对象，我们递归处理结构，而不是把整个对象变成 R
 export type DeepMapValues<T, R> =
-  T extends Array<infer U>
-    ? Array<DeepMapValues<U, R>>
-    : T extends object
-      ? { [K in keyof T]: T[K] extends object ? DeepMapValues<T[K], R> : R }
-      : R;
+	T extends Array<infer U>
+		? Array<DeepMapValues<U, R>>
+		: T extends object
+			? { [K in keyof T]: T[K] extends object ? DeepMapValues<T[K], R> : R }
+			: R;
 
 /**
  * 递归处理对象里的 value
@@ -128,38 +126,38 @@ export type DeepMapValues<T, R> =
  * console.log(result); // { a: 2, b: { c: 3 } }
  */
 export const mapValues = <T, R = any>(
-  obj: T,
-  getNewValue: (value: any, key: string | number) => R,
+	obj: T,
+	getNewValue: (value: any, key: string | number) => R,
 ): DeepMapValues<T, R> => {
-  // 处理数组
-  if (Array.isArray(obj)) {
-    return obj.map((item, index) => {
-      // 如果元素是对象，则递归处理
-      if (isObject(item)) {
-        return mapValues(item, getNewValue);
-      }
-      // 如果元素是原始值，则直接应用 getNewValue（此时 key 为数组下标）
-      return getNewValue(item, index);
-    }) as any;
-  }
-
-  // 处理普通对象
-  if (isObject(obj)) {
-    const keys = Object.keys(obj);
-    return keys.reduce((result, key) => {
-      const value = (obj as any)[key];
-      // 如果值为对象或数组，则递归处理
-      if (!isPrimitive(value)) {
-        result[key] = mapValues(value, getNewValue);
-      }
-      // 否则直接应用 getNewValue
-      else {
-        result[key] = getNewValue(value, key);
-      }
-      return result;
-    }, {} as any) as DeepMapValues<T, R>;
-  }
-
-  // 处理非数组/对象
-  return obj as any;
+	// 处理数组
+	if (Array.isArray(obj)) {
+		return obj.map((item, index) => {
+			// 如果元素是对象，则递归处理
+			if (isObject(item)) {
+				return mapValues(item, getNewValue);
+			}
+			// 如果元素是原始值，则直接应用 getNewValue（此时 key 为数组下标）
+			return getNewValue(item, index);
+		}) as any;
+	}
+
+	// 处理普通对象
+	if (isObject(obj)) {
+		const keys = Object.keys(obj);
+		return keys.reduce((result, key) => {
+			const value = (obj as any)[key];
+			// 如果值为对象或数组，则递归处理
+			if (isObject(value) || Array.isArray(value)) {
+				result[key] = mapValues(value, getNewValue);
+			}
+			// 否则直接应用 getNewValue
+			else {
+				result[key] = getNewValue(value, key);
+			}
+			return result;
+		}, {} as any) as DeepMapValues<T, R>;
+	}
+
+	// 处理非数组/对象
+	return obj as any;
 };

package/src/string.ts

@@ -2,7 +2,7 @@
  * 下划线命名法转为驼峰命名法
  *
  * @example
- * snakeToCamel("user_name") // 'userName'
+ * snakeToCamel("user_name") // "userName"
  */
 export const snakeToCamel = (str: string) => {
 	return str.replace(/_([a-zA-Z])/g, (match, pattern) => pattern.toUpperCase());
@@ -12,7 +12,7 @@ export const snakeToCamel = (str: string) => {
  * 驼峰命名法转为下划线命名法
  *
  * @example
- * camelToSnake("shouldComponentUpdate") // 'should_component_update'
+ * camelToSnake("shouldComponentUpdate") // "should_component_update"
  */
 export const camelToSnake = (str: string) => {
 	return str.replace(
@@ -25,7 +25,7 @@ export const camelToSnake = (str: string) => {
  * 字符串首字母大写
  *
  * @example
- * capitalize("hello") // 'Hello'
+ * capitalize("hello") // "Hello"
  */
 export const capitalize = (s: string) => {
 	return s.charAt(0).toUpperCase() + s.slice(1);
@@ -35,7 +35,7 @@ export const capitalize = (s: string) => {
  * 字符串首字母小写
  *
  * @example
- * decapitalize("Hello") // 'hello'
+ * decapitalize("Hello") // "hello"
  */
 export const decapitalize = (s: string) => {
 	return s.charAt(0).toLowerCase() + s.slice(1);

package/src/time.ts

@@ -5,7 +5,7 @@
  * await sleep(1000); // 等待 1 秒执行后续代码
  */
 export const sleep = async (time = 150) => {
-  return new Promise((resolve) => {
-    setTimeout(resolve, time);
-  });
+	return new Promise((resolve) => {
+		setTimeout(resolve, time);
+	});
 };