@nickyzj2023/utils 1.0.18 → 1.0.19

package/src/object.ts

@@ -1,165 +1,165 @@
-import { isObject, isPrimitive } from "./is";
-
-/**
- * 深度合并两个对象，规则如下：
- * 1. 原始值覆盖：如果两个值都是原始类型（string、number、boolean、null、undefined、symbol、bigint），则用后者覆盖;
- * 2. 数组拼接：如果两个值都是数组，则拼接为大数组；
- * 3. 对象递归合并：如果两个值都是对象，则进行递归深度合并；
- * 4. 类型不匹配覆盖：如果两个值的类型不同，则用后者覆盖；
- * 5. 独有属性保留：如果字段只存在于其中一个对象中，则保留它。
- *
- * @template T 第一个对象
- * @template U 第二个对象
- * @param {T} obj1 要合并的第一个对象，相同字段可能会被 obj2 覆盖
- * @param {U} obj2 要合并的第二个对象
- */
-export const mergeObjects = <
-  T extends Record<string, any>,
-  U extends Record<string, any>,
->(
-  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;
-};
-
-// --- mapKeys ---
-
-// 这里的 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;
-
-/**
- * 递归处理对象里的 key
- *
- * @remarks
- * 无法完整推导出类型，只能做到有递归，key 全为 string，value 为同层级的所有类型的联合
- *
- * @template T 要转换的对象
- *
- * @example
- * const obj = { a: { b: 1 } };
- * const result = mapKeys(obj, (key) => key.toUpperCase());
- * console.log(result); // { A: { B: 1 } }
- */
-export const mapKeys = <T>(
-  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;
-};
-
-// --- mapValues ---
-
-// 这里的 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;
-
-/**
- * 递归处理对象里的 value
- *
- * @remarks
- * 无法完整推导出类型，所有 value 最终都会变为 any
- *
- * @template T 要转换的对象
- * @template R 转换后的值类型，为 any，无法进一步推导
- *
- * @example
- * const obj = { a: 1, b: { c: 2 } };
- * const result = mapValues(obj, (value, key) => isPrimitive(value) ? value + 1 : value);
- * console.log(result); // { a: 2, b: { c: 3 } }
- */
-export const mapValues = <T, R = any>(
-  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;
-};
+import { isObject, isPrimitive } from "./is";
+
+/**
+ * 深度合并两个对象，规则如下：
+ * 1. 原始值覆盖：如果两个值都是原始类型（string、number、boolean、null、undefined、symbol、bigint），则用后者覆盖;
+ * 2. 数组拼接：如果两个值都是数组，则拼接为大数组；
+ * 3. 对象递归合并：如果两个值都是对象，则进行递归深度合并；
+ * 4. 类型不匹配覆盖：如果两个值的类型不同，则用后者覆盖；
+ * 5. 独有属性保留：如果字段只存在于其中一个对象中，则保留它。
+ *
+ * @template T 第一个对象
+ * @template U 第二个对象
+ * @param {T} obj1 要合并的第一个对象，相同字段可能会被 obj2 覆盖
+ * @param {U} obj2 要合并的第二个对象
+ */
+export const mergeObjects = <
+  T extends Record<string, any>,
+  U extends Record<string, any>,
+>(
+  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;
+};
+
+// --- mapKeys ---
+
+// 这里的 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;
+
+/**
+ * 递归处理对象里的 key
+ *
+ * @remarks
+ * 无法完整推导出类型，只能做到有递归，key 全为 string，value 为同层级的所有类型的联合
+ *
+ * @template T 要转换的对象
+ *
+ * @example
+ * const obj = { a: { b: 1 } };
+ * const result = mapKeys(obj, (key) => key.toUpperCase());
+ * console.log(result); // { A: { B: 1 } }
+ */
+export const mapKeys = <T>(
+  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;
+};
+
+// --- mapValues ---
+
+// 这里的 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;
+
+/**
+ * 递归处理对象里的 value
+ *
+ * @remarks
+ * 无法完整推导出类型，所有 value 最终都会变为 any
+ *
+ * @template T 要转换的对象
+ * @template R 转换后的值类型，为 any，无法进一步推导
+ *
+ * @example
+ * const obj = { a: 1, b: { c: 2 } };
+ * const result = mapValues(obj, (value, key) => isPrimitive(value) ? value + 1 : value);
+ * console.log(result); // { a: 2, b: { c: 3 } }
+ */
+export const mapValues = <T, R = any>(
+  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;
+};

package/src/string.ts

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

package/src/time.ts

@@ -1,11 +1,11 @@
-/**
- * 延迟一段时间再执行后续代码
- * @param time 延迟时间，默认 150ms
- * @example
- * await sleep(1000); // 等待 1 秒执行后续代码
- */
-export const sleep = async (time = 150) => {
-  return new Promise((resolve) => {
-    setTimeout(resolve, time);
-  });
-};
+/**
+ * 延迟一段时间再执行后续代码
+ * @param time 延迟时间，默认 150ms
+ * @example
+ * await sleep(1000); // 等待 1 秒执行后续代码
+ */
+export const sleep = async (time = 150) => {
+  return new Promise((resolve) => {
+    setTimeout(resolve, time);
+  });
+};

package/tsconfig.json

@@ -1,32 +1,32 @@
-{
-  "compilerOptions": {
-    // Environment setup & latest features
-    "lib": ["ESNext", "DOM"],
-    "target": "ESNext",
-    "module": "Preserve",
-    "moduleDetection": "force",
-    "jsx": "react-jsx",
-    "allowJs": true,
-
-    // Bundler mode
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-    "outDir": "dist",
-    "declaration": true,
-    "emitDeclarationOnly": true,
-
-    // Best practices
-    "strict": true,
-    "skipLibCheck": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
-
-    // Some stricter flags (disabled by default)
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "noPropertyAccessFromIndexSignature": false
-  },
-  "include": ["src"]
-}
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext", "DOM"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "outDir": "dist",
+    "declaration": true,
+    "emitDeclarationOnly": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  },
+  "include": ["src"]
+}