@nickyzj2023/utils 1.0.15 → 1.0.17

package/src/lru-cache.ts

@@ -1,50 +1,50 @@
-/**
- * 简易 LRU 缓存
- * @example
- * const cache = new LRUCache<string, number>(2);
- * cache.set("a", 1);
- * cache.set("b", 2);
- * cache.set("c", 3);    // 缓存已满，a 被淘汰
- * cache.get("a");    // undefined
- */
-class LRUCache<K, V> {
-  private cache: Map<K, V>;
-  private maxSize: number;
-
-  constructor(maxSize = 10) {
-    this.cache = new Map();
-    this.maxSize = maxSize;
-  }
-
-  get(key: K): V | undefined {
-    const value = this.cache.get(key);
-    if (!value) {
-      return undefined;
-    }
-    // 重置缓存顺序
-    this.cache.delete(key);
-    this.cache.set(key, value);
-    return value;
-  }
-
-  set(key: K, value: V) {
-    // 刷新缓存
-    if (this.cache.has(key)) {
-      this.cache.delete(key);
-    }
-    // 删除最旧的缓存
-    else if (this.cache.size >= this.maxSize) {
-      const oldestKey = [...this.cache.keys()][0];
-      if (oldestKey) {
-        this.cache.delete(oldestKey);
-      }
-    }
-    this.cache.set(key, value);
-  }
-
-  has(key: K) {
-    return this.cache.has(key);
-  }
-}
-
-export default LRUCache;
+/**
+ * 简易 LRU 缓存
+ * @example
+ * const cache = new LRUCache<string, number>(2);
+ * cache.set("a", 1);
+ * cache.set("b", 2);
+ * cache.set("c", 3);    // 缓存已满，a 被淘汰
+ * cache.get("a");    // undefined
+ */
+class LRUCache<K, V> {
+  private cache: Map<K, V>;
+  private maxSize: number;
+
+  constructor(maxSize = 10) {
+    this.cache = new Map();
+    this.maxSize = maxSize;
+  }
+
+  get(key: K): V | undefined {
+    const value = this.cache.get(key);
+    if (!value) {
+      return undefined;
+    }
+    // 重置缓存顺序
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    return value;
+  }
+
+  set(key: K, value: V) {
+    // 刷新缓存
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    }
+    // 删除最旧的缓存
+    else if (this.cache.size >= this.maxSize) {
+      const oldestKey = [...this.cache.keys()][0];
+      if (oldestKey) {
+        this.cache.delete(oldestKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+
+  has(key: K) {
+    return this.cache.has(key);
+  }
+}
+
+export default LRUCache;

package/src/network.ts

@@ -1,111 +1,111 @@
-import { isObject } from "./is";
-import { mergeObjects } from "./object";
-
-type RequestInit = BunFetchRequestInit & {
-  parser?: (response: Response) => Promise<any>;
-};
-
-/**
- * 基于 Fetch API 的请求客户端
- * @param baseURL 接口前缀，如 https://nickyzj.run:3030，也可以不填
- * @param defaultOptions 客户端级别的请求选项，方法级别的选项会覆盖这里的相同值
- *
- * @remarks
- * 特性：
- * - 合并客户端级别、方法级别的请求选项
- * - 在 body 里直接传递对象
- * - 可选择使用 to() 处理返回结果为 [Error, Response]
- * - 可选择使用 withCache() 缓存请求结果
- *
- * @example
- * // 用法1：创建客户端
- * const api = fetcher("https://nickyzj.run:3030", { headers: { Authorization: "Bearer token" } });
- * const res = await api.get<Blog>("/blogs/hello-world");
- *
- * // 用法2：直接发送请求
- * const res = await fetcher().get<Blog>("https://nickyzj.run:3030/blogs/hello-world");
- *
- * // 安全处理返回结果
- * const [error, data] = await to(api.get<Blog>("/blogs/hello-world"));
- * if (error) {
- *   console.error(error);
- *   return;
- * }
- *
- * // 缓存请求结果
- * const getBlogs = withCache(api.get);
- * await getBlogs("/blogs");
- * await sleep(1000);
- * await getBlogs("/blogs");  // 不请求，使用缓存结果
- */
-export const fetcher = (baseURL = "", defaultOptions: RequestInit = {}) => {
-  const createRequest = async <T>(
-    path: string,
-    requestOptions: RequestInit = {},
-  ) => {
-    // 构建完整 URL
-    const url = baseURL ? `${baseURL}${path}` : path;
-
-    // 合并 options
-    const { parser, ...options } = mergeObjects(defaultOptions, requestOptions);
-
-    // 转换 body 为字符串
-    if (isObject(options.body)) {
-      options.body = JSON.stringify(options.body);
-      options.headers = {
-        ...options.headers,
-        "Content-Type": "application/json",
-      };
-    }
-
-    // 发送请求
-    const response = await fetch(url, options);
-    if (!response.ok) {
-      throw new Error(response.statusText);
-    }
-
-    const data = await (parser?.(response) ?? response.json());
-    return data as T;
-  };
-
-  return {
-    get: <T>(url: string, options: Omit<RequestInit, "method"> = {}) =>
-      createRequest<T>(url, { ...options, method: "GET" }),
-
-    post: <T>(
-      url: string,
-      body: any,
-      options: Omit<RequestInit, "method" | "body"> = {},
-    ) => createRequest<T>(url, { ...options, method: "POST", body }),
-
-    put: <T>(
-      url: string,
-      body: any,
-      options: Omit<RequestInit, "method" | "body"> = {},
-    ) => createRequest<T>(url, { ...options, method: "PUT", body }),
-
-    delete: <T>(
-      url: string,
-      options: Omit<RequestInit, "method" | "body"> = {},
-    ) => createRequest<T>(url, { ...options, method: "DELETE" }),
-  };
-};
-
-/**
- * Go 语言风格的异步处理方式
- * @param promise 一个能被 await 的异步函数
- * @returns 如果成功，返回 [null, 异步函数结果]，否则返回 [Error, undefined]
- *
- * @example
- * const [error, response] = await to(fetcher().get<Blog>("/blogs/hello-world"));
- */
-export const to = async <T, U = Error>(
-  promise: Promise<T>,
-): Promise<[null, T] | [U, undefined]> => {
-  try {
-    const response = await promise;
-    return [null, response];
-  } catch (error) {
-    return [error as U, undefined];
-  }
-};
+import { isObject } from "./is";
+import { mergeObjects } from "./object";
+
+export type RequestInit = BunFetchRequestInit & {
+  parser?: (response: Response) => Promise<any>;
+};
+
+/**
+ * 基于 Fetch API 的请求客户端
+ * @param baseURL 接口前缀，如 https://nickyzj.run:3030，也可以不填
+ * @param defaultOptions 客户端级别的请求选项，方法级别的选项会覆盖这里的相同值
+ *
+ * @remarks
+ * 特性：
+ * - 合并客户端级别、方法级别的请求选项
+ * - 在 body 里直接传递对象
+ * - 可选择使用 to() 处理返回结果为 [Error, Response]
+ * - 可选择使用 withCache() 缓存请求结果
+ *
+ * @example
+ * // 用法1：创建客户端
+ * const api = fetcher("https://nickyzj.run:3030", { headers: { Authorization: "Bearer token" } });
+ * const res = await api.get<Blog>("/blogs/hello-world");
+ *
+ * // 用法2：直接发送请求
+ * const res = await fetcher().get<Blog>("https://nickyzj.run:3030/blogs/hello-world");
+ *
+ * // 安全处理返回结果
+ * const [error, data] = await to(api.get<Blog>("/blogs/hello-world"));
+ * if (error) {
+ *   console.error(error);
+ *   return;
+ * }
+ *
+ * // 缓存请求结果
+ * const getBlogs = withCache(api.get);
+ * await getBlogs("/blogs");
+ * await sleep(1000);
+ * await getBlogs("/blogs");  // 不请求，使用缓存结果
+ */
+export const fetcher = (baseURL = "", defaultOptions: RequestInit = {}) => {
+  const createRequest = async <T>(
+    path: string,
+    requestOptions: RequestInit = {},
+  ) => {
+    // 构建完整 URL
+    const url = baseURL ? `${baseURL}${path}` : path;
+
+    // 合并 options
+    const { parser, ...options } = mergeObjects(defaultOptions, requestOptions);
+
+    // 转换 body 为字符串
+    if (isObject(options.body)) {
+      options.body = JSON.stringify(options.body);
+      options.headers = {
+        ...options.headers,
+        "Content-Type": "application/json",
+      };
+    }
+
+    // 发送请求
+    const response = await fetch(url, options);
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+
+    const data = await (parser?.(response) ?? response.json());
+    return data as T;
+  };
+
+  return {
+    get: <T>(url: string, options: Omit<RequestInit, "method"> = {}) =>
+      createRequest<T>(url, { ...options, method: "GET" }),
+
+    post: <T>(
+      url: string,
+      body: any,
+      options: Omit<RequestInit, "method" | "body"> = {},
+    ) => createRequest<T>(url, { ...options, method: "POST", body }),
+
+    put: <T>(
+      url: string,
+      body: any,
+      options: Omit<RequestInit, "method" | "body"> = {},
+    ) => createRequest<T>(url, { ...options, method: "PUT", body }),
+
+    delete: <T>(
+      url: string,
+      options: Omit<RequestInit, "method" | "body"> = {},
+    ) => createRequest<T>(url, { ...options, method: "DELETE" }),
+  };
+};
+
+/**
+ * Go 语言风格的异步处理方式
+ * @param promise 一个能被 await 的异步函数
+ * @returns 如果成功，返回 [null, 异步函数结果]，否则返回 [Error, undefined]
+ *
+ * @example
+ * const [error, response] = await to(fetcher().get<Blog>("/blogs/hello-world"));
+ */
+export const to = async <T, U = Error>(
+  promise: Promise<T>,
+): Promise<[null, T] | [U, undefined]> => {
+  try {
+    const response = await promise;
+    return [null, response];
+  } catch (error) {
+    return [error as U, undefined];
+  }
+};

package/src/object.ts

@@ -1,52 +1,52 @@
-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;
-};
+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;
+};

package/src/string.ts

@@ -0,0 +1,22 @@
+/**
+ * 转换下划线命名法为驼峰命名法
+ *
+ * @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()}`,
+  );
+};

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"]
+}