@nickyzj2023/utils 1.0.8 → 1.0.10

package/package.json

@@ -1,22 +1,22 @@
-{
-  "name": "@nickyzj2023/utils",
-  "version": "1.0.8",
-  "type": "module",
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "scripts": {
-    "docs": "typedoc src/index.ts",
-    "build": "bun build --target=bun --outdir ./dist --minify ./src/index.ts && tsc && bun run docs"
-  },
-  "devDependencies": {
-    "@types/bun": "latest",
-    "typedoc": "^0.28.14"
-  },
-  "peerDependencies": {
-    "typescript": "^5"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/Nickyzj628/utils.git"
-  }
-}
+{
+  "name": "@nickyzj2023/utils",
+  "version": "1.0.10",
+  "type": "module",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "docs": "typedoc src/index.ts",
+    "build": "bun build --target=bun --outdir ./dist --minify ./src/index.ts && tsc && bun run docs"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typedoc": "^0.28.14"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Nickyzj628/utils.git"
+  }
+}

package/src/dom.ts

@@ -1,10 +1,10 @@
-/**
- * 附带时间的 console.log
- * @param args
- *
- * @example
- * timeLog("Hello", "World"); // 14:30:00 Hello World
- */
-export const timeLog = (...args: any[]) => {
-  console.log(`${new Date().toLocaleTimeString()}`, ...args);
-};
+/**
+ * 附带时间的 console.log
+ * @param args
+ *
+ * @example
+ * timeLog("Hello", "World"); // 14:30:00 Hello World
+ */
+export const timeLog = (...args: any[]) => {
+  console.log(`${new Date().toLocaleTimeString()}`, ...args);
+};

package/src/hoc.ts

@@ -0,0 +1,109 @@
+type SetTtl = (seconds: number) => void;
+
+type CacheEntry = {
+  value: any;
+  expiresAt: number; // 时间戳（毫秒）
+};
+
+/**
+ * 创建一个带缓存的高阶函数
+ *
+ * @template Args 被包装函数的参数类型数组
+ * @template Result 被包装函数的返回类型
+ *
+ * @param fn 需要被缓存的函数，参数里附带的 setTtl 方法用于根据具体情况改写过期时间
+ * @param ttlSeconds 以秒为单位的过期时间，-1 表示永不过期，默认 -1，会被回调函数里的 setTtl() 覆盖
+ *
+ * @returns 返回包装后的函数，以及缓存相关的额外方法
+ *
+ * @example
+ * // 异步函数示例
+ * const fetchData = withCache(async (setTtl, url: string) => {
+ *   const data = await fetch(url).then((res) => res.json());
+ *   setTtl(data.expiresIn);  // 根据实际情况调整过期时间
+ *   return data;
+ * });
+ *
+ * await fetchData(urlA);
+ * await fetchData(urlA); // 使用缓存结果
+
+ * await fetchData(urlB);
+ * await fetchData(urlB); // 使用缓存结果
+ *
+ * fetchData.clear(); // urlA 和 urlB 的缓存都被清除
+ * await fetchData(urlA); // 重新请求数据
+ * await fetchData(urlB); // 重新请求数据
+ *
+ * // 缓存过期前
+ * fetchData.updateTtl(180);  // 更新 ttl 并为所有未过期缓存续期
+ * await fetchData(urlA); // 使用缓存结果
+ * await fetchData(urlB); // 使用缓存结果
+ */
+export const withCache = <Args extends any[], Result>(
+  fn: (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;
+    }
+
+    const setTtl: SetTtl = (seconds) => (ttlSeconds = seconds);
+    const result = fn(setTtl, ...args);
+
+    // 异步函数：缓存 Promise 的 resolved 值
+    if (result instanceof Promise) {
+      const promise = result.then((resolved) => {
+        cache.set(key, {
+          value: resolved,
+          expiresAt: Date.now() + ttlSeconds * 1000,
+        });
+        return resolved;
+      });
+
+      // 将 promise 先塞进去避免重复请求
+      cache.set(key, {
+        value: promise,
+        expiresAt: now + ttlSeconds * 1000,
+      });
+
+      return promise as Result;
+    }
+
+    // 同步函数缓存
+    cache.set(key, {
+      value: result,
+      expiresAt: now + ttlSeconds * 1000,
+    });
+
+    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/index.ts

@@ -1,3 +1,4 @@
-export * from "./dom";
-export * from "./is";
-export * from "./network";
+export * from "./dom";
+export * from "./hoc";
+export * from "./is";
+export * from "./network";

package/src/is.ts

@@ -1,8 +1,8 @@
-/**
- * 检测传入的值是否为**普通对象**
- * @param value
- * @returns {Boolean} 如果是普通对象，返回 true，否则返回 false
- */
-export const isObject = (value: any): value is object => {
-  return value?.constructor === Object;
-};
+/**
+ * 检测传入的值是否为**普通对象**
+ * @param value
+ * @returns {Boolean} 如果是普通对象，返回 true，否则返回 false
+ */
+export const isObject = (value: any): value is object => {
+  return value?.constructor === Object;
+};

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,100 +1,101 @@
-import { isObject } from "./is";
-import LRUCache from "./lru-cache";
-
-const cachedRequests = new LRUCache<string, Promise<Response>>();
-
-/**
- * 基于 Fetch API 的请求客户端
- * @param baseURL 接口前缀，如 https://nickyzj.run:3030，也可以不填
- *
- * @remarks
- * 特性：
- * - 在 body 里直接传递对象
- * - 能够缓存 GET 请求
- *
- * @example
- * // 用法1：创建客户端
- * const api = fetcher("https://nickyzj.run:3030");
- * const res = await api.get<Blog>("/blogs/hello-world");
- *
- * // 用法2：直接发送请求
- * const res = await fetcher().get<Blog>("https://nickyzj.run:3030/blogs/hello-world");
- */
-export const fetcher = (baseURL = "") => {
-  const createRequest = async <T>(path: string, options: RequestInit = {}) => {
-    // 构建完整 URL
-    const url = baseURL ? `${baseURL}${path}` : path;
-
-    // 处理 body 为对象的情况
-    if (isObject(options.body)) {
-      options.body = JSON.stringify(options.body);
-      options.headers = {
-        ...options.headers,
-        "Content-Type": "application/json",
-      };
-    }
-
-    const request = () => fetch(url, options);
-    let promise: Promise<Response>;
-
-    const canCache = options.method === "GET" || !options.method;
-    if (!canCache) {
-      promise = request();
-    } else {
-      let tempPromise = cachedRequests.get(url);
-      if (!tempPromise) {
-        tempPromise = request();
-        cachedRequests.set(url, tempPromise);
-      }
-      promise = tempPromise;
-    }
-
-    // 必须使用 clone() 消费一个新的响应体，否则下次从 cache 中获取的响应体会报错（无法被重复消费）
-    const response = (await promise).clone();
-    if (!response.ok) {
-      throw new Error(response.statusText);
-    }
-
-    const data = await 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"> = {}) =>
-      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 LRUCache from "./lru-cache";
+
+const cachedRequests = new LRUCache<string, Promise<Response>>();
+
+/**
+ * 基于 Fetch API 的请求客户端
+ * @param baseURL 接口前缀，如 https://nickyzj.run:3030，也可以不填
+ * @param defaultOptions 客户端级别的请求选项，方法级别的选项会覆盖这里的相同值
+ *
+ * @remarks
+ * 特性：
+ * - 在 body 里直接传递对象
+ * - 能够缓存 GET 请求
+ *
+ * @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");
+ */
+export const fetcher = (baseURL = "", defaultOptions: RequestInit = {}) => {
+  const createRequest = async <T>(path: string, options: RequestInit = {}) => {
+    // 构建完整 URL
+    const url = baseURL ? `${baseURL}${path}` : path;
+
+    // 处理 body 为对象的情况
+    if (isObject(options.body)) {
+      options.body = JSON.stringify(options.body);
+      options.headers = {
+        ...defaultOptions.headers,
+        ...options.headers,
+        "Content-Type": "application/json",
+      };
+    }
+
+    const request = () => fetch(url, options);
+    const canCache = options.method === "GET" || !options.method;
+    let promise: Promise<Response>;
+    if (!canCache) {
+      promise = request();
+    } else {
+      let tempPromise = cachedRequests.get(url);
+      if (!tempPromise) {
+        tempPromise = request();
+        cachedRequests.set(url, tempPromise);
+      }
+      promise = tempPromise;
+    }
+
+    // 必须使用 clone() 消费一个新的响应体，否则下次从 cache 中获取的响应体会报错（无法被重复消费）
+    const response = (await promise).clone();
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+
+    const data = await 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"> = {}) =>
+      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/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"]
+}