@nickyzj2023/utils 1.0.47 → 1.0.48

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@nickyzj2023/utils",
-  "version": "1.0.47",
+  "version": "1.0.48",
   "repository": {
     "type": "git",
     "url": "https://github.com/Nickyzj628/utils.git"
   },
+  "type": "module",
   "module": "dist/index.js",
+  "types": "dist/index.d.ts",
   "devDependencies": {
     "@biomejs/biome": "^2.3.14",
     "@types/bun": "^1.3.8",
@@ -18,7 +20,5 @@
   "scripts": {
     "docs": "typedoc src/index.ts --plugin typedoc-material-theme",
     "build": "bun build --target=bun --outdir ./dist --minify ./src/index.ts --packages external && tsc"
-  },
-  "type": "module",
-  "types": "dist/index.d.ts"
+  }
 }

package/src/{network.ts → network/fetcher.ts}

@@ -1,5 +1,5 @@
-import { isNil, isObject } from "./is";
-import { mergeObjects } from "./object";
+import { isNil, isObject } from "../is";
+import { mergeObjects } from "../object";
 
 // Bun 特有的 fetch 选项
 type BunFetchOptions = {
@@ -121,38 +121,3 @@ export const fetcher = (baseURL = "", baseOptions: RequestInit = {}) => {
 			myFetch<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, E = Error>(
-	promise: Promise<T>,
-): Promise<[null, T] | [E, undefined]> => {
-	try {
-		return [null, await promise];
-	} catch (e) {
-		return [e as E, undefined];
-	}
-};
-
-/** 从 url 响应头获取真实链接 */
-export const getRealURL = async (originURL: string) => {
-	const [error, response] = await to(
-		fetch(originURL, {
-			method: "HEAD", // 用 HEAD 减少数据传输
-			redirect: "manual", // 手动处理重定向
-		}),
-	);
-
-	if (error) {
-		return originURL;
-	}
-
-	const location = response.headers.get("location");
-	return location || originURL;
-};

package/src/network/getRealURL.ts

@@ -0,0 +1,18 @@
+import { to } from "./to";
+
+/** 从 url 响应头获取真实链接 */
+export const getRealURL = async (originURL: string) => {
+	const [error, response] = await to(
+		fetch(originURL, {
+			method: "HEAD", // 用 HEAD 减少数据传输
+			redirect: "manual", // 手动处理重定向
+		}),
+	);
+
+	if (error) {
+		return originURL;
+	}
+
+	const location = response.headers.get("location");
+	return location || originURL;
+};

package/src/network/image.ts

@@ -0,0 +1,202 @@
+/**
+ * 将 ArrayBuffer 转换为 base64 字符串
+ * 兼容浏览器、Bun 和 Node.js
+ */
+const arrayBufferToBase64 = (buffer: ArrayBuffer): string => {
+	const bytes = new Uint8Array(buffer);
+	let binary = "";
+	for (let i = 0; i < bytes.byteLength; i++) {
+		binary += String.fromCharCode(bytes[i]!);
+	}
+	return btoa(binary);
+};
+
+/**
+ * 尝试动态导入 sharp 模块
+ * 用于检测用户项目中是否安装了 sharp
+ */
+const tryImportSharp = async () => {
+	try {
+		// 动态导入 sharp，避免在浏览器环境中报错
+		// 使用 new Function 避免 TypeScript 编译时解析该模块（sharp 是可选依赖）
+		const dynamicImport = new Function(
+			"modulePath",
+			"return import(modulePath)",
+		);
+		const sharpModule = await dynamicImport("sharp");
+		return sharpModule.default || sharpModule;
+	} catch {
+		return null;
+	}
+};
+
+/**
+ * 使用 sharp 压缩图片
+ */
+const compressWithSharp = async (
+	sharp: any,
+	arrayBuffer: ArrayBuffer,
+	mime: string,
+	quality: number,
+): Promise<string> => {
+	const buffer = Buffer.from(arrayBuffer);
+	let sharpInstance = sharp(buffer);
+
+	// 根据 MIME 类型设置压缩选项
+	if (mime === "image/jpeg") {
+		sharpInstance = sharpInstance.jpeg({ quality: Math.round(quality * 100) });
+	} else if (mime === "image/png") {
+		// PNG 使用 compressionLevel (0-9)，将 quality (0-1) 映射到 compressionLevel
+		const compressionLevel = Math.round((1 - quality) * 9);
+		sharpInstance = sharpInstance.png({ compressionLevel });
+	}
+
+	const compressedBuffer = await sharpInstance.toBuffer();
+	return `data:${mime};base64,${compressedBuffer.toString("base64")}`;
+};
+
+/**
+ * 图片压缩选项
+ */
+export type ImageCompressionOptions = {
+	/** 压缩比率，默认 0.92 */
+	quality?: number;
+	/**
+	 * 自定义压缩函数，用于覆盖默认压缩行为
+	 * @param arrayBuffer 图片的 ArrayBuffer 数据
+	 * @param mime 图片的 MIME 类型
+	 * @param quality 压缩质量
+	 * @returns 压缩后的 base64 字符串
+	 */
+	compressor?: (
+		arrayBuffer: ArrayBuffer,
+		mime: string,
+		quality: number,
+	) => Promise<string> | string;
+	/**
+	 * 自定义 fetch 函数，用于使用自己封装的请求库读取图片
+	 * 必须返回符合 Web 标准的 Response 对象
+	 * @param url 图片地址
+	 * @returns Promise<Response>
+	 */
+	fetcher?: (url: string) => Promise<Response>;
+};
+
+/**
+ * 图片地址转 base64 数据
+ *
+ * @param imageUrl 图片地址
+ * @param options 可选配置
+ * @param options.quality 压缩比率，默认 0.92
+ * @param options.compressor 自定义压缩函数，用于覆盖默认压缩行为
+ *
+ * @example
+ * // 基本用法（浏览器自动使用 Canvas 压缩，Node.js/Bun 自动检测并使用 sharp）
+ * imageUrlToBase64("https://example.com/image.jpg");
+ *
+ * @example
+ * // 使用自定义 fetch 函数（如 axios 封装）
+ * imageUrlToBase64("https://example.com/image.jpg", {
+ *   fetcher: async (url) => {
+ *     // 使用 axios 或其他请求库，但必须返回 Response 对象
+ *     const response = await axios.get(url, { responseType: 'arraybuffer' });
+ *     return new Response(response.data, {
+ *       status: response.status,
+ *       statusText: response.statusText,
+ *       headers: response.headers
+ *     });
+ *   }
+ * });
+ *
+ * @example
+ * // 使用自定义压缩函数覆盖默认行为
+ * imageUrlToBase64("https://example.com/image.jpg", {
+ *   quality: 0.8,
+ *   compressor: async (buffer, mime, quality) => {
+ *     // 自定义压缩逻辑
+ *     return `data:${mime};base64,...`;
+ *   }
+ * });
+ */
+export const imageUrlToBase64 = async (
+	imageUrl: string,
+	options: ImageCompressionOptions = {},
+): Promise<string> => {
+	const { quality = 0.92, compressor, fetcher = fetch } = options;
+
+	if (!imageUrl.startsWith("http")) {
+		throw new Error("图片地址必须以http或https开头");
+	}
+
+	// 使用自定义 fetch 获取图片数据
+	const response = await fetcher(imageUrl);
+	if (!response.ok) {
+		throw new Error(`获取图片失败: ${response.statusText}`);
+	}
+
+	const mime = response.headers.get("Content-Type") || "image/jpeg";
+	const arrayBuffer = await response.arrayBuffer();
+
+	// 对于非 JPEG/PNG 图片，直接返回 base64，不做压缩
+	if (mime !== "image/jpeg" && mime !== "image/png") {
+		const base64 = arrayBufferToBase64(arrayBuffer);
+		return `data:${mime};base64,${base64}`;
+	}
+
+	// 如果提供了自定义压缩函数，优先使用它
+	if (compressor) {
+		return await compressor(arrayBuffer, mime, quality);
+	}
+
+	// 浏览器环境：使用 OffscreenCanvas 压缩
+	if (typeof OffscreenCanvas !== "undefined") {
+		let bitmap: ImageBitmap | null = null;
+
+		try {
+			const blob = new Blob([arrayBuffer], { type: mime });
+			bitmap = await createImageBitmap(blob);
+
+			const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
+			const ctx = canvas.getContext("2d");
+			if (!ctx) {
+				throw new Error("无法获取 OffscreenCanvas context");
+			}
+
+			ctx.drawImage(bitmap, 0, 0);
+			bitmap.close();
+			bitmap = null;
+
+			// OffscreenCanvas 使用 convertToBlob 获取压缩后的图片
+			const compressedBlob = await canvas.convertToBlob({
+				type: mime,
+				quality: quality,
+			});
+
+			// 将 Blob 转换为 base64
+			const compressedArrayBuffer = await compressedBlob.arrayBuffer();
+			const base64 = arrayBufferToBase64(compressedArrayBuffer);
+			return `data:${mime};base64,${base64}`;
+		} catch {
+			// OffscreenCanvas 压缩失败，返回原始 base64
+			bitmap?.close();
+			const base64 = arrayBufferToBase64(arrayBuffer);
+			return `data:${mime};base64,${base64}`;
+		}
+	}
+
+	// Node.js/Bun 环境：尝试使用 sharp 进行压缩
+	const sharp = await tryImportSharp();
+	if (sharp) {
+		try {
+			return await compressWithSharp(sharp, arrayBuffer, mime, quality);
+		} catch {
+			// sharp 压缩失败，返回原始 base64
+			const base64 = arrayBufferToBase64(arrayBuffer);
+			return `data:${mime};base64,${base64}`;
+		}
+	}
+
+	// 没有可用的压缩方式，直接返回原始 base64
+	const base64 = arrayBufferToBase64(arrayBuffer);
+	return `data:${mime};base64,${base64}`;
+};

package/src/network/index.ts

@@ -0,0 +1,4 @@
+export { fetcher, type RequestInit } from "./fetcher";
+export { getRealURL } from "./getRealURL";
+export { type ImageCompressionOptions, imageUrlToBase64 } from "./image";
+export { to } from "./to";

package/src/network/to.ts

@@ -0,0 +1,17 @@
+/**
+ * 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, E = Error>(
+	promise: Promise<T>,
+): Promise<[null, T] | [E, undefined]> => {
+	try {
+		return [null, await promise];
+	} catch (e) {
+		return [e as E, undefined];
+	}
+};

package/src/string/case.ts

@@ -0,0 +1,71 @@
+export type SnakeToCamel<S extends string> =
+	S extends `${infer Before}_${infer After}`
+		? After extends `${infer First}${infer Rest}`
+			? `${Before}${Uppercase<First>}${SnakeToCamel<Rest>}`
+			: Before
+		: S;
+
+/**
+ * 下划线命名法转为驼峰命名法
+ *
+ * @example
+ * snakeToCamel("user_name") // "userName"
+ */
+export const snakeToCamel = <S extends string>(str: S): SnakeToCamel<S> => {
+	return str.replace(/_([a-zA-Z])/g, (match, pattern) =>
+		pattern.toUpperCase(),
+	) as SnakeToCamel<S>;
+};
+
+export type CamelToSnake<S extends string> =
+	S extends `${infer First}${infer Rest}`
+		? Rest extends Uncapitalize<Rest>
+			? `${Lowercase<First>}${CamelToSnake<Rest>}`
+			: `${Lowercase<First>}_${CamelToSnake<Rest>}`
+		: Lowercase<S>;
+
+/**
+ * 驼峰命名法转为下划线命名法
+ *
+ * @example
+ * camelToSnake("shouldComponentUpdate") // "should_component_update"
+ */
+export const camelToSnake = <S extends string>(str: S): CamelToSnake<S> => {
+	return str.replace(
+		/([A-Z])/g,
+		(match, pattern) => `_${pattern.toLowerCase()}`,
+	) as CamelToSnake<S>;
+};
+
+export type Capitalize<S extends string> = S extends `${infer P1}${infer Rest}`
+	? P1 extends Capitalize<P1>
+		? S
+		: `${Uppercase<P1>}${Rest}`
+	: S;
+
+/**
+ * 字符串首字母大写
+ *
+ * @example
+ * capitalize("hello") // "Hello"
+ */
+export const capitalize = <S extends string>(s: S): Capitalize<S> => {
+	return (s.charAt(0).toUpperCase() + s.slice(1)) as Capitalize<S>;
+};
+
+export type Decapitalize<S extends string> =
+	S extends `${infer P1}${infer Rest}`
+		? P1 extends Lowercase<P1>
+			? P1
+			: `${Lowercase<P1>}${Rest}`
+		: S;
+
+/**
+ * 字符串首字母小写
+ *
+ * @example
+ * decapitalize("Hello") // "hello"
+ */
+export const decapitalize = <S extends string>(s: S): Decapitalize<S> => {
+	return (s.charAt(0).toLowerCase() + s.slice(1)) as Decapitalize<S>;
+};

package/src/string/compact.ts

@@ -0,0 +1,56 @@
+/**
+ * 将字符串压缩为单行精简格式
+ *
+ * @example
+ * // "Hello, world."
+ * compactStr(`
+ *   Hello,
+ *        world!
+ * `, {
+ *  disableNewLineReplace: false,
+ * });
+ */
+export const compactStr = (
+	text: string = "",
+	options?: {
+		/** 最大保留长度，设为 0 或 Infinity 则不截断，默认 Infinity */
+		maxLength?: number;
+		/** 是否将换行符替换为字面量 \n，默认开启 */
+		disableNewLineReplace?: boolean;
+		/** 是否合并连续的空格/制表符为一个空格，默认开启 */
+		disableWhitespaceCollapse?: boolean;
+		/** 截断后的后缀，默认为 "..." */
+		omission?: string;
+	},
+): string => {
+	if (!text) return "";
+
+	const {
+		maxLength = Infinity,
+		disableNewLineReplace = false,
+		disableWhitespaceCollapse = false,
+		omission = "...",
+	} = options ?? {};
+
+	let result = text;
+
+	// 处理换行符
+	if (!disableNewLineReplace) {
+		result = result.replace(/\r?\n/g, "\\n");
+	} else {
+		result = result.replace(/\r?\n/g, " ");
+	}
+
+	// 合并连续空格
+	if (!disableWhitespaceCollapse) {
+		result = result.replace(/\s+/g, " ");
+	}
+	result = result.trim();
+
+	// 截断多出来的文字
+	if (maxLength > 0 && result.length > maxLength) {
+		return result.slice(0, maxLength) + omission;
+	}
+
+	return result;
+};

package/src/string/index.ts

@@ -0,0 +1,12 @@
+export {
+	type CamelToSnake,
+	type Capitalize,
+	camelToSnake,
+	capitalize,
+	type Decapitalize,
+	decapitalize,
+	type SnakeToCamel,
+	snakeToCamel,
+} from "./case";
+
+export { compactStr } from "./compact";

package/dist/dom.d.ts

@@ -1,8 +0,0 @@
-/**
- * 附带时间的 console.log
- * @param args
- *
- * @example
- * timeLog("Hello", "World"); // 14:30:00 Hello World
- */
-export declare const timeLog: (...args: any[]) => void;

package/dist/function.d.ts

@@ -1,22 +0,0 @@
-/**
- * 循环执行函数，直到符合停止条件
- *
- * @example
- * // 循环请求大语言模型，直到其不再调用工具
- * loopUntil(
- *   async () => {
- *     const completion = await chatCompletions();
- *     completion.tool_calls?.forEach(chooseAndHandleTool)
- *     return completion;
- *   },
- *   {
- *     shouldStop: (completion) => !completion.tool_calls,
- *   },
- * ),
- */
-export declare const loopUntil: <T>(fn: (count: number) => Promise<T>, options?: {
-    /** 最大循环次数，默认 5 次 */
-    maxRetries?: number;
-    /** 停止循环条件，默认立即停止 */
-    shouldStop?: (result: T) => boolean;
-}) => Promise<T>;

package/dist/hoc.d.ts

@@ -1,42 +0,0 @@
-export type SetTtl = (seconds: number) => void;
-/**
- * 创建一个带缓存的高阶函数
- *
- * @template Args 被包装函数的参数类型数组
- * @template Result 被包装函数的返回类型
- *
- * @param fn 需要被缓存的函数，参数里附带的 setTtl 方法用于根据具体情况改写过期时间
- * @param ttlSeconds 以秒为单位的过期时间，-1 表示永不过期，默认 -1，会被回调函数里的 setTtl() 覆盖
- *
- * @returns 返回包装后的函数，以及缓存相关的额外方法
- *
- * @example
- * // 异步函数示例
- * const fetchData = withCache(async function (url: string) {
- *   const data = await fetch(url).then((res) => res.json());
- *   this.setTtl(data.expiresIn); // 根据实际情况调整过期时间
- *   return data;
- * });
- *
- * await fetchData(urlA);
- * await fetchData(urlA); // 使用缓存结果
- * await fetchData(urlB);
- * await fetchData(urlB); // 使用缓存结果
- *
- * fetchData.clear(); // 清除缓存
- * await fetchData(urlA); // 重新请求
- * await fetchData(urlB); // 重新请求
- *
- * // 缓存过期前
- * await sleep();
- * fetchData.updateTtl(180);  // 更新 ttl 并为所有未过期的缓存续期
- * await fetchData(urlA); // 使用缓存结果
- * await fetchData(urlB); // 使用缓存结果
- */
-export declare const withCache: <Args extends any[], Result>(fn: (this: {
-    setTtl: SetTtl;
-}, ...args: Args) => Result, ttlSeconds?: number) => {
-    (...args: Args): Result;
-    clear(): void;
-    updateTtl(seconds: number): void;
-};

package/dist/index.d.ts

@@ -1,9 +0,0 @@
-export * from "./dom";
-export * from "./function";
-export * from "./hoc";
-export * from "./is";
-export * from "./network";
-export * from "./number";
-export * from "./object";
-export * from "./string";
-export * from "./time";

package/dist/index.js

@@ -1,2 +0,0 @@
-// @bun
-var A=(...I)=>{console.log(`${new Date().toLocaleTimeString()}`,...I)};var B=async(I,$)=>{let{maxRetries:M=5,shouldStop:W=()=>!0}=$??{};for(let z=0;z<M;z++){let H=await I(z);if(W(H))return H}throw Error(`\u8D85\u8FC7\u4E86\u6700\u5927\u5FAA\u73AF\u6B21\u6570\uFF08${M}\uFF09\u4E14\u672A\u6EE1\u8DB3\u505C\u6B62\u6267\u884C\u6761\u4EF6`)};var O=(I,$=-1)=>{let M=new Map,W=(...z)=>{let H=JSON.stringify(z),D=Date.now(),J=M.get(H);if(J&&D<J.expiresAt)return J.value;let G=$===-1?1/0:D+$*1000,Q={setTtl:(X)=>{G=D+X*1000}},_=I.apply(Q,z);if(_ instanceof Promise){let X=_.then((C)=>{return M.set(H,{value:C,expiresAt:G}),C});return M.set(H,{value:X,expiresAt:G}),X}return M.set(H,{value:_,expiresAt:G}),_};return W.clear=()=>M.clear(),W.updateTtl=(z)=>{$=z;let H=Date.now(),D=H+z*1000;for(let[J,G]of M.entries())if(G.expiresAt>H)G.expiresAt=D,M.set(J,G)},W};var Z=(I)=>{return I?.constructor===Object},P=(I)=>{return I===null||I===void 0||typeof I!=="object"&&typeof I!=="function"},V=(I)=>{return!I},N=(I)=>{return!!I},q=(I)=>{return I===null||I===void 0};var E=(I,$)=>{let M={...I};for(let W of Object.keys($)){let z=M[W],H=$[W];if(P(z)&&P(H)){M[W]=H;continue}if(Array.isArray(z)&&Array.isArray(H)){M[W]=z.concat(H);continue}if(Z(z)&&Z(H)){M[W]=E(z,H);continue}M[W]=H}return M},F=(I,$)=>{if(Array.isArray(I))return I.map((M)=>F(M,$));if(Z(I))return Object.keys(I).reduce((W,z)=>{let H=$(z),D=I[z];return W[H]=F(D,$),W},{});return I},T=(I,$,M)=>{let{filter:W}=M??{};if(Array.isArray(I)){let z=I.map((H,D)=>{if(Z(H))return T(H,$,M);return $(H,D)});if(W)return z.filter((H,D)=>W(H,D));return z}if(Z(I))return Object.keys(I).reduce((H,D)=>{let J=I[D],G;if(Z(J)||Array.isArray(J))G=T(J,$,M);else G=$(J,D);if(!W||W(G,D))H[D]=G;return H},{});return I};var d=(I="",$={})=>{let M=async(W,z={})=>{let H=new URL(I?`${I}${W}`:W),{params:D,parser:J,...G}=E($,z);if(Z(D))Object.entries(D).forEach(([X,C])=>{if(q(C))return;H.searchParams.append(X,C.toString())});if(Z(G.body))G.body=JSON.stringify(G.body),G.headers={...G.headers,"Content-Type":"application/json"};let Q=await fetch(H,G);if(!Q.ok){if(Q.headers.get("Content-Type")?.startsWith("application/json"))throw await Q.json();throw Error(Q.statusText)}return await(J?.(Q)??Q.json())};return{get:(W,z)=>M(W,{...z,method:"GET"}),post:(W,z,H)=>M(W,{...H,method:"POST",body:z}),put:(W,z,H)=>M(W,{...H,method:"PUT",body:z}),delete:(W,z)=>M(W,{...z,method:"DELETE"})}},K=async(I)=>{try{return[null,await I]}catch($){return[$,void 0]}},j=async(I)=>{let[$,M]=await K(fetch(I,{method:"HEAD",redirect:"manual"}));if($)return I;return M.headers.get("location")||I};var v=(I,$)=>{return Math.floor(Math.random()*($-I+1))+I};var b=(I)=>{return I.replace(/_([a-zA-Z])/g,($,M)=>M.toUpperCase())},y=(I)=>{return I.replace(/([A-Z])/g,($,M)=>`_${M.toLowerCase()}`)},p=(I)=>{return I.charAt(0).toUpperCase()+I.slice(1)},n=(I)=>{return I.charAt(0).toLowerCase()+I.slice(1)},Y=(I)=>{let $=new Uint8Array(I),M="";for(let W=0;W<$.byteLength;W++)M+=String.fromCharCode($[W]);return btoa(M)},u=async(I,$={})=>{let{quality:M=0.92,compressor:W}=$;if(!I.startsWith("http"))throw Error("\u56FE\u7247\u5730\u5740\u5FC5\u987B\u4EE5http\u6216https\u5F00\u5934");let z=await fetch(I);if(!z.ok)throw Error(`\u83B7\u53D6\u56FE\u7247\u5931\u8D25: ${z.statusText}`);let H=z.headers.get("Content-Type")||"image/jpeg",D=await z.arrayBuffer();if(H!=="image/jpeg"&&H!=="image/png"){let G=Y(D);return`data:${H};base64,${G}`}if(W)return await W(D,H,M);if(typeof OffscreenCanvas<"u"){let G=null;try{let Q=new Blob([D],{type:H});G=await createImageBitmap(Q);let _=new OffscreenCanvas(G.width,G.height),X=_.getContext("2d");if(!X)throw Error("\u65E0\u6CD5\u83B7\u53D6 canvas context");X.drawImage(G,0,0),G.close(),G=null;let x=await(await _.convertToBlob({type:H,quality:M})).arrayBuffer(),S=Y(x);return`data:${H};base64,${S}`}catch{G?.close();let Q=Y(D);return`data:${H};base64,${Q}`}}let J=Y(D);return`data:${H};base64,${J}`},o=(I="",$)=>{if(!I)return"";let{maxLength:M=1/0,disableNewLineReplace:W=!1,disableWhitespaceCollapse:z=!1,omission:H="..."}=$??{},D=I;if(!W)D=D.replace(/\r?\n/g,"\\n");else D=D.replace(/\r?\n/g," ");if(!z)D=D.replace(/\s+/g," ");if(D=D.trim(),M>0&&D.length>M)return D.slice(0,M)+H;return D};var i=async(I=150)=>{return new Promise(($)=>{setTimeout($,I)})},r=(I,$=300)=>{let M=null;return(...W)=>{if(M)clearTimeout(M);M=setTimeout(()=>{I(...W)},$)}},a=(I,$=300)=>{let M=null;return function(...W){if(!M)M=setTimeout(()=>{M=null,I.apply(this,W)},$)}};export{O as withCache,K as to,A as timeLog,a as throttle,b as snakeToCamel,i as sleep,v as randomInt,E as mergeObjects,T as mapValues,F as mapKeys,B as loopUntil,N as isTruthy,P as isPrimitive,Z as isObject,q as isNil,V as isFalsy,u as imageUrlToBase64,j as getRealURL,d as fetcher,n as decapitalize,r as debounce,o as compactStr,p as capitalize,y as camelToSnake};

package/dist/is.d.ts

@@ -1,43 +0,0 @@
-export type Primitive = number | string | boolean | symbol | bigint | undefined | null;
-export type Falsy = false | 0 | -0 | 0n | "" | null | undefined;
-/**
- * 检测传入的值是否为**普通对象**
- *
- * @example
- * const obj = { a: 1 };
- * isObject(obj); // true
- */
-export declare const isObject: (value: any) => value is Record<string, any>;
-/**
- * 检测传入的值是否为**原始值**（number、string、boolean、symbol、bigint、undefined、null）
- *
- * @example
- * isPrimitive(1);  // true
- * isPrimitive([]); // false
- */
-export declare const isPrimitive: (value: any) => value is Primitive;
-/**
- * 检测传入的值是否为**假值**（false、0、''、null、undefined、NaN等）
- *
- * @example
- * isFalsy(""); // true
- * isFalsy(1); // false
- */
-export declare const isFalsy: (value: any) => value is Falsy;
-/**
- * 检测传入的值是否为**真值**
- *
- * @example
- * isTruthy(1); // true
- * isTruthy(""); // false
- */
-export declare const isTruthy: (value: any) => value is any;
-/**
- * 检测传入的值是否为**空值**（null、undefined）
- *
- * @example
- * isNil(null); // true
- * isNil(undefined); // true
- * isNil(1); // false
- */
-export declare const isNil: (value: any) => value is null | undefined;

package/dist/lru-cache.d.ts

@@ -1,18 +0,0 @@
-/**
- * 简易 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
- */
-declare class LRUCache<K, V> {
-    private cache;
-    private maxSize;
-    constructor(maxSize?: number);
-    get(key: K): V | undefined;
-    set(key: K, value: V): void;
-    has(key: K): boolean;
-}
-export default LRUCache;

package/dist/network.d.ts

@@ -1,68 +0,0 @@
-type BunFetchOptions = {
-    /** 代理服务器配置（仅 Bun 支持） */
-    proxy?: string;
-};
-export type RequestInit = globalThis.RequestInit & BunFetchOptions & {
-    params?: Record<string, any>;
-    parser?: (response: Response) => Promise<any>;
-};
-/**
- * 基于 Fetch API 的请求客户端
- * @param baseURL 接口前缀
- * @param baseOptions 客户端级别的请求体，后续调用时传递相同参数会覆盖上去
- *
- * @remarks
- * 特性：
- * - 合并实例、调用时的相同请求体
- * - 在 params 里传递对象，自动转换为 queryString
- * - 在 body 里传递对象，自动 JSON.stringify
- * - 可选择使用 to() 转换请求结果为 [Error, Response]
- * - 可选择使用 withCache() 缓存请求结果
- * - 支持 proxy 选项（仅在 Bun 环境有效）
- *
- * @example
- *
- * // 用法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 后面
- *
- * // 用法3：使用代理（仅 Bun 环境）
- * const api = fetcher("https://api.example.com", {
- *   proxy: "http://127.0.0.1:7890"
- * });
- *
- * // 安全处理请求结果
- * 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();
- * await getBlogs("/blogs");  // 不发请求，使用缓存
- */
-export declare const fetcher: (baseURL?: string, baseOptions?: RequestInit) => {
-    get: <T>(url: string, options?: Omit<RequestInit, "method">) => Promise<T>;
-    post: <T>(url: string, body: any, options?: Omit<RequestInit, "method" | "body">) => Promise<T>;
-    put: <T>(url: string, body: any, options?: Omit<RequestInit, "method" | "body">) => Promise<T>;
-    delete: <T>(url: string, options?: Omit<RequestInit, "method" | "body">) => Promise<T>;
-};
-/**
- * Go 语言风格的异步处理方式
- * @param promise 一个能被 await 的异步函数
- * @returns 如果成功，返回 [null, 异步函数结果]，否则返回 [Error, undefined]
- *
- * @example
- * const [error, response] = await to(fetcher().get<Blog>("/blogs/hello-world"));
- */
-export declare const to: <T, E = Error>(promise: Promise<T>) => Promise<[null, T] | [E, undefined]>;
-/** 从 url 响应头获取真实链接 */
-export declare const getRealURL: (originURL: string) => Promise<string>;
-export {};

package/dist/number.d.ts

@@ -1,7 +0,0 @@
-/**
- * 在指定闭区间内生成随机整数
- *
- * @example
- * randomInt(1, 10);    // 1 <= x <= 10
- */
-export declare const randomInt: (min: number, max: number) => number;

package/dist/object.d.ts

@@ -1,50 +0,0 @@
-/**
- * 深度合并两个对象，规则如下：
- * 1. 原始值覆盖：如果两个值都是原始类型，则用后者覆盖;
- * 2. 数组拼接：如果两个值都是数组，则拼接为大数组；
- * 3. 对象递归合并：如果两个值都是对象，则进行递归深度合并；
- *
- * @template T 第一个对象
- * @template U 第二个对象
- * @param {T} obj1 要合并的第一个对象，相同字段会被 obj2 覆盖
- * @param {U} obj2 要合并的第二个对象
- */
-export declare const mergeObjects: <T extends Record<string, any>, U extends Record<string, any>>(obj1: T, obj2: U) => T & U;
-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 declare const mapKeys: <T>(obj: T, getNewKey: (key: string) => string) => DeepMapKeys<T>;
-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 declare const mapValues: <T, R = any>(obj: T, getNewValue: (value: any, key: string | number) => R, options?: {
-    /** 过滤函数，返回 true 表示保留该字段 */
-    filter?: (value: any, key: string | number) => boolean;
-}) => DeepMapValues<T, R>;

package/dist/string.d.ts

@@ -1,97 +0,0 @@
-export type SnakeToCamel<S extends string> = S extends `${infer Before}_${infer After}` ? After extends `${infer First}${infer Rest}` ? `${Before}${Uppercase<First>}${SnakeToCamel<Rest>}` : Before : S;
-/**
- * 下划线命名法转为驼峰命名法
- *
- * @example
- * snakeToCamel("user_name") // "userName"
- */
-export declare const snakeToCamel: <S extends string>(str: S) => SnakeToCamel<S>;
-export type CamelToSnake<S extends string> = S extends `${infer First}${infer Rest}` ? Rest extends Uncapitalize<Rest> ? `${Lowercase<First>}${CamelToSnake<Rest>}` : `${Lowercase<First>}_${CamelToSnake<Rest>}` : Lowercase<S>;
-/**
- * 驼峰命名法转为下划线命名法
- *
- * @example
- * camelToSnake("shouldComponentUpdate") // "should_component_update"
- */
-export declare const camelToSnake: <S extends string>(str: S) => CamelToSnake<S>;
-export type Capitalize<S extends string> = S extends `${infer P1}${infer Rest}` ? P1 extends Capitalize<P1> ? S : `${Uppercase<P1>}${Rest}` : S;
-/**
- * 字符串首字母大写
- *
- * @example
- * capitalize("hello") // "Hello"
- */
-export declare const capitalize: <S extends string>(s: S) => Capitalize<S>;
-export type Decapitalize<S extends string> = S extends `${infer P1}${infer Rest}` ? P1 extends Lowercase<P1> ? P1 : `${Lowercase<P1>}${Rest}` : S;
-/**
- * 字符串首字母小写
- *
- * @example
- * decapitalize("Hello") // "hello"
- */
-export declare const decapitalize: <S extends string>(s: S) => Decapitalize<S>;
-/**
- * 图片压缩选项
- */
-export type ImageCompressionOptions = {
-    /** 压缩比率，默认 0.92 */
-    quality?: number;
-    /**
-     * 自定义压缩函数，用于非浏览器环境（Node.js/Bun）
-     * 如果提供，将使用此函数替代默认的 canvas 压缩
-     * @param arrayBuffer 图片的 ArrayBuffer 数据
-     * @param mime 图片的 MIME 类型
-     * @param quality 压缩质量
-     * @returns 压缩后的 base64 字符串
-     */
-    compressor?: (arrayBuffer: ArrayBuffer, mime: string, quality: number) => Promise<string> | string;
-};
-/**
- * 图片地址转 base64 数据
- *
- * @param imageUrl 图片地址
- * @param options 可选配置
- * @param options.quality 压缩比率，默认 0.92
- * @param options.compressor 自定义压缩函数，用于 Node.js/Bun 环境
- *
- * @example
- * // 基本用法（浏览器自动使用 Canvas 压缩）
- * imageUrlToBase64("https://example.com/image.jpg");
- *
- * @example
- * // Node.js/Bun 使用 sharp 压缩
- * import sharp from "sharp";
- *
- * imageUrlToBase64("https://example.com/image.jpg", {
- *   quality: 0.8,
- *   compressor: async (buffer, mime, quality) => {
- *     const compressed = await sharp(Buffer.from(buffer))
- *       .jpeg({ quality: Math.round(quality * 100) })
- *       .toBuffer();
- *     return `data:${mime};base64,${compressed.toString("base64")}`;
- *   }
- * });
- */
-export declare const imageUrlToBase64: (imageUrl: string, options?: ImageCompressionOptions) => Promise<string>;
-/**
- * 将字符串压缩为单行精简格式
- *
- * @example
- * // "Hello, world."
- * compactStr(`
- *   Hello,
- *        world!
- * `, {
- *  disableNewLineReplace: false,
- * });
- */
-export declare const compactStr: (text?: string, options?: {
-    /** 最大保留长度，设为 0 或 Infinity 则不截断，默认 Infinity */
-    maxLength?: number;
-    /** 是否将换行符替换为字面量 \n，默认开启 */
-    disableNewLineReplace?: boolean;
-    /** 是否合并连续的空格/制表符为一个空格，默认开启 */
-    disableWhitespaceCollapse?: boolean;
-    /** 截断后的后缀，默认为 "..." */
-    omission?: string;
-}) => string;

package/dist/time.d.ts

@@ -1,47 +0,0 @@
-/**
- * 延迟一段时间再执行后续代码
- * @param time 延迟时间，默认 150ms
- * @example
- * await sleep(1000); // 等待 1 秒执行后续代码
- */
-export declare const sleep: (time?: number) => Promise<unknown>;
-/**
- * 防抖：在指定时间内只执行最后一次调用
- * @param fn 要防抖的函数
- * @param delay 延迟时间，默认 300ms
- *
- * @remarks
- * 连续触发时，只有最后一次会执行。适合用于搜索框输入、窗口大小调整等场景。
- * 例如：用户输入"hello"过程中，不会触发搜索，只有停下来时才执行。
- *
- * 防抖 vs 节流：
- * - 防抖：等待触发停止后才执行（最后一次）
- * - 节流：按固定节奏执行（每隔多久执行一次）
- *
- * @example
- * const search = debounce((keyword: string) => {
- *   console.log('搜索:', keyword);
- * });
- * search('hello'); // 300ms 后执行
- */
-export declare const debounce: <T extends (...args: any[]) => any>(fn: T, delay?: number) => (...args: Parameters<T>) => void;
-/**
- * 节流函数 - 在指定时间间隔内最多执行一次调用
- * @param fn 要节流的函数
- * @param delay 间隔时间，默认 300ms
- *
- * @remarks
- * 节流：连续触发时，按照固定间隔执行。适合用于滚动、拖拽等高频触发场景。
- * 例如：滚动页面时，每300ms最多执行一次回调，而不是每次滚动都执行。
- *
- * 防抖 vs 节流：
- * - 防抖：等待触发停止后才执行（最后一次）
- * - 节流：按固定节奏执行（每隔多久执行一次）
- *
- * @example
- * const handleScroll = throttle(() => {
- *   console.log('滚动位置:', window.scrollY);
- * }, 200);
- * window.addEventListener('scroll', handleScroll);
- */
-export declare const throttle: <T extends (...args: any[]) => any>(fn: T, delay?: number) => (this: any, ...args: Parameters<T>) => void;

package/src/string.ts

@@ -1,259 +0,0 @@
-export type SnakeToCamel<S extends string> =
-	S extends `${infer Before}_${infer After}`
-		? After extends `${infer First}${infer Rest}`
-			? `${Before}${Uppercase<First>}${SnakeToCamel<Rest>}`
-			: Before
-		: S;
-
-/**
- * 下划线命名法转为驼峰命名法
- *
- * @example
- * snakeToCamel("user_name") // "userName"
- */
-export const snakeToCamel = <S extends string>(str: S): SnakeToCamel<S> => {
-	return str.replace(/_([a-zA-Z])/g, (match, pattern) =>
-		pattern.toUpperCase(),
-	) as SnakeToCamel<S>;
-};
-
-export type CamelToSnake<S extends string> =
-	S extends `${infer First}${infer Rest}`
-		? Rest extends Uncapitalize<Rest>
-			? `${Lowercase<First>}${CamelToSnake<Rest>}`
-			: `${Lowercase<First>}_${CamelToSnake<Rest>}`
-		: Lowercase<S>;
-
-/**
- * 驼峰命名法转为下划线命名法
- *
- * @example
- * camelToSnake("shouldComponentUpdate") // "should_component_update"
- */
-export const camelToSnake = <S extends string>(str: S): CamelToSnake<S> => {
-	return str.replace(
-		/([A-Z])/g,
-		(match, pattern) => `_${pattern.toLowerCase()}`,
-	) as CamelToSnake<S>;
-};
-
-export type Capitalize<S extends string> = S extends `${infer P1}${infer Rest}`
-	? P1 extends Capitalize<P1>
-		? S
-		: `${Uppercase<P1>}${Rest}`
-	: S;
-
-/**
- * 字符串首字母大写
- *
- * @example
- * capitalize("hello") // "Hello"
- */
-export const capitalize = <S extends string>(s: S): Capitalize<S> => {
-	return (s.charAt(0).toUpperCase() + s.slice(1)) as Capitalize<S>;
-};
-
-export type Decapitalize<S extends string> =
-	S extends `${infer P1}${infer Rest}`
-		? P1 extends Lowercase<P1>
-			? P1
-			: `${Lowercase<P1>}${Rest}`
-		: S;
-
-/**
- * 字符串首字母小写
- *
- * @example
- * decapitalize("Hello") // "hello"
- */
-export const decapitalize = <S extends string>(s: S): Decapitalize<S> => {
-	return (s.charAt(0).toLowerCase() + s.slice(1)) as Decapitalize<S>;
-};
-
-/**
- * 将 ArrayBuffer 转换为 base64 字符串
- * 兼容浏览器、Bun 和 Node.js
- */
-const arrayBufferToBase64 = (buffer: ArrayBuffer): string => {
-	const bytes = new Uint8Array(buffer);
-	let binary = "";
-	for (let i = 0; i < bytes.byteLength; i++) {
-		binary += String.fromCharCode(bytes[i]!);
-	}
-	return btoa(binary);
-};
-
-/**
- * 图片压缩选项
- */
-export type ImageCompressionOptions = {
-	/** 压缩比率，默认 0.92 */
-	quality?: number;
-	/**
-	 * 自定义压缩函数，用于非浏览器环境（Node.js/Bun）
-	 * 如果提供，将使用此函数替代默认的 canvas 压缩
-	 * @param arrayBuffer 图片的 ArrayBuffer 数据
-	 * @param mime 图片的 MIME 类型
-	 * @param quality 压缩质量
-	 * @returns 压缩后的 base64 字符串
-	 */
-	compressor?: (
-		arrayBuffer: ArrayBuffer,
-		mime: string,
-		quality: number,
-	) => Promise<string> | string;
-};
-
-/**
- * 图片地址转 base64 数据
- *
- * @param imageUrl 图片地址
- * @param options 可选配置
- * @param options.quality 压缩比率，默认 0.92
- * @param options.compressor 自定义压缩函数，用于 Node.js/Bun 环境
- *
- * @example
- * // 基本用法（浏览器自动使用 Canvas 压缩）
- * imageUrlToBase64("https://example.com/image.jpg");
- *
- * @example
- * // Node.js/Bun 使用 sharp 压缩
- * import sharp from "sharp";
- *
- * imageUrlToBase64("https://example.com/image.jpg", {
- *   quality: 0.8,
- *   compressor: async (buffer, mime, quality) => {
- *     const compressed = await sharp(Buffer.from(buffer))
- *       .jpeg({ quality: Math.round(quality * 100) })
- *       .toBuffer();
- *     return `data:${mime};base64,${compressed.toString("base64")}`;
- *   }
- * });
- */
-export const imageUrlToBase64 = async (
-	imageUrl: string,
-	options: ImageCompressionOptions = {},
-): Promise<string> => {
-	const { quality = 0.92, compressor } = options;
-
-	if (!imageUrl.startsWith("http")) {
-		throw new Error("图片地址必须以http或https开头");
-	}
-
-	// 使用 fetch 获取图片数据
-	const response = await fetch(imageUrl);
-	if (!response.ok) {
-		throw new Error(`获取图片失败: ${response.statusText}`);
-	}
-
-	const mime = response.headers.get("Content-Type") || "image/jpeg";
-	const arrayBuffer = await response.arrayBuffer();
-
-	// 对于非 JPEG/PNG 图片，直接返回 base64，不做压缩
-	if (mime !== "image/jpeg" && mime !== "image/png") {
-		const base64 = arrayBufferToBase64(arrayBuffer);
-		return `data:${mime};base64,${base64}`;
-	}
-
-	// 如果提供了自定义压缩函数（用于 Node.js/Bun 环境），使用它
-	if (compressor) {
-		return await compressor(arrayBuffer, mime, quality);
-	}
-
-	// 浏览器环境：使用 OffscreenCanvas 压缩（Chrome 69+, Firefox 105+, Safari 16.4+）
-	if (typeof OffscreenCanvas !== "undefined") {
-		let bitmap: ImageBitmap | null = null;
-
-		try {
-			const blob = new Blob([arrayBuffer], { type: mime });
-			bitmap = await createImageBitmap(blob);
-
-			const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
-			const ctx = canvas.getContext("2d");
-			if (!ctx) {
-				throw new Error("无法获取 canvas context");
-			}
-
-			ctx.drawImage(bitmap, 0, 0);
-			bitmap.close();
-			bitmap = null;
-
-			// OffscreenCanvas 使用 convertToBlob 获取压缩后的图片
-			const compressedBlob = await canvas.convertToBlob({
-				type: mime,
-				quality: quality,
-			});
-
-			// 将 Blob 转换为 base64
-			const compressedArrayBuffer = await compressedBlob.arrayBuffer();
-			const base64 = arrayBufferToBase64(compressedArrayBuffer);
-			return `data:${mime};base64,${base64}`;
-		} catch {
-			// Canvas 压缩失败，返回原始 base64
-			bitmap?.close();
-			const base64 = arrayBufferToBase64(arrayBuffer);
-			return `data:${mime};base64,${base64}`;
-		}
-	}
-
-	// 非浏览器环境且没有提供压缩器，直接返回原始 base64
-	const base64 = arrayBufferToBase64(arrayBuffer);
-	return `data:${mime};base64,${base64}`;
-};
-
-/**
- * 将字符串压缩为单行精简格式
- *
- * @example
- * // "Hello, world."
- * compactStr(`
- *   Hello,
- *        world!
- * `, {
- *  disableNewLineReplace: false,
- * });
- */
-export const compactStr = (
-	text: string = "",
-	options?: {
-		/** 最大保留长度，设为 0 或 Infinity 则不截断，默认 Infinity */
-		maxLength?: number;
-		/** 是否将换行符替换为字面量 \n，默认开启 */
-		disableNewLineReplace?: boolean;
-		/** 是否合并连续的空格/制表符为一个空格，默认开启 */
-		disableWhitespaceCollapse?: boolean;
-		/** 截断后的后缀，默认为 "..." */
-		omission?: string;
-	},
-): string => {
-	if (!text) return "";
-
-	const {
-		maxLength = Infinity,
-		disableNewLineReplace = false,
-		disableWhitespaceCollapse = false,
-		omission = "...",
-	} = options ?? {};
-
-	let result = text;
-
-	// 处理换行符
-	if (!disableNewLineReplace) {
-		result = result.replace(/\r?\n/g, "\\n");
-	} else {
-		result = result.replace(/\r?\n/g, " ");
-	}
-
-	// 合并连续空格
-	if (!disableWhitespaceCollapse) {
-		result = result.replace(/\s+/g, " ");
-	}
-	result = result.trim();
-
-	// 截断多出来的文字
-	if (maxLength > 0 && result.length > maxLength) {
-		return result.slice(0, maxLength) + omission;
-	}
-
-	return result;
-};