@cloudcome/utils-core 1.19.0 → 1.20.0

package/dist/promise.cjs

@@ -1,62 +1,103 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const type = require("./type.cjs");
+const require_type = require("./type.cjs");
+//#region src/promise.ts
+/**
+* 检查给定的值是否为 Promise 类似对象。
+* @param unknown - 要检查的值。
+* @returns 如果值是 Promise 类似对象，则返回 `true`，否则返回 `false`。
+*/
 function isPromiseLike(unknown) {
-  return type.isPromise(unknown) || type.isObject(unknown) && typeof unknown.then === "function";
+	return require_type.isPromise(unknown) || require_type.isObject(unknown) && typeof unknown.then === "function";
 }
+/**
+* 等待一定时间后解决 Promise
+* @param ms - 等待的毫秒数，默认为 0
+* @param ctrl - 可选的 AbortController，用于提前终止等待
+* @returns 一个 Promise，等待指定时间后解决
+*/
 async function promiseDelay(ms = 0, ctrl) {
-  return new Promise((resolve) => {
-    const t = setTimeout(resolve, ms);
-    if (ctrl) {
-      ctrl.signal.addEventListener("abort", () => {
-        clearTimeout(t);
-        resolve();
-      });
-    }
-  });
+	return new Promise((resolve) => {
+		const t = setTimeout(resolve, ms);
+		if (ctrl) ctrl.signal.addEventListener("abort", () => {
+			clearTimeout(t);
+			resolve();
+		});
+	});
 }
+/**
+* 使 Promise 在指定时间内执行，超时则拒绝
+* @param promise - 要执行的 Promise
+* @param ms - 超时的毫秒数
+* @returns 如果 Promise 在指定时间内解决，则返回其结果；否则抛出 "timeout" 错误
+* @throws {Error} 如果 Promise 超时，抛出 "timeout" 错误
+*/
 async function promiseTimeout(promise, ms) {
-  const ctrl = new AbortController();
-  const result = await Promise.race([
-    promise,
-    promiseDelay(ms, ctrl).then(() => {
-      throw new Error("timeout");
-    })
-  ]);
-  ctrl.abort();
-  return result;
+	const ctrl = new AbortController();
+	const result = await Promise.race([promise, promiseDelay(ms, ctrl).then(() => {
+		throw new Error("timeout");
+	})]);
+	ctrl.abort();
+	return result;
 }
+/**
+* 在指定条件满足时解决 Promise
+* @param condition - 一个返回布尔值的函数，用于检查条件是否满足
+* @param ms - 检查条件的时间间隔（毫秒），默认为 10
+* @returns 一个 Promise，在条件满足时解决
+*/
 function promiseWhen(condition, ms = 10) {
-  return new Promise((resolve, reject) => {
-    const check = () => {
-      if (condition()) {
-        resolve();
-      } else {
-        setTimeout(check, ms);
-      }
-    };
-    check();
-  });
+	return new Promise((resolve, _reject) => {
+		const check = () => {
+			if (condition()) resolve();
+			else setTimeout(check, ms);
+		};
+		check();
+	});
 }
+/**
+* 创建一个与给定 Promise 共享状态的新 Promise。
+* 新的 Promise 不具备 resolve 或 reject 的能力，它仅反映原始 Promise 的状态。
+* @param promise - 要共享状态的原始 Promise。
+* @returns 一个新的 Promise，其状态与给定的 Promise 完全相同。
+* @example
+* const { promise: p1 } = Promise.withResolvers();
+* const sp1 = sharedPromise(p1);
+* const sp2 = sharedPromise(p1);
+* // 此时 sp1、sp2 完全共享 p1 的状态，自身并不具备 resolve 或 reject 的能力
+*/
 function promiseShared(promise) {
-  return new Promise((resolve, reject) => {
-    promise.then(resolve, reject);
-  });
+	return new Promise((resolve, reject) => {
+		promise.then(resolve, reject);
+	});
 }
+/**
+* 创建一个最小等待时间的函数
+* @param {number} ms - 最小等待时间（毫秒）
+* @returns {function} 返回一个异步函数，该函数会确保从 createMinDelayPromise 调用到其执行的时间至少为 ms 毫秒
+* @example
+* const end = createMinDelayPromise(1000);
+* // 执行一些操作
+* await end(); // 确保从 createMinDelayPromise 调用到这里的总时间至少为 1000 毫秒
+*/
 function createMinDelayPromise(ms) {
-  const startTime = Date.now();
-  return async function end() {
-    const endTime = Date.now();
-    const waitTime = ms - (endTime - startTime);
-    if (waitTime > 0) {
-      await promiseDelay(waitTime);
-    }
-  };
+	const startTime = Date.now();
+	/**
+	* 确保最小等待时间的结束函数
+	* @async
+	* @function end
+	* @returns {Promise<void>} 在达到最小等待时间后解决
+	*/
+	return async function end() {
+		const waitTime = ms - (Date.now() - startTime);
+		if (waitTime > 0) await promiseDelay(waitTime);
+	};
 }
+//#endregion
 exports.createMinDelayPromise = createMinDelayPromise;
 exports.isPromiseLike = isPromiseLike;
 exports.promiseDelay = promiseDelay;
 exports.promiseShared = promiseShared;
 exports.promiseTimeout = promiseTimeout;
 exports.promiseWhen = promiseWhen;
-//# sourceMappingURL=promise.cjs.map
+
+//# sourceMappingURL=promise.cjs.map

package/dist/promise.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"promise.cjs","sources":["../src/promise.ts"],"sourcesContent":["import { isObject, isPromise } from './type';\n\n/**\n * 检查给定的值是否为 Promise 类似对象。\n * @param unknown - 要检查的值。\n * @returns 如果值是 Promise 类似对象，则返回 `true`，否则返回 `false`。\n */\nexport function isPromiseLike<T>(unknown: unknown): unknown is Promise<T> {\n  return isPromise(unknown) || (isObject(unknown) && typeof (unknown as unknown as Promise<T>).then === 'function');\n}\n\n/**\n * 等待一定时间后解决 Promise\n * @param ms - 等待的毫秒数，默认为 0\n * @param ctrl - 可选的 AbortController，用于提前终止等待\n * @returns 一个 Promise，等待指定时间后解决\n */\nexport async function promiseDelay(ms = 0, ctrl?: AbortController) {\n  return new Promise<void>((resolve) => {\n    const t = setTimeout(resolve, ms);\n\n    if (ctrl) {\n      ctrl.signal.addEventListener('abort', () => {\n        clearTimeout(t);\n        resolve();\n      });\n    }\n  });\n}\n\n/**\n * 使 Promise 在指定时间内执行，超时则拒绝\n * @param promise - 要执行的 Promise\n * @param ms - 超时的毫秒数\n * @returns 如果 Promise 在指定时间内解决，则返回其结果；否则抛出 \"timeout\" 错误\n * @throws {Error} 如果 Promise 超时，抛出 \"timeout\" 错误\n */\nexport async function promiseTimeout<T>(promise: Promise<T>, ms: number) {\n  const ctrl = new AbortController();\n  const result = await Promise.race([\n    promise,\n    promiseDelay(ms, ctrl).then(() => {\n      throw new Error('timeout');\n    }),\n  ]);\n  ctrl.abort();\n  return result;\n}\n\n/**\n * 在指定条件满足时解决 Promise\n * @param condition - 一个返回布尔值的函数，用于检查条件是否满足\n * @param ms - 检查条件的时间间隔（毫秒），默认为 10\n * @returns 一个 Promise，在条件满足时解决\n */\nexport function promiseWhen(condition: () => boolean, ms = 10) {\n  return new Promise<void>((resolve, reject) => {\n    const check = () => {\n      if (condition()) {\n        resolve();\n      } else {\n        setTimeout(check, ms);\n      }\n    };\n\n    check();\n  });\n}\n\n/**\n * 创建一个与给定 Promise 共享状态的新 Promise。\n * 新的 Promise 不具备 resolve 或 reject 的能力，它仅反映原始 Promise 的状态。\n * @param promise - 要共享状态的原始 Promise。\n * @returns 一个新的 Promise，其状态与给定的 Promise 完全相同。\n * @example\n * const { promise: p1 } = Promise.withResolvers();\n * const sp1 = sharedPromise(p1);\n * const sp2 = sharedPromise(p1);\n * // 此时 sp1、sp2 完全共享 p1 的状态，自身并不具备 resolve 或 reject 的能力\n */\nexport function promiseShared<T>(promise: Promise<T>) {\n  return new Promise<T>((resolve, reject) => {\n    promise.then(resolve, reject);\n  });\n}\n\n/**\n * 创建一个最小等待时间的函数\n * @param {number} ms - 最小等待时间（毫秒）\n * @returns {function} 返回一个异步函数，该函数会确保从 createMinDelayPromise 调用到其执行的时间至少为 ms 毫秒\n * @example\n * const end = createMinDelayPromise(1000);\n * // 执行一些操作\n * await end(); // 确保从 createMinDelayPromise 调用到这里的总时间至少为 1000 毫秒\n */\nexport function createMinDelayPromise(ms: number) {\n  const startTime = Date.now();\n  /**\n   * 确保最小等待时间的结束函数\n   * @async\n   * @function end\n   * @returns {Promise<void>} 在达到最小等待时间后解决\n   */\n  return async function end() {\n    const endTime = Date.now();\n    const waitTime = ms - (endTime - startTime);\n    if (waitTime > 0) {\n      await promiseDelay(waitTime);\n    }\n  };\n}\n"],"names":["isPromise","isObject"],"mappings":";;;AAOO,SAAS,cAAiB,SAAyC;AACjE,SAAAA,KAAA,UAAU,OAAO,KAAMC,KAAA,SAAS,OAAO,KAAK,OAAQ,QAAkC,SAAS;AACxG;AAQsB,eAAA,aAAa,KAAK,GAAG,MAAwB;AAC1D,SAAA,IAAI,QAAc,CAAC,YAAY;AAC9B,UAAA,IAAI,WAAW,SAAS,EAAE;AAEhC,QAAI,MAAM;AACH,WAAA,OAAO,iBAAiB,SAAS,MAAM;AAC1C,qBAAa,CAAC;AACN,gBAAA;AAAA,MAAA,CACT;AAAA,IAAA;AAAA,EACH,CACD;AACH;AASsB,eAAA,eAAkB,SAAqB,IAAY;AACjE,QAAA,OAAO,IAAI,gBAAgB;AAC3B,QAAA,SAAS,MAAM,QAAQ,KAAK;AAAA,IAChC;AAAA,IACA,aAAa,IAAI,IAAI,EAAE,KAAK,MAAM;AAC1B,YAAA,IAAI,MAAM,SAAS;AAAA,IAC1B,CAAA;AAAA,EAAA,CACF;AACD,OAAK,MAAM;AACJ,SAAA;AACT;AAQgB,SAAA,YAAY,WAA0B,KAAK,IAAI;AAC7D,SAAO,IAAI,QAAc,CAAC,SAAS,WAAW;AAC5C,UAAM,QAAQ,MAAM;AAClB,UAAI,aAAa;AACP,gBAAA;AAAA,MAAA,OACH;AACL,mBAAW,OAAO,EAAE;AAAA,MAAA;AAAA,IAExB;AAEM,UAAA;AAAA,EAAA,CACP;AACH;AAaO,SAAS,cAAiB,SAAqB;AACpD,SAAO,IAAI,QAAW,CAAC,SAAS,WAAW;AACjC,YAAA,KAAK,SAAS,MAAM;AAAA,EAAA,CAC7B;AACH;AAWO,SAAS,sBAAsB,IAAY;AAC1C,QAAA,YAAY,KAAK,IAAI;AAO3B,SAAO,eAAe,MAAM;AACpB,UAAA,UAAU,KAAK,IAAI;AACnB,UAAA,WAAW,MAAM,UAAU;AACjC,QAAI,WAAW,GAAG;AAChB,YAAM,aAAa,QAAQ;AAAA,IAAA;AAAA,EAE/B;AACF;;;;;;;"}
+{"version":3,"file":"promise.cjs","names":[],"sources":["../src/promise.ts"],"sourcesContent":["import { isObject, isPromise } from './type';\n\n/**\n * 检查给定的值是否为 Promise 类似对象。\n * @param unknown - 要检查的值。\n * @returns 如果值是 Promise 类似对象，则返回 `true`，否则返回 `false`。\n */\nexport function isPromiseLike<T>(unknown: unknown): unknown is Promise<T> {\n  return (\n    isPromise(unknown) ||\n    (isObject(unknown) &&\n      typeof (unknown as unknown as Promise<T>).then === 'function')\n  );\n}\n\n/**\n * 等待一定时间后解决 Promise\n * @param ms - 等待的毫秒数，默认为 0\n * @param ctrl - 可选的 AbortController，用于提前终止等待\n * @returns 一个 Promise，等待指定时间后解决\n */\nexport async function promiseDelay(ms = 0, ctrl?: AbortController) {\n  return new Promise<void>((resolve) => {\n    const t = setTimeout(resolve, ms);\n\n    if (ctrl) {\n      ctrl.signal.addEventListener('abort', () => {\n        clearTimeout(t);\n        resolve();\n      });\n    }\n  });\n}\n\n/**\n * 使 Promise 在指定时间内执行，超时则拒绝\n * @param promise - 要执行的 Promise\n * @param ms - 超时的毫秒数\n * @returns 如果 Promise 在指定时间内解决，则返回其结果；否则抛出 \"timeout\" 错误\n * @throws {Error} 如果 Promise 超时，抛出 \"timeout\" 错误\n */\nexport async function promiseTimeout<T>(promise: Promise<T>, ms: number) {\n  const ctrl = new AbortController();\n  const result = await Promise.race([\n    promise,\n    promiseDelay(ms, ctrl).then(() => {\n      throw new Error('timeout');\n    }),\n  ]);\n  ctrl.abort();\n  return result;\n}\n\n/**\n * 在指定条件满足时解决 Promise\n * @param condition - 一个返回布尔值的函数，用于检查条件是否满足\n * @param ms - 检查条件的时间间隔（毫秒），默认为 10\n * @returns 一个 Promise，在条件满足时解决\n */\nexport function promiseWhen(condition: () => boolean, ms = 10) {\n  return new Promise<void>((resolve, _reject) => {\n    const check = () => {\n      if (condition()) {\n        resolve();\n      } else {\n        setTimeout(check, ms);\n      }\n    };\n\n    check();\n  });\n}\n\n/**\n * 创建一个与给定 Promise 共享状态的新 Promise。\n * 新的 Promise 不具备 resolve 或 reject 的能力，它仅反映原始 Promise 的状态。\n * @param promise - 要共享状态的原始 Promise。\n * @returns 一个新的 Promise，其状态与给定的 Promise 完全相同。\n * @example\n * const { promise: p1 } = Promise.withResolvers();\n * const sp1 = sharedPromise(p1);\n * const sp2 = sharedPromise(p1);\n * // 此时 sp1、sp2 完全共享 p1 的状态，自身并不具备 resolve 或 reject 的能力\n */\nexport function promiseShared<T>(promise: Promise<T>) {\n  return new Promise<T>((resolve, reject) => {\n    promise.then(resolve, reject);\n  });\n}\n\n/**\n * 创建一个最小等待时间的函数\n * @param {number} ms - 最小等待时间（毫秒）\n * @returns {function} 返回一个异步函数，该函数会确保从 createMinDelayPromise 调用到其执行的时间至少为 ms 毫秒\n * @example\n * const end = createMinDelayPromise(1000);\n * // 执行一些操作\n * await end(); // 确保从 createMinDelayPromise 调用到这里的总时间至少为 1000 毫秒\n */\nexport function createMinDelayPromise(ms: number) {\n  const startTime = Date.now();\n  /**\n   * 确保最小等待时间的结束函数\n   * @async\n   * @function end\n   * @returns {Promise<void>} 在达到最小等待时间后解决\n   */\n  return async function end() {\n    const endTime = Date.now();\n    const waitTime = ms - (endTime - startTime);\n    if (waitTime > 0) {\n      await promiseDelay(waitTime);\n    }\n  };\n}\n"],"mappings":";;;;;;;;AAOA,SAAgB,cAAiB,SAAyC;CACxE,OACE,aAAA,UAAU,QAAQ,IACjB,aAAA,SAAS,QAAQ,IAChB,OAAQ,QAAkC,SAAS;;;;;;;;AAUzD,eAAsB,aAAa,KAAK,GAAG,MAAwB;CACjE,OAAO,IAAI,SAAe,YAAY;EACpC,MAAM,IAAI,WAAW,SAAS,GAAG;EAEjC,IAAI,MACF,KAAK,OAAO,iBAAiB,eAAe;GAC1C,aAAa,EAAE;GACf,SAAS;IACT;GAEJ;;;;;;;;;AAUJ,eAAsB,eAAkB,SAAqB,IAAY;CACvE,MAAM,OAAO,IAAI,iBAAiB;CAClC,MAAM,SAAS,MAAM,QAAQ,KAAK,CAChC,SACA,aAAa,IAAI,KAAK,CAAC,WAAW;EAChC,MAAM,IAAI,MAAM,UAAU;GAC1B,CACH,CAAC;CACF,KAAK,OAAO;CACZ,OAAO;;;;;;;;AAST,SAAgB,YAAY,WAA0B,KAAK,IAAI;CAC7D,OAAO,IAAI,SAAe,SAAS,YAAY;EAC7C,MAAM,cAAc;GAClB,IAAI,WAAW,EACb,SAAS;QAET,WAAW,OAAO,GAAG;;EAIzB,OAAO;GACP;;;;;;;;;;;;;AAcJ,SAAgB,cAAiB,SAAqB;CACpD,OAAO,IAAI,SAAY,SAAS,WAAW;EACzC,QAAQ,KAAK,SAAS,OAAO;GAC7B;;;;;;;;;;;AAYJ,SAAgB,sBAAsB,IAAY;CAChD,MAAM,YAAY,KAAK,KAAK;;;;;;;CAO5B,OAAO,eAAe,MAAM;EAE1B,MAAM,WAAW,MADD,KAAK,KACE,GAAU;EACjC,IAAI,WAAW,GACb,MAAM,aAAa,SAAS"}

package/dist/promise.mjs

@@ -1,62 +1,97 @@
-import { isPromise, isObject } from "./type.mjs";
+import { isObject, isPromise } from "./type.mjs";
+//#region src/promise.ts
+/**
+* 检查给定的值是否为 Promise 类似对象。
+* @param unknown - 要检查的值。
+* @returns 如果值是 Promise 类似对象，则返回 `true`，否则返回 `false`。
+*/
 function isPromiseLike(unknown) {
-  return isPromise(unknown) || isObject(unknown) && typeof unknown.then === "function";
+	return isPromise(unknown) || isObject(unknown) && typeof unknown.then === "function";
 }
+/**
+* 等待一定时间后解决 Promise
+* @param ms - 等待的毫秒数，默认为 0
+* @param ctrl - 可选的 AbortController，用于提前终止等待
+* @returns 一个 Promise，等待指定时间后解决
+*/
 async function promiseDelay(ms = 0, ctrl) {
-  return new Promise((resolve) => {
-    const t = setTimeout(resolve, ms);
-    if (ctrl) {
-      ctrl.signal.addEventListener("abort", () => {
-        clearTimeout(t);
-        resolve();
-      });
-    }
-  });
+	return new Promise((resolve) => {
+		const t = setTimeout(resolve, ms);
+		if (ctrl) ctrl.signal.addEventListener("abort", () => {
+			clearTimeout(t);
+			resolve();
+		});
+	});
 }
+/**
+* 使 Promise 在指定时间内执行，超时则拒绝
+* @param promise - 要执行的 Promise
+* @param ms - 超时的毫秒数
+* @returns 如果 Promise 在指定时间内解决，则返回其结果；否则抛出 "timeout" 错误
+* @throws {Error} 如果 Promise 超时，抛出 "timeout" 错误
+*/
 async function promiseTimeout(promise, ms) {
-  const ctrl = new AbortController();
-  const result = await Promise.race([
-    promise,
-    promiseDelay(ms, ctrl).then(() => {
-      throw new Error("timeout");
-    })
-  ]);
-  ctrl.abort();
-  return result;
+	const ctrl = new AbortController();
+	const result = await Promise.race([promise, promiseDelay(ms, ctrl).then(() => {
+		throw new Error("timeout");
+	})]);
+	ctrl.abort();
+	return result;
 }
+/**
+* 在指定条件满足时解决 Promise
+* @param condition - 一个返回布尔值的函数，用于检查条件是否满足
+* @param ms - 检查条件的时间间隔（毫秒），默认为 10
+* @returns 一个 Promise，在条件满足时解决
+*/
 function promiseWhen(condition, ms = 10) {
-  return new Promise((resolve, reject) => {
-    const check = () => {
-      if (condition()) {
-        resolve();
-      } else {
-        setTimeout(check, ms);
-      }
-    };
-    check();
-  });
+	return new Promise((resolve, _reject) => {
+		const check = () => {
+			if (condition()) resolve();
+			else setTimeout(check, ms);
+		};
+		check();
+	});
 }
+/**
+* 创建一个与给定 Promise 共享状态的新 Promise。
+* 新的 Promise 不具备 resolve 或 reject 的能力，它仅反映原始 Promise 的状态。
+* @param promise - 要共享状态的原始 Promise。
+* @returns 一个新的 Promise，其状态与给定的 Promise 完全相同。
+* @example
+* const { promise: p1 } = Promise.withResolvers();
+* const sp1 = sharedPromise(p1);
+* const sp2 = sharedPromise(p1);
+* // 此时 sp1、sp2 完全共享 p1 的状态，自身并不具备 resolve 或 reject 的能力
+*/
 function promiseShared(promise) {
-  return new Promise((resolve, reject) => {
-    promise.then(resolve, reject);
-  });
+	return new Promise((resolve, reject) => {
+		promise.then(resolve, reject);
+	});
 }
+/**
+* 创建一个最小等待时间的函数
+* @param {number} ms - 最小等待时间（毫秒）
+* @returns {function} 返回一个异步函数，该函数会确保从 createMinDelayPromise 调用到其执行的时间至少为 ms 毫秒
+* @example
+* const end = createMinDelayPromise(1000);
+* // 执行一些操作
+* await end(); // 确保从 createMinDelayPromise 调用到这里的总时间至少为 1000 毫秒
+*/
 function createMinDelayPromise(ms) {
-  const startTime = Date.now();
-  return async function end() {
-    const endTime = Date.now();
-    const waitTime = ms - (endTime - startTime);
-    if (waitTime > 0) {
-      await promiseDelay(waitTime);
-    }
-  };
+	const startTime = Date.now();
+	/**
+	* 确保最小等待时间的结束函数
+	* @async
+	* @function end
+	* @returns {Promise<void>} 在达到最小等待时间后解决
+	*/
+	return async function end() {
+		const waitTime = ms - (Date.now() - startTime);
+		if (waitTime > 0) await promiseDelay(waitTime);
+	};
 }
-export {
-  createMinDelayPromise,
-  isPromiseLike,
-  promiseDelay,
-  promiseShared,
-  promiseTimeout,
-  promiseWhen
-};
-//# sourceMappingURL=promise.mjs.map
+//#endregion
+export { createMinDelayPromise, isPromiseLike, promiseDelay, promiseShared, promiseTimeout, promiseWhen };
+
+//# sourceMappingURL=promise.mjs.map

package/dist/promise.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"promise.mjs","sources":["../src/promise.ts"],"sourcesContent":["import { isObject, isPromise } from './type';\n\n/**\n * 检查给定的值是否为 Promise 类似对象。\n * @param unknown - 要检查的值。\n * @returns 如果值是 Promise 类似对象，则返回 `true`，否则返回 `false`。\n */\nexport function isPromiseLike<T>(unknown: unknown): unknown is Promise<T> {\n  return isPromise(unknown) || (isObject(unknown) && typeof (unknown as unknown as Promise<T>).then === 'function');\n}\n\n/**\n * 等待一定时间后解决 Promise\n * @param ms - 等待的毫秒数，默认为 0\n * @param ctrl - 可选的 AbortController，用于提前终止等待\n * @returns 一个 Promise，等待指定时间后解决\n */\nexport async function promiseDelay(ms = 0, ctrl?: AbortController) {\n  return new Promise<void>((resolve) => {\n    const t = setTimeout(resolve, ms);\n\n    if (ctrl) {\n      ctrl.signal.addEventListener('abort', () => {\n        clearTimeout(t);\n        resolve();\n      });\n    }\n  });\n}\n\n/**\n * 使 Promise 在指定时间内执行，超时则拒绝\n * @param promise - 要执行的 Promise\n * @param ms - 超时的毫秒数\n * @returns 如果 Promise 在指定时间内解决，则返回其结果；否则抛出 \"timeout\" 错误\n * @throws {Error} 如果 Promise 超时，抛出 \"timeout\" 错误\n */\nexport async function promiseTimeout<T>(promise: Promise<T>, ms: number) {\n  const ctrl = new AbortController();\n  const result = await Promise.race([\n    promise,\n    promiseDelay(ms, ctrl).then(() => {\n      throw new Error('timeout');\n    }),\n  ]);\n  ctrl.abort();\n  return result;\n}\n\n/**\n * 在指定条件满足时解决 Promise\n * @param condition - 一个返回布尔值的函数，用于检查条件是否满足\n * @param ms - 检查条件的时间间隔（毫秒），默认为 10\n * @returns 一个 Promise，在条件满足时解决\n */\nexport function promiseWhen(condition: () => boolean, ms = 10) {\n  return new Promise<void>((resolve, reject) => {\n    const check = () => {\n      if (condition()) {\n        resolve();\n      } else {\n        setTimeout(check, ms);\n      }\n    };\n\n    check();\n  });\n}\n\n/**\n * 创建一个与给定 Promise 共享状态的新 Promise。\n * 新的 Promise 不具备 resolve 或 reject 的能力，它仅反映原始 Promise 的状态。\n * @param promise - 要共享状态的原始 Promise。\n * @returns 一个新的 Promise，其状态与给定的 Promise 完全相同。\n * @example\n * const { promise: p1 } = Promise.withResolvers();\n * const sp1 = sharedPromise(p1);\n * const sp2 = sharedPromise(p1);\n * // 此时 sp1、sp2 完全共享 p1 的状态，自身并不具备 resolve 或 reject 的能力\n */\nexport function promiseShared<T>(promise: Promise<T>) {\n  return new Promise<T>((resolve, reject) => {\n    promise.then(resolve, reject);\n  });\n}\n\n/**\n * 创建一个最小等待时间的函数\n * @param {number} ms - 最小等待时间（毫秒）\n * @returns {function} 返回一个异步函数，该函数会确保从 createMinDelayPromise 调用到其执行的时间至少为 ms 毫秒\n * @example\n * const end = createMinDelayPromise(1000);\n * // 执行一些操作\n * await end(); // 确保从 createMinDelayPromise 调用到这里的总时间至少为 1000 毫秒\n */\nexport function createMinDelayPromise(ms: number) {\n  const startTime = Date.now();\n  /**\n   * 确保最小等待时间的结束函数\n   * @async\n   * @function end\n   * @returns {Promise<void>} 在达到最小等待时间后解决\n   */\n  return async function end() {\n    const endTime = Date.now();\n    const waitTime = ms - (endTime - startTime);\n    if (waitTime > 0) {\n      await promiseDelay(waitTime);\n    }\n  };\n}\n"],"names":[],"mappings":";AAOO,SAAS,cAAiB,SAAyC;AACjE,SAAA,UAAU,OAAO,KAAM,SAAS,OAAO,KAAK,OAAQ,QAAkC,SAAS;AACxG;AAQsB,eAAA,aAAa,KAAK,GAAG,MAAwB;AAC1D,SAAA,IAAI,QAAc,CAAC,YAAY;AAC9B,UAAA,IAAI,WAAW,SAAS,EAAE;AAEhC,QAAI,MAAM;AACH,WAAA,OAAO,iBAAiB,SAAS,MAAM;AAC1C,qBAAa,CAAC;AACN,gBAAA;AAAA,MAAA,CACT;AAAA,IAAA;AAAA,EACH,CACD;AACH;AASsB,eAAA,eAAkB,SAAqB,IAAY;AACjE,QAAA,OAAO,IAAI,gBAAgB;AAC3B,QAAA,SAAS,MAAM,QAAQ,KAAK;AAAA,IAChC;AAAA,IACA,aAAa,IAAI,IAAI,EAAE,KAAK,MAAM;AAC1B,YAAA,IAAI,MAAM,SAAS;AAAA,IAC1B,CAAA;AAAA,EAAA,CACF;AACD,OAAK,MAAM;AACJ,SAAA;AACT;AAQgB,SAAA,YAAY,WAA0B,KAAK,IAAI;AAC7D,SAAO,IAAI,QAAc,CAAC,SAAS,WAAW;AAC5C,UAAM,QAAQ,MAAM;AAClB,UAAI,aAAa;AACP,gBAAA;AAAA,MAAA,OACH;AACL,mBAAW,OAAO,EAAE;AAAA,MAAA;AAAA,IAExB;AAEM,UAAA;AAAA,EAAA,CACP;AACH;AAaO,SAAS,cAAiB,SAAqB;AACpD,SAAO,IAAI,QAAW,CAAC,SAAS,WAAW;AACjC,YAAA,KAAK,SAAS,MAAM;AAAA,EAAA,CAC7B;AACH;AAWO,SAAS,sBAAsB,IAAY;AAC1C,QAAA,YAAY,KAAK,IAAI;AAO3B,SAAO,eAAe,MAAM;AACpB,UAAA,UAAU,KAAK,IAAI;AACnB,UAAA,WAAW,MAAM,UAAU;AACjC,QAAI,WAAW,GAAG;AAChB,YAAM,aAAa,QAAQ;AAAA,IAAA;AAAA,EAE/B;AACF;"}
+{"version":3,"file":"promise.mjs","names":[],"sources":["../src/promise.ts"],"sourcesContent":["import { isObject, isPromise } from './type';\n\n/**\n * 检查给定的值是否为 Promise 类似对象。\n * @param unknown - 要检查的值。\n * @returns 如果值是 Promise 类似对象，则返回 `true`，否则返回 `false`。\n */\nexport function isPromiseLike<T>(unknown: unknown): unknown is Promise<T> {\n  return (\n    isPromise(unknown) ||\n    (isObject(unknown) &&\n      typeof (unknown as unknown as Promise<T>).then === 'function')\n  );\n}\n\n/**\n * 等待一定时间后解决 Promise\n * @param ms - 等待的毫秒数，默认为 0\n * @param ctrl - 可选的 AbortController，用于提前终止等待\n * @returns 一个 Promise，等待指定时间后解决\n */\nexport async function promiseDelay(ms = 0, ctrl?: AbortController) {\n  return new Promise<void>((resolve) => {\n    const t = setTimeout(resolve, ms);\n\n    if (ctrl) {\n      ctrl.signal.addEventListener('abort', () => {\n        clearTimeout(t);\n        resolve();\n      });\n    }\n  });\n}\n\n/**\n * 使 Promise 在指定时间内执行，超时则拒绝\n * @param promise - 要执行的 Promise\n * @param ms - 超时的毫秒数\n * @returns 如果 Promise 在指定时间内解决，则返回其结果；否则抛出 \"timeout\" 错误\n * @throws {Error} 如果 Promise 超时，抛出 \"timeout\" 错误\n */\nexport async function promiseTimeout<T>(promise: Promise<T>, ms: number) {\n  const ctrl = new AbortController();\n  const result = await Promise.race([\n    promise,\n    promiseDelay(ms, ctrl).then(() => {\n      throw new Error('timeout');\n    }),\n  ]);\n  ctrl.abort();\n  return result;\n}\n\n/**\n * 在指定条件满足时解决 Promise\n * @param condition - 一个返回布尔值的函数，用于检查条件是否满足\n * @param ms - 检查条件的时间间隔（毫秒），默认为 10\n * @returns 一个 Promise，在条件满足时解决\n */\nexport function promiseWhen(condition: () => boolean, ms = 10) {\n  return new Promise<void>((resolve, _reject) => {\n    const check = () => {\n      if (condition()) {\n        resolve();\n      } else {\n        setTimeout(check, ms);\n      }\n    };\n\n    check();\n  });\n}\n\n/**\n * 创建一个与给定 Promise 共享状态的新 Promise。\n * 新的 Promise 不具备 resolve 或 reject 的能力，它仅反映原始 Promise 的状态。\n * @param promise - 要共享状态的原始 Promise。\n * @returns 一个新的 Promise，其状态与给定的 Promise 完全相同。\n * @example\n * const { promise: p1 } = Promise.withResolvers();\n * const sp1 = sharedPromise(p1);\n * const sp2 = sharedPromise(p1);\n * // 此时 sp1、sp2 完全共享 p1 的状态，自身并不具备 resolve 或 reject 的能力\n */\nexport function promiseShared<T>(promise: Promise<T>) {\n  return new Promise<T>((resolve, reject) => {\n    promise.then(resolve, reject);\n  });\n}\n\n/**\n * 创建一个最小等待时间的函数\n * @param {number} ms - 最小等待时间（毫秒）\n * @returns {function} 返回一个异步函数，该函数会确保从 createMinDelayPromise 调用到其执行的时间至少为 ms 毫秒\n * @example\n * const end = createMinDelayPromise(1000);\n * // 执行一些操作\n * await end(); // 确保从 createMinDelayPromise 调用到这里的总时间至少为 1000 毫秒\n */\nexport function createMinDelayPromise(ms: number) {\n  const startTime = Date.now();\n  /**\n   * 确保最小等待时间的结束函数\n   * @async\n   * @function end\n   * @returns {Promise<void>} 在达到最小等待时间后解决\n   */\n  return async function end() {\n    const endTime = Date.now();\n    const waitTime = ms - (endTime - startTime);\n    if (waitTime > 0) {\n      await promiseDelay(waitTime);\n    }\n  };\n}\n"],"mappings":";;;;;;;AAOA,SAAgB,cAAiB,SAAyC;CACxE,OACE,UAAU,QAAQ,IACjB,SAAS,QAAQ,IAChB,OAAQ,QAAkC,SAAS;;;;;;;;AAUzD,eAAsB,aAAa,KAAK,GAAG,MAAwB;CACjE,OAAO,IAAI,SAAe,YAAY;EACpC,MAAM,IAAI,WAAW,SAAS,GAAG;EAEjC,IAAI,MACF,KAAK,OAAO,iBAAiB,eAAe;GAC1C,aAAa,EAAE;GACf,SAAS;IACT;GAEJ;;;;;;;;;AAUJ,eAAsB,eAAkB,SAAqB,IAAY;CACvE,MAAM,OAAO,IAAI,iBAAiB;CAClC,MAAM,SAAS,MAAM,QAAQ,KAAK,CAChC,SACA,aAAa,IAAI,KAAK,CAAC,WAAW;EAChC,MAAM,IAAI,MAAM,UAAU;GAC1B,CACH,CAAC;CACF,KAAK,OAAO;CACZ,OAAO;;;;;;;;AAST,SAAgB,YAAY,WAA0B,KAAK,IAAI;CAC7D,OAAO,IAAI,SAAe,SAAS,YAAY;EAC7C,MAAM,cAAc;GAClB,IAAI,WAAW,EACb,SAAS;QAET,WAAW,OAAO,GAAG;;EAIzB,OAAO;GACP;;;;;;;;;;;;;AAcJ,SAAgB,cAAiB,SAAqB;CACpD,OAAO,IAAI,SAAY,SAAS,WAAW;EACzC,QAAQ,KAAK,SAAS,OAAO;GAC7B;;;;;;;;;;;AAYJ,SAAgB,sBAAsB,IAAY;CAChD,MAAM,YAAY,KAAK,KAAK;;;;;;;CAO5B,OAAO,eAAe,MAAM;EAE1B,MAAM,WAAW,MADD,KAAK,KACE,GAAU;EACjC,IAAI,WAAW,GACb,MAAM,aAAa,SAAS"}

package/dist/qs.cjs

@@ -1,47 +1,71 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const each = require("./each.cjs");
-const type = require("./type.cjs");
+const require_type = require("./type.cjs");
+const require_object = require("./object.cjs");
+//#region src/qs.ts
+/**
+* 解析查询字符串为对象
+* @template T - 返回的对象类型
+* @param {string} queryString - 要解析的查询字符串
+* @param {QSReader<T>} [parser] - 自定义解析函数
+* @returns {T} 解析后的对象
+* @example
+* const obj = qsParse('name=John&age=30');
+* // { name: 'John', age: '30' }
+*
+* const obj2 = qsParse('date=2023-01-01', (val, key) => {
+*   if (key === 'date') return new Date(val);
+*   return val;
+* });
+* // { date: Date('2023-01-01') }
+*/
 function qsParse(queryString, parser) {
-  const sp = new globalThis.URLSearchParams(queryString.replace(/^.*\?/, ""));
-  const qsObject = {};
-  for (const [key, val] of sp.entries()) {
-    const valFinal = parser ? parser(val, key, qsObject) : val;
-    if (type.isNullish(valFinal)) continue;
-    if (Object.hasOwn(qsObject, key)) {
-      if (!type.isArray(qsObject[key])) qsObject[key] = [qsObject[key]];
-      qsObject[key].push(val);
-    } else {
-      qsObject[key] = valFinal;
-    }
-  }
-  return qsObject;
+	const sp = new globalThis.URLSearchParams(queryString.replace(/^.*\?/, ""));
+	const qsObject = {};
+	for (const [key, val] of sp.entries()) {
+		const valFinal = parser ? parser(val, key, qsObject) : val;
+		if (require_type.isNullish(valFinal)) continue;
+		if (Object.hasOwn(qsObject, key)) {
+			if (!require_type.isArray(qsObject[key])) qsObject[key] = [qsObject[key]];
+			qsObject[key].push(val);
+		} else qsObject[key] = valFinal;
+	}
+	return qsObject;
 }
-const defaultWriter = (val) => {
-  if (type.isString(val)) return val;
-  if (type.isNumber(val)) return String(val);
-  if (type.isBoolean(val)) return val ? "true" : "false";
-  if (type.isDate(val)) return val.toISOString();
-  return null;
+var defaultWriter = (val) => {
+	if (require_type.isString(val)) return val;
+	if (require_type.isNumber(val)) return String(val);
+	if (require_type.isBoolean(val)) return val ? "true" : "false";
+	if (require_type.isDate(val)) return val.toISOString();
+	return null;
 };
+/**
+* 将对象序列化为查询字符串
+* @template T - 要序列化的对象类型
+* @param {T} qsObject - 要序列化的对象
+* @param {QSWriter<T>} [stringify=defaultWriter] - 自定义序列化函数
+* @returns {string} 序列化后的查询字符串
+* @example
+* const str = qsStringify({ name: 'John', age: 30 });
+* // 'name=John&age=30'
+*
+* const str2 = qsStringify({ date: new Date('2023-01-01') });
+* // 'date=2023-01-01T00:00:00.000Z'
+*/
 function qsStringify(qsObject, stringify = defaultWriter) {
-  const sp = new globalThis.URLSearchParams();
-  const pushPairs = (val, key) => {
-    const valFinal = stringify(val, String(key), qsObject);
-    if (type.isNullish(valFinal)) return;
-    sp.append(key, valFinal);
-  };
-  each.objectEach(qsObject, (val, key) => {
-    if (type.isArray(val)) {
-      for (const it of val) {
-        pushPairs(it, key);
-      }
-    } else {
-      pushPairs(val, key);
-    }
-  });
-  return sp.toString();
+	const sp = new globalThis.URLSearchParams();
+	const pushPairs = (val, key) => {
+		const valFinal = stringify(val, String(key), qsObject);
+		if (require_type.isNullish(valFinal)) return;
+		sp.append(key, valFinal);
+	};
+	require_object.objectEach(qsObject, (val, key) => {
+		if (require_type.isArray(val)) for (const it of val) pushPairs(it, key);
+		else pushPairs(val, key);
+	});
+	return sp.toString();
 }
+//#endregion
 exports.qsParse = qsParse;
 exports.qsStringify = qsStringify;
-//# sourceMappingURL=qs.cjs.map
+
+//# sourceMappingURL=qs.cjs.map

package/dist/qs.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"qs.cjs","sources":["../src/qs.ts"],"sourcesContent":["import { objectEach } from './object';\nimport { isArray, isBoolean, isDate, isNull, isNullish, isNumber, isString, isUndefined } from './type';\nimport type { AnyObject } from './types';\n\n/**\n * 查询字符串解析函数\n * @template T - 解析后返回的对象类型\n * @callback QSReader\n * @param {string} value - 查询字符串的值\n * @param {string} key - 查询字符串的键\n * @param {T} qsObject - 当前解析的对象\n * @returns {unknown} 解析后的值，如果返回 undefined 或 null 则不会添加到对象中\n * @example\n * const parser: QSReader<MyObject> = (value, key, obj) => {\n *   if (key === 'date') return new Date(value);\n *   return value;\n * };\n */\nexport type QSReader<T extends AnyObject> = (value: string, key: string, qsObject: T) => unknown;\n\n/**\n * 解析查询字符串为对象\n * @template T - 返回的对象类型\n * @param {string} queryString - 要解析的查询字符串\n * @param {QSReader<T>} [parser] - 自定义解析函数\n * @returns {T} 解析后的对象\n * @example\n * const obj = qsParse('name=John&age=30');\n * // { name: 'John', age: '30' }\n *\n * const obj2 = qsParse('date=2023-01-01', (val, key) => {\n *   if (key === 'date') return new Date(val);\n *   return val;\n * });\n * // { date: Date('2023-01-01') }\n */\nexport function qsParse<T extends AnyObject>(queryString: string, parser?: QSReader<T>): T {\n  // 添加 globalThis 是便于对接外部环境 URL 的自行实现\n  // 例如在 uni-app、微信小程序等运行环境。\n  const sp = new globalThis.URLSearchParams(queryString.replace(/^.*\\?/, ''));\n  const qsObject = {} as T;\n\n  for (const [key, val] of sp.entries()) {\n    const valFinal = parser ? parser(val, key, qsObject) : val;\n\n    if (isNullish(valFinal)) continue;\n\n    if (Object.hasOwn(qsObject, key)) {\n      // @ts-expect-error\n      if (!isArray(qsObject[key])) qsObject[key] = [qsObject[key]];\n      (qsObject[key] as unknown[]).push(val);\n    } else {\n      // @ts-expect-error\n      qsObject[key] = valFinal;\n    }\n  }\n\n  return qsObject;\n}\n\n/**\n * 查询字符串序列化函数\n * @template T - 要序列化的对象类型\n * @callback QSWriter\n * @param {unknown} value - 要序列化的值\n * @param {string} key - 对象的键\n * @param {T} query - 当前序列化的对象\n * @returns {string | null} 序列化后的字符串，如果返回 null 则忽略该键值对\n * @example\n * const writer: QSWriter<MyObject> = (val, key) => {\n *   if (val instanceof Date) return val.toISOString();\n *   return String(val);\n * };\n */\nexport type QSWriter<T extends AnyObject = AnyObject> = (value: unknown, key: string, query: T) => string | null;\nconst defaultWriter: QSWriter<AnyObject> = (val: unknown) => {\n  if (isString(val)) return val;\n  if (isNumber(val)) return String(val);\n  if (isBoolean(val)) return val ? 'true' : 'false';\n  if (isDate(val)) return val.toISOString();\n  return null;\n};\n\n/**\n * 将对象序列化为查询字符串\n * @template T - 要序列化的对象类型\n * @param {T} qsObject - 要序列化的对象\n * @param {QSWriter<T>} [stringify=defaultWriter] - 自定义序列化函数\n * @returns {string} 序列化后的查询字符串\n * @example\n * const str = qsStringify({ name: 'John', age: 30 });\n * // 'name=John&age=30'\n *\n * const str2 = qsStringify({ date: new Date('2023-01-01') });\n * // 'date=2023-01-01T00:00:00.000Z'\n */\nexport function qsStringify<T extends AnyObject>(qsObject: T, stringify: QSWriter<T> = defaultWriter): string {\n  // 添加 globalThis 是便于对接外部环境 URL 的自行实现\n  // 例如在 uni-app、微信小程序等运行环境。\n  const sp = new globalThis.URLSearchParams();\n  const pushPairs = (val: unknown, key: string) => {\n    const valFinal = stringify(val, String(key), qsObject);\n    if (isNullish(valFinal)) return;\n\n    sp.append(key, valFinal);\n  };\n\n  objectEach(qsObject, (val, key: string) => {\n    if (isArray(val)) {\n      for (const it of val) {\n        pushPairs(it, key);\n      }\n    } else {\n      pushPairs(val, key);\n    }\n  });\n\n  return sp.toString();\n}\n"],"names":["isNullish","isArray","isString","isNumber","isBoolean","isDate","objectEach"],"mappings":";;;;AAoCgB,SAAA,QAA6B,aAAqB,QAAyB;AAGnF,QAAA,KAAK,IAAI,WAAW,gBAAgB,YAAY,QAAQ,SAAS,EAAE,CAAC;AAC1E,QAAM,WAAW,CAAC;AAElB,aAAW,CAAC,KAAK,GAAG,KAAK,GAAG,WAAW;AACrC,UAAM,WAAW,SAAS,OAAO,KAAK,KAAK,QAAQ,IAAI;AAEnD,QAAAA,KAAAA,UAAU,QAAQ,EAAG;AAEzB,QAAI,OAAO,OAAO,UAAU,GAAG,GAAG;AAEhC,UAAI,CAACC,KAAA,QAAQ,SAAS,GAAG,CAAC,EAAY,UAAA,GAAG,IAAI,CAAC,SAAS,GAAG,CAAC;AAC1D,eAAS,GAAG,EAAgB,KAAK,GAAG;AAAA,IAAA,OAChC;AAEL,eAAS,GAAG,IAAI;AAAA,IAAA;AAAA,EAClB;AAGK,SAAA;AACT;AAiBA,MAAM,gBAAqC,CAAC,QAAiB;AACvD,MAAAC,KAAA,SAAS,GAAG,EAAU,QAAA;AAC1B,MAAIC,KAAS,SAAA,GAAG,EAAG,QAAO,OAAO,GAAG;AACpC,MAAIC,KAAU,UAAA,GAAG,EAAG,QAAO,MAAM,SAAS;AAC1C,MAAIC,KAAO,OAAA,GAAG,EAAG,QAAO,IAAI,YAAY;AACjC,SAAA;AACT;AAegB,SAAA,YAAiC,UAAa,YAAyB,eAAuB;AAGtG,QAAA,KAAK,IAAI,WAAW,gBAAgB;AACpC,QAAA,YAAY,CAAC,KAAc,QAAgB;AAC/C,UAAM,WAAW,UAAU,KAAK,OAAO,GAAG,GAAG,QAAQ;AACjD,QAAAL,KAAAA,UAAU,QAAQ,EAAG;AAEtB,OAAA,OAAO,KAAK,QAAQ;AAAA,EACzB;AAEWM,OAAAA,WAAA,UAAU,CAAC,KAAK,QAAgB;AACrC,QAAAL,KAAAA,QAAQ,GAAG,GAAG;AAChB,iBAAW,MAAM,KAAK;AACpB,kBAAU,IAAI,GAAG;AAAA,MAAA;AAAA,IACnB,OACK;AACL,gBAAU,KAAK,GAAG;AAAA,IAAA;AAAA,EACpB,CACD;AAED,SAAO,GAAG,SAAS;AACrB;;;"}
+{"version":3,"file":"qs.cjs","names":[],"sources":["../src/qs.ts"],"sourcesContent":["import { objectEach } from './object';\nimport {\n  isArray,\n  isBoolean,\n  isDate,\n  isNullish,\n  isNumber,\n  isString,\n} from './type';\nimport type { AnyObject } from './types';\n\n/**\n * 查询字符串解析函数\n * @template T - 解析后返回的对象类型\n * @callback QSReader\n * @param {string} value - 查询字符串的值\n * @param {string} key - 查询字符串的键\n * @param {T} qsObject - 当前解析的对象\n * @returns {unknown} 解析后的值，如果返回 undefined 或 null 则不会添加到对象中\n * @example\n * const parser: QSReader<MyObject> = (value, key, obj) => {\n *   if (key === 'date') return new Date(value);\n *   return value;\n * };\n */\nexport type QSReader<T extends AnyObject> = (\n  value: string,\n  key: string,\n  qsObject: T,\n) => unknown;\n\n/**\n * 解析查询字符串为对象\n * @template T - 返回的对象类型\n * @param {string} queryString - 要解析的查询字符串\n * @param {QSReader<T>} [parser] - 自定义解析函数\n * @returns {T} 解析后的对象\n * @example\n * const obj = qsParse('name=John&age=30');\n * // { name: 'John', age: '30' }\n *\n * const obj2 = qsParse('date=2023-01-01', (val, key) => {\n *   if (key === 'date') return new Date(val);\n *   return val;\n * });\n * // { date: Date('2023-01-01') }\n */\nexport function qsParse<T extends AnyObject>(\n  queryString: string,\n  parser?: QSReader<T>,\n): T {\n  // 添加 globalThis 是便于对接外部环境 URL 的自行实现\n  // 例如在 uni-app、微信小程序等运行环境。\n  const sp = new globalThis.URLSearchParams(queryString.replace(/^.*\\?/, ''));\n  const qsObject = {} as T;\n\n  for (const [key, val] of sp.entries()) {\n    const valFinal = parser ? parser(val, key, qsObject) : val;\n\n    if (isNullish(valFinal)) continue;\n\n    if (Object.hasOwn(qsObject, key)) {\n      // @ts-expect-error\n      if (!isArray(qsObject[key])) qsObject[key] = [qsObject[key]];\n      (qsObject[key] as unknown[]).push(val);\n    } else {\n      // @ts-expect-error\n      qsObject[key] = valFinal;\n    }\n  }\n\n  return qsObject;\n}\n\n/**\n * 查询字符串序列化函数\n * @template T - 要序列化的对象类型\n * @callback QSWriter\n * @param {unknown} value - 要序列化的值\n * @param {string} key - 对象的键\n * @param {T} query - 当前序列化的对象\n * @returns {string | null} 序列化后的字符串，如果返回 null 则忽略该键值对\n * @example\n * const writer: QSWriter<MyObject> = (val, key) => {\n *   if (val instanceof Date) return val.toISOString();\n *   return String(val);\n * };\n */\nexport type QSWriter<T extends AnyObject = AnyObject> = (\n  value: unknown,\n  key: string,\n  query: T,\n) => string | null;\nconst defaultWriter: QSWriter<AnyObject> = (val: unknown) => {\n  if (isString(val)) return val;\n  if (isNumber(val)) return String(val);\n  if (isBoolean(val)) return val ? 'true' : 'false';\n  if (isDate(val)) return val.toISOString();\n  return null;\n};\n\n/**\n * 将对象序列化为查询字符串\n * @template T - 要序列化的对象类型\n * @param {T} qsObject - 要序列化的对象\n * @param {QSWriter<T>} [stringify=defaultWriter] - 自定义序列化函数\n * @returns {string} 序列化后的查询字符串\n * @example\n * const str = qsStringify({ name: 'John', age: 30 });\n * // 'name=John&age=30'\n *\n * const str2 = qsStringify({ date: new Date('2023-01-01') });\n * // 'date=2023-01-01T00:00:00.000Z'\n */\nexport function qsStringify<T extends AnyObject>(\n  qsObject: T,\n  stringify: QSWriter<T> = defaultWriter,\n): string {\n  // 添加 globalThis 是便于对接外部环境 URL 的自行实现\n  // 例如在 uni-app、微信小程序等运行环境。\n  const sp = new globalThis.URLSearchParams();\n  const pushPairs = (val: unknown, key: string) => {\n    const valFinal = stringify(val, String(key), qsObject);\n    if (isNullish(valFinal)) return;\n\n    sp.append(key, valFinal);\n  };\n\n  objectEach(qsObject, (val, key: string) => {\n    if (isArray(val)) {\n      for (const it of val) {\n        pushPairs(it, key);\n      }\n    } else {\n      pushPairs(val, key);\n    }\n  });\n\n  return sp.toString();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA+CA,SAAgB,QACd,aACA,QACG;CAGH,MAAM,KAAK,IAAI,WAAW,gBAAgB,YAAY,QAAQ,SAAS,GAAG,CAAC;CAC3E,MAAM,WAAW,EAAE;CAEnB,KAAK,MAAM,CAAC,KAAK,QAAQ,GAAG,SAAS,EAAE;EACrC,MAAM,WAAW,SAAS,OAAO,KAAK,KAAK,SAAS,GAAG;EAEvD,IAAI,aAAA,UAAU,SAAS,EAAE;EAEzB,IAAI,OAAO,OAAO,UAAU,IAAI,EAAE;GAEhC,IAAI,CAAC,aAAA,QAAQ,SAAS,KAAK,EAAE,SAAS,OAAO,CAAC,SAAS,KAAK;GAC5D,SAAU,KAAmB,KAAK,IAAI;SAGtC,SAAS,OAAO;;CAIpB,OAAO;;AAsBT,IAAM,iBAAsC,QAAiB;CAC3D,IAAI,aAAA,SAAS,IAAI,EAAE,OAAO;CAC1B,IAAI,aAAA,SAAS,IAAI,EAAE,OAAO,OAAO,IAAI;CACrC,IAAI,aAAA,UAAU,IAAI,EAAE,OAAO,MAAM,SAAS;CAC1C,IAAI,aAAA,OAAO,IAAI,EAAE,OAAO,IAAI,aAAa;CACzC,OAAO;;;;;;;;;;;;;;;AAgBT,SAAgB,YACd,UACA,YAAyB,eACjB;CAGR,MAAM,KAAK,IAAI,WAAW,iBAAiB;CAC3C,MAAM,aAAa,KAAc,QAAgB;EAC/C,MAAM,WAAW,UAAU,KAAK,OAAO,IAAI,EAAE,SAAS;EACtD,IAAI,aAAA,UAAU,SAAS,EAAE;EAEzB,GAAG,OAAO,KAAK,SAAS;;CAG1B,eAAA,WAAW,WAAW,KAAK,QAAgB;EACzC,IAAI,aAAA,QAAQ,IAAI,EACd,KAAK,MAAM,MAAM,KACf,UAAU,IAAI,IAAI;OAGpB,UAAU,KAAK,IAAI;GAErB;CAEF,OAAO,GAAG,UAAU"}

package/dist/qs.mjs

@@ -1,47 +1,69 @@
-import { o as objectEach } from "./each.mjs";
-import { isNullish, isArray, isString, isNumber, isBoolean, isDate } from "./type.mjs";
+import { isArray, isBoolean, isDate, isNullish, isNumber, isString } from "./type.mjs";
+import { objectEach } from "./object.mjs";
+//#region src/qs.ts
+/**
+* 解析查询字符串为对象
+* @template T - 返回的对象类型
+* @param {string} queryString - 要解析的查询字符串
+* @param {QSReader<T>} [parser] - 自定义解析函数
+* @returns {T} 解析后的对象
+* @example
+* const obj = qsParse('name=John&age=30');
+* // { name: 'John', age: '30' }
+*
+* const obj2 = qsParse('date=2023-01-01', (val, key) => {
+*   if (key === 'date') return new Date(val);
+*   return val;
+* });
+* // { date: Date('2023-01-01') }
+*/
 function qsParse(queryString, parser) {
-  const sp = new globalThis.URLSearchParams(queryString.replace(/^.*\?/, ""));
-  const qsObject = {};
-  for (const [key, val] of sp.entries()) {
-    const valFinal = parser ? parser(val, key, qsObject) : val;
-    if (isNullish(valFinal)) continue;
-    if (Object.hasOwn(qsObject, key)) {
-      if (!isArray(qsObject[key])) qsObject[key] = [qsObject[key]];
-      qsObject[key].push(val);
-    } else {
-      qsObject[key] = valFinal;
-    }
-  }
-  return qsObject;
+	const sp = new globalThis.URLSearchParams(queryString.replace(/^.*\?/, ""));
+	const qsObject = {};
+	for (const [key, val] of sp.entries()) {
+		const valFinal = parser ? parser(val, key, qsObject) : val;
+		if (isNullish(valFinal)) continue;
+		if (Object.hasOwn(qsObject, key)) {
+			if (!isArray(qsObject[key])) qsObject[key] = [qsObject[key]];
+			qsObject[key].push(val);
+		} else qsObject[key] = valFinal;
+	}
+	return qsObject;
 }
-const defaultWriter = (val) => {
-  if (isString(val)) return val;
-  if (isNumber(val)) return String(val);
-  if (isBoolean(val)) return val ? "true" : "false";
-  if (isDate(val)) return val.toISOString();
-  return null;
+var defaultWriter = (val) => {
+	if (isString(val)) return val;
+	if (isNumber(val)) return String(val);
+	if (isBoolean(val)) return val ? "true" : "false";
+	if (isDate(val)) return val.toISOString();
+	return null;
 };
+/**
+* 将对象序列化为查询字符串
+* @template T - 要序列化的对象类型
+* @param {T} qsObject - 要序列化的对象
+* @param {QSWriter<T>} [stringify=defaultWriter] - 自定义序列化函数
+* @returns {string} 序列化后的查询字符串
+* @example
+* const str = qsStringify({ name: 'John', age: 30 });
+* // 'name=John&age=30'
+*
+* const str2 = qsStringify({ date: new Date('2023-01-01') });
+* // 'date=2023-01-01T00:00:00.000Z'
+*/
 function qsStringify(qsObject, stringify = defaultWriter) {
-  const sp = new globalThis.URLSearchParams();
-  const pushPairs = (val, key) => {
-    const valFinal = stringify(val, String(key), qsObject);
-    if (isNullish(valFinal)) return;
-    sp.append(key, valFinal);
-  };
-  objectEach(qsObject, (val, key) => {
-    if (isArray(val)) {
-      for (const it of val) {
-        pushPairs(it, key);
-      }
-    } else {
-      pushPairs(val, key);
-    }
-  });
-  return sp.toString();
+	const sp = new globalThis.URLSearchParams();
+	const pushPairs = (val, key) => {
+		const valFinal = stringify(val, String(key), qsObject);
+		if (isNullish(valFinal)) return;
+		sp.append(key, valFinal);
+	};
+	objectEach(qsObject, (val, key) => {
+		if (isArray(val)) for (const it of val) pushPairs(it, key);
+		else pushPairs(val, key);
+	});
+	return sp.toString();
 }
-export {
-  qsParse,
-  qsStringify
-};
-//# sourceMappingURL=qs.mjs.map
+//#endregion
+export { qsParse, qsStringify };
+
+//# sourceMappingURL=qs.mjs.map