@nickyzj2023/utils 1.0.19 → 1.0.22

package/src/hoc.ts

@@ -1,6 +1,6 @@
 type CacheEntry = {
-  value: any;
-  expiresAt: number; // 时间戳（毫秒）
+	value: any;
+	expiresAt: number; // 时间戳（毫秒）
 };
 
 export type SetTtl = (seconds: number) => void;
@@ -40,76 +40,78 @@ export type SetTtl = (seconds: number) => void;
  * await fetchData(urlB); // 使用缓存结果
  */
 export const withCache = <Args extends any[], Result>(
-  fn: (this: { setTtl: SetTtl }, ...args: Args) => Result,
-  ttlSeconds = -1,
+	fn: (this: { setTtl: SetTtl }, ...args: Args) => Result,
+	ttlSeconds = -1,
 ) => {
-  const cache = new Map<string, CacheEntry>();
-
-  const wrapped = (...args: Args): Result => {
-    const key = JSON.stringify(args);
-    const now = Date.now();
-    const entry = cache.get(key);
-
-    // 命中缓存且未过期
-    if (entry && now < entry.expiresAt) {
-      return entry.value;
-    }
-
-    let expiresAt = ttlSeconds === -1 ? Infinity : now + ttlSeconds * 1000;
-
-    // 创建上下文，包含 setTtl 方法
-    const thisArg = {
-      setTtl: (ttl: number) => (expiresAt = now + ttl * 1000),
-    };
-
-    const result = fn.apply(thisArg, args);
-
-    // 异步函数：缓存 Promise 的 resolved 值
-    if (result instanceof Promise) {
-      const promise = result.then((resolved) => {
-        cache.set(key, {
-          value: resolved,
-          expiresAt,
-        });
-        return resolved;
-      });
-
-      // 将 promise 先塞进去避免重复请求
-      cache.set(key, {
-        value: promise,
-        expiresAt,
-      });
-
-      return promise as Result;
-    }
-
-    // 同步函数缓存
-    cache.set(key, {
-      value: result,
-      expiresAt,
-    });
-
-    return result;
-  };
-
-  /** 手动清除缓存 */
-  wrapped.clear = () => cache.clear();
-
-  /** 更新 TTL，同时刷新所有未过期缓存的时间 */
-  wrapped.updateTtl = (seconds: number) => {
-    // 更新默认 TTL
-    ttlSeconds = seconds;
-
-    // 给未过期缓存续期
-    const now = Date.now();
-    const newExpiresAt = now + seconds * 1000;
-    for (const [key, entry] of cache.entries()) {
-      if (entry.expiresAt > now) {
-        entry.expiresAt = newExpiresAt;
-        cache.set(key, entry);
-      }
-    }
-  };
-
-  return wrapped;
+	const cache = new Map<string, CacheEntry>();
+
+	const wrapped = (...args: Args): Result => {
+		const key = JSON.stringify(args);
+		const now = Date.now();
+		const entry = cache.get(key);
+
+		// 命中缓存且未过期
+		if (entry && now < entry.expiresAt) {
+			return entry.value;
+		}
+
+		let expiresAt = ttlSeconds === -1 ? Infinity : now + ttlSeconds * 1000;
+
+		// 创建上下文，包含 setTtl 方法
+		const thisArg = {
+			setTtl: (ttl: number) => {
+				expiresAt = now + ttl * 1000;
+			},
+		};
+
+		const result = fn.apply(thisArg, args);
+
+		// 异步函数：缓存 Promise 的 resolved 值
+		if (result instanceof Promise) {
+			const promise = result.then((resolved) => {
+				cache.set(key, {
+					value: resolved,
+					expiresAt,
+				});
+				return resolved;
+			});
+
+			// 将 promise 先塞进去避免重复请求
+			cache.set(key, {
+				value: promise,
+				expiresAt,
+			});
+
+			return promise as Result;
+		}
+
+		// 同步函数缓存
+		cache.set(key, {
+			value: result,
+			expiresAt,
+		});
+
+		return result;
+	};
+
+	/** 手动清除缓存 */
+	wrapped.clear = () => cache.clear();
+
+	/** 更新 TTL，同时刷新所有未过期缓存的时间 */
+	wrapped.updateTtl = (seconds: number) => {
+		// 更新默认 TTL
+		ttlSeconds = seconds;
+
+		// 给未过期缓存续期
+		const now = Date.now();
+		const newExpiresAt = now + seconds * 1000;
+		for (const [key, entry] of cache.entries()) {
+			if (entry.expiresAt > now) {
+				entry.expiresAt = newExpiresAt;
+				cache.set(key, entry);
+			}
+		}
+	};
+
+	return wrapped;
 };

package/src/is.ts

@@ -1,11 +1,18 @@
-export type Primitive = number | string | boolean | symbol | bigint | undefined | null;
+export type Primitive =
+	| number
+	| string
+	| boolean
+	| symbol
+	| bigint
+	| undefined
+	| null;
 
 /**
  * 检测传入的值是否为**普通对象**
  * @returns 如果是普通对象，返回 true，否则返回 false
  */
 export const isObject = (value: any): value is object => {
-  return value?.constructor === Object;
+	return value?.constructor === Object;
 };
 
 /**
@@ -13,9 +20,16 @@ export const isObject = (value: any): value is object => {
  * @returns 如果是原始值，返回 true，否则返回 false
  */
 export const isPrimitive = (value: any): value is Primitive => {
-  return (
-    value === null ||
-    value === undefined ||
-    (typeof value !== "object" && typeof value !== "function")
-  );
+	return (
+		value === null ||
+		value === undefined ||
+		(typeof value !== "object" && typeof value !== "function")
+	);
+};
+
+/**
+ * 检测传入的值是否为**false值**（false、0、''、null、undefined、NaN等）
+ */
+export const isFalsy = (value: any) => {
+	return !value;
 };

package/src/lru-cache.ts

@@ -8,43 +8,43 @@
  * cache.get("a");    // undefined
  */
 class LRUCache<K, V> {
-  private cache: Map<K, V>;
-  private maxSize: number;
+	private cache: Map<K, V>;
+	private maxSize: number;
 
-  constructor(maxSize = 10) {
-    this.cache = new Map();
-    this.maxSize = maxSize;
-  }
+	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;
-  }
+	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);
-  }
+	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);
-  }
+	has(key: K) {
+		return this.cache.has(key);
+	}
 }
 
 export default LRUCache;

package/src/network.ts

@@ -2,93 +2,102 @@ import { isObject } from "./is";
 import { mergeObjects } from "./object";
 
 export type RequestInit = BunFetchRequestInit & {
-  parser?: (response: Response) => Promise<any>;
+	params?: Record<string, any>;
+	parser?: (response: Response) => Promise<any>;
 };
 
 /**
  * 基于 Fetch API 的请求客户端
- * @param baseURL 接口前缀，如 https://nickyzj.run:3030，也可以不填
- * @param defaultOptions 客户端级别的请求选项，方法级别的选项会覆盖这里的相同值
+ * @param baseURL 接口前缀
+ * @param baseOptions 客户端级别的请求体，后续调用时传递相同参数会覆盖上去
  *
  * @remarks
  * 特性：
- * - 合并客户端级别、方法级别的请求选项
- * - 在 body 里直接传递对象
- * - 可选择使用 to() 处理返回结果为 [Error, Response]
+ * - 合并实例、调用时的相同请求体
+ * - 在 params 里传递对象，自动转换为 queryString
+ * - 在 body 里传递对象，自动 JSON.stringify
+ * - 可选择使用 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：直接发送请求
+ * // 用法1：直接发送请求
  * const res = await fetcher().get<Blog>("https://nickyzj.run:3030/blogs/hello-world");
  *
- * // 安全处理返回结果
+ * // 用法2：创建实例
+ * const api = fetcher("https://nickyzj.run:3030", { headers: { Authorization: "Bearer token" } });
+ * const res = await api.get<Blog>("/blogs/hello-world", { headers: {...}, params: { page: 1 } });  // 与实例相同的 headers 会覆盖上去，params 会转成 ?page=1 跟到 url 后面
+ *
+ * // 安全处理请求结果
  * const [error, data] = await to(api.get<Blog>("/blogs/hello-world"));
  * if (error) {
  *   console.error(error);
  *   return;
  * }
+ * console.log(data);
  *
  * // 缓存请求结果
  * const getBlogs = withCache(api.get);
  * await getBlogs("/blogs");
- * await sleep(1000);
- * await getBlogs("/blogs");  // 不请求，使用缓存结果
+ * await sleep();
+ * await getBlogs("/blogs");  // 不发请求，使用缓存
  */
-export const fetcher = (baseURL = "", defaultOptions: RequestInit = {}) => {
-  const createRequest = async <T>(
-    path: string,
-    requestOptions: RequestInit = {},
-  ) => {
-    // 构建完整 URL
-    const url = baseURL ? `${baseURL}${path}` : path;
+export const fetcher = (baseURL = "", baseOptions: RequestInit = {}) => {
+	const myFetch = async <T>(path: string, requestOptions: RequestInit = {}) => {
+		// 构建完整 URL
+		const url = new URL(baseURL ? `${baseURL}${path}` : path);
+
+		// 合并 options
+		const { params, parser, ...options } = mergeObjects(
+			baseOptions,
+			requestOptions,
+		);
 
-    // 合并 options
-    const { parser, ...options } = mergeObjects(defaultOptions, requestOptions);
+		// 转换 params 为查询字符串
+		if (isObject(params)) {
+			Object.entries(params).forEach(([key, value]) => {
+				url.searchParams.append(key, value.toString());
+			});
+		}
 
-    // 转换 body 为字符串
-    if (isObject(options.body)) {
-      options.body = JSON.stringify(options.body);
-      options.headers = {
-        ...options.headers,
-        "Content-Type": "application/json",
-      };
-    }
+		// 转换 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 response = await fetch(url, options);
+		if (!response.ok) {
+			throw new Error(response.statusText);
+		}
 
-    const data = await (parser?.(response) ?? response.json());
-    return data as T;
-  };
+		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" }),
+	return {
+		get: <T>(url: string, options?: Omit<RequestInit, "method">) =>
+			myFetch<T>(url, { ...options, method: "GET" }),
 
-    post: <T>(
-      url: string,
-      body: any,
-      options: Omit<RequestInit, "method" | "body"> = {},
-    ) => createRequest<T>(url, { ...options, method: "POST", body }),
+		post: <T>(
+			url: string,
+			body: any,
+			options?: Omit<RequestInit, "method" | "body">,
+		) => myFetch<T>(url, { ...options, method: "POST", body }),
 
-    put: <T>(
-      url: string,
-      body: any,
-      options: Omit<RequestInit, "method" | "body"> = {},
-    ) => createRequest<T>(url, { ...options, method: "PUT", body }),
+		put: <T>(
+			url: string,
+			body: any,
+			options?: Omit<RequestInit, "method" | "body">,
+		) => myFetch<T>(url, { ...options, method: "PUT", body }),
 
-    delete: <T>(
-      url: string,
-      options: Omit<RequestInit, "method" | "body"> = {},
-    ) => createRequest<T>(url, { ...options, method: "DELETE" }),
-  };
+		delete: <T>(url: string, options?: Omit<RequestInit, "method" | "body">) =>
+			myFetch<T>(url, { ...options, method: "DELETE" }),
+	};
 };
 
 /**
@@ -100,12 +109,12 @@ export const fetcher = (baseURL = "", defaultOptions: RequestInit = {}) => {
  * const [error, response] = await to(fetcher().get<Blog>("/blogs/hello-world"));
  */
 export const to = async <T, U = Error>(
-  promise: Promise<T>,
+	promise: Promise<T>,
 ): Promise<[null, T] | [U, undefined]> => {
-  try {
-    const response = await promise;
-    return [null, response];
-  } catch (error) {
-    return [error as U, undefined];
-  }
+	try {
+		const response = await promise;
+		return [null, response];
+	} catch (error) {
+		return [error as U, undefined];
+	}
 };