@pawover/kit 0.0.1 → 0.1.1

package/packages/utils/dist/{string-DCWqoW4P.js → string-p6hZ1Mjb.js}

@@ -1,4 +1,4 @@
-//#region \0@oxc-project+runtime@0.129.0/helpers/typeof.js
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/typeof.js
 function _typeof(o) {
 	"@babel/helpers - typeof";
 	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
@@ -8,7 +8,7 @@ function _typeof(o) {
 	}, _typeof(o);
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.129.0/helpers/toPrimitive.js
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/toPrimitive.js
 function toPrimitive(t, r) {
 	if ("object" != _typeof(t) || !t) return t;
 	var e = t[Symbol.toPrimitive];
@@ -20,13 +20,13 @@ function toPrimitive(t, r) {
 	return ("string" === r ? String : Number)(t);
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.129.0/helpers/toPropertyKey.js
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/toPropertyKey.js
 function toPropertyKey(t) {
 	var i = toPrimitive(t, "string");
 	return "symbol" == _typeof(i) ? i : i + "";
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.129.0/helpers/defineProperty.js
+//#region \0@oxc-project+runtime@0.133.0/helpers/esm/defineProperty.js
 function _defineProperty(e, r, t) {
 	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
 		value: t,
@@ -60,25 +60,29 @@ var TypeUtil = class {
 	}
 	/**
 	* 检查 value 是否为 string 类型
+	* - 当 `checkEmpty` 为 `true` 时，会先 trim 再判断是否为空
 	*
 	* @param value 待检查值
-	* @param checkEmpty 是否检查空字符串
+	* @param checkEmpty 是否检查空字符串（含空白字符串），默认为 `false`
 	* @returns 是否为字符串
 	* @example
 	* ```ts
 	* TypeUtil.isString("abc"); // true
 	* TypeUtil.isString(""); // true
 	* TypeUtil.isString("", true); // false
+	* TypeUtil.isString("   ", true); // false
+	* TypeUtil.isString(" a ", true); // true
 	* ```
 	*/
 	static isString(value, checkEmpty = false) {
-		return typeof value === "string" && (!checkEmpty || !!value.length);
+		return typeof value === "string" && (!checkEmpty || value.trim().length > 0);
 	}
 	/**
 	* 检查 value 是否为 number 类型
+	* - 默认会调用 `TypeUtil.isNaN`（内部基于 `Number.isNaN`）过滤掉 `NaN`
 	*
 	* @param value 待检查值
-	* @param checkNaN 是否排除 `NaN`，默认为 `true`
+	* @param checkNaN 是否检查 `NaN`，默认为 `true`
 	* @returns 是否为 number
 	* @example
 	* ```ts
@@ -92,9 +96,15 @@ var TypeUtil = class {
 	}
 	/**
 	* 检查 value 是否为 NaN
+	* - 禁止使用全局 `isNaN`，其会先进行隐式数字转换，可能导致误判（例如 `isNaN("foo") === true`）
+	* - 使用 `Number.isNaN` 仅在值本身就是 `NaN` 时返回 `true`，语义更严格且更安全
 	*
 	* @param value 待检查值
 	* @returns 是否为 NaN
+	* @example
+	* ```ts
+	* TypeUtil.isNaN(NaN); // true
+	* ```
 	*/
 	static isNaN(value) {
 		return Number.isNaN(value);
@@ -105,6 +115,11 @@ var TypeUtil = class {
 	* @param value 待检查值
 	* @param checkSafe 是否附加安全整数检查
 	* @returns 是否为整数
+	* @example
+	* ```ts
+	* TypeUtil.isInteger(1); // true
+	* TypeUtil.isInteger(1.1); // false
+	* ```
 	*/
 	static isInteger(value, checkSafe = true) {
 		const check = Number.isInteger(value);
@@ -116,6 +131,11 @@ var TypeUtil = class {
 	*
 	* @param value 待检查值
 	* @param checkSafe 是否附加安全整数检查
+	* @example
+	* ```ts
+	* TypeUtil.isPositiveInteger(1); // true
+	* TypeUtil.isPositiveInteger(0); // false
+	* ```
 	*/
 	static isPositiveInteger(value, checkSafe = true) {
 		return this.isInteger(value, checkSafe) && value > 0;
@@ -126,6 +146,11 @@ var TypeUtil = class {
 	*
 	* @param value 待检查值
 	* @param checkSafe 是否附加安全整数检查
+	* @example
+	* ```ts
+	* TypeUtil.isNegativeInteger(-1); // true
+	* TypeUtil.isNegativeInteger(0); // false
+	* ```
 	*/
 	static isNegativeInteger(value, checkSafe = true) {
 		return this.isInteger(value, checkSafe) && value < 0;
@@ -135,6 +160,11 @@ var TypeUtil = class {
 	* - 排除 `NaN`
 	*
 	* @param value 待检查值
+	* @example
+	* ```ts
+	* TypeUtil.isInfinity(Infinity); // true
+	* TypeUtil.isInfinity(1); // false
+	* ```
 	*/
 	static isInfinity(value) {
 		return this.isNumber(value) && (Number.POSITIVE_INFINITY === value || Number.NEGATIVE_INFINITY === value);
@@ -144,6 +174,11 @@ var TypeUtil = class {
 	* - 排除 `NaN`
 	*
 	* @param value 待检查值
+	* @example
+	* ```ts
+	* TypeUtil.isInfinityLike("Infinity"); // true
+	* TypeUtil.isInfinityLike("123"); // false
+	* ```
 	*/
 	static isInfinityLike(value) {
 		const check = this.isInfinity(value);
@@ -162,6 +197,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 Boolean
 	* @param value 待检查值
 	* @returns 是否为 Boolean
+	* @example
+	* ```ts
+	* TypeUtil.isBoolean(false); // true
+	* ```
 	*/
 	static isBoolean(value) {
 		return typeof value === "boolean";
@@ -170,6 +209,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 BigInt
 	* @param value 待检查值
 	* @returns 是否为 BigInt
+	* @example
+	* ```ts
+	* TypeUtil.isBigInt(1n); // true
+	* ```
 	*/
 	static isBigInt(value) {
 		return typeof value === "bigint";
@@ -178,6 +221,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 Symbol
 	* @param value 待检查值
 	* @returns 是否为 Symbol
+	* @example
+	* ```ts
+	* TypeUtil.isSymbol(Symbol("a")); // true
+	* ```
 	*/
 	static isSymbol(value) {
 		return typeof value === "symbol";
@@ -186,6 +233,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 undefined
 	* @param value 待检查值
 	* @returns 是否为 undefined
+	* @example
+	* ```ts
+	* TypeUtil.isUndefined(undefined); // true
+	* ```
 	*/
 	static isUndefined(value) {
 		return typeof value === "undefined";
@@ -194,6 +245,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 null
 	* @param value 待检查值
 	* @returns 是否为 null
+	* @example
+	* ```ts
+	* TypeUtil.isNull(null); // true
+	* ```
 	*/
 	static isNull(value) {
 		return value === null;
@@ -202,6 +257,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 Function
 	* @param value 待检查值
 	* @returns 是否为 Function
+	* @example
+	* ```ts
+	* TypeUtil.isFunction(() => {}); // true
+	* ```
 	*/
 	static isFunction(value) {
 		return typeof value === "function";
@@ -210,6 +269,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 AsyncFunction
 	* @param value 待检查值
 	* @returns 是否为 AsyncFunction
+	* @example
+	* ```ts
+	* TypeUtil.isAsyncFunction(async () => {}); // true
+	* ```
 	*/
 	static isAsyncFunction(value) {
 		return this.isFunction(value) && this.getPrototypeString(value) === this.PROTOTYPE_TAGS.ASYNC_FUNCTION;
@@ -218,6 +281,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 GeneratorFunction
 	* @param value 待检查值
 	* @returns 是否为 GeneratorFunction
+	* @example
+	* ```ts
+	* TypeUtil.isGeneratorFunction(function * a () {}); // true
+	* ```
 	*/
 	static isGeneratorFunction(value) {
 		return this.isFunction(value) && this.getPrototypeString(value) === this.PROTOTYPE_TAGS.GENERATOR_FUNCTION;
@@ -226,6 +293,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 AsyncGeneratorFunction
 	* @param value 待检查值
 	* @returns 是否为 AsyncGeneratorFunction
+	* @example
+	* ```ts
+	* TypeUtil.isAsyncGeneratorFunction(async function * a () {}); // true
+	* ```
 	*/
 	static isAsyncGeneratorFunction(value) {
 		return this.isFunction(value) && this.getPrototypeString(value) === this.PROTOTYPE_TAGS.ASYNC_GENERATOR_FUNCTION;
@@ -234,6 +305,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 Promise
 	* @param value 待检查值
 	* @returns 是否为 Promise
+	* @example
+	* ```ts
+	* TypeUtil.isPromise(Promise.resolve(1)); // true
+	* ```
 	*/
 	static isPromise(value) {
 		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.PROMISE;
@@ -243,6 +318,10 @@ var TypeUtil = class {
 	* - 可识别拥有 then 方法的非 Promise 对象
 	* @param value 待检查值
 	* @returns 是否为 PromiseLike
+	* @example
+	* ```ts
+	* TypeUtil.isPromiseLike({ then: () => {} }); // true
+	* ```
 	*/
 	static isPromiseLike(value) {
 		return this.isPromise(value) || this.isObject(value, false) && this.isFunction(value["then"]);
@@ -278,6 +357,11 @@ var TypeUtil = class {
 	*
 	* @param enumeration 待检查值
 	* @returns [是否为有效的枚举, 是否为双向枚举]
+	* @example
+	* ```ts
+	* enum A { X, Y }
+	* TypeUtil.isEnumeration(A); // [true, true]
+	* ```
 	*/
 	static isEnumeration(enumeration) {
 		if (typeof enumeration !== "object" || enumeration === null) return [false, false];
@@ -359,6 +443,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 Map
 	* @param value 待检查值
 	* @returns 是否为 Map
+	* @example
+	* ```ts
+	* TypeUtil.isMap(new Map()); // true
+	* ```
 	*/
 	static isMap(value) {
 		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.MAP;
@@ -367,6 +455,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 WeakMap
 	* @param value 待检查值
 	* @returns 是否为 WeakMap
+	* @example
+	* ```ts
+	* TypeUtil.isWeakMap(new WeakMap()); // true
+	* ```
 	*/
 	static isWeakMap(value) {
 		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.WEAK_MAP;
@@ -375,6 +467,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 Set
 	* @param value 待检查值
 	* @returns 是否为 Set
+	* @example
+	* ```ts
+	* TypeUtil.isSet(new Set()); // true
+	* ```
 	*/
 	static isSet(value) {
 		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.SET;
@@ -383,6 +479,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 WeakSet
 	* @param value 待检查值
 	* @returns 是否为 WeakSet
+	* @example
+	* ```ts
+	* TypeUtil.isWeakSet(new WeakSet()); // true
+	* ```
 	*/
 	static isWeakSet(value) {
 		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.WEAK_SET;
@@ -391,6 +491,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 Blob
 	* @param value 待检查值
 	* @returns 是否为 Blob
+	* @example
+	* ```ts
+	* TypeUtil.isBlob(new Blob(["a"])); // true
+	* ```
 	*/
 	static isBlob(value) {
 		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.BLOB;
@@ -399,6 +503,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 File
 	* @param value 待检查值
 	* @returns 是否为 File
+	* @example
+	* ```ts
+	* TypeUtil.isFile(new File(["a"], "a.txt")); // true
+	* ```
 	*/
 	static isFile(value) {
 		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.FILE;
@@ -412,6 +520,10 @@ var TypeUtil = class {
 	*
 	* @param value 待检查值
 	* @returns 是否为 ReadableStream
+	* @example
+	* ```ts
+	* TypeUtil.isReadableStream(new ReadableStream()); // true
+	* ```
 	*/
 	static isReadableStream(value) {
 		if (this.getPrototypeString(value) === this.PROTOTYPE_TAGS.READABLE_STREAM) return true;
@@ -421,6 +533,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 Window
 	* @param value 待检查值
 	* @returns 是否为 Window
+	* @example
+	* ```ts
+	* TypeUtil.isWindow(window); // true
+	* ```
 	*/
 	static isWindow(value) {
 		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.WINDOW;
@@ -429,6 +545,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 HTMLIFrameElement
 	* @param value 待检查值
 	* @returns 是否为 HTMLIFrameElement
+	* @example
+	* ```ts
+	* TypeUtil.isIframe(document.createElement("iframe")); // true
+	* ```
 	*/
 	static isIframe(value) {
 		if (typeof window === "undefined") return false;
@@ -467,6 +587,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 Error 对象
 	* @param value 待检查值
 	* @returns 是否为 Error
+	* @example
+	* ```ts
+	* TypeUtil.isError(new Error("x")); // true
+	* ```
 	*/
 	static isError(value) {
 		return value instanceof Error || this.getPrototypeString(value) === this.PROTOTYPE_TAGS.ERROR;
@@ -475,6 +599,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 RegExp
 	* @param value 待检查值
 	* @returns 是否为 RegExp
+	* @example
+	* ```ts
+	* TypeUtil.isRegExp(/a/); // true
+	* ```
 	*/
 	static isRegExp(value) {
 		if (typeof value !== "object" || value === null) return false;
@@ -489,6 +617,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 WebSocket
 	* @param value 待检查值
 	* @returns 是否为 WebSocket
+	* @example
+	* ```ts
+	* TypeUtil.isWebSocket(new WebSocket("wss://echo.websocket.events")); // true
+	* ```
 	*/
 	static isWebSocket(value) {
 		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.WEB_SOCKET;
@@ -497,6 +629,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 URLSearchParams
 	* @param value 待检查值
 	* @returns 是否为 URLSearchParams
+	* @example
+	* ```ts
+	* TypeUtil.isURLSearchParams(new URLSearchParams("a=1")); // true
+	* ```
 	*/
 	static isURLSearchParams(value) {
 		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.URL_SEARCH_PARAMS;
@@ -505,6 +641,10 @@ var TypeUtil = class {
 	* 检查 value 是否为 AbortSignal
 	* @param value 待检查值
 	* @returns 是否为 AbortSignal
+	* @example
+	* ```ts
+	* TypeUtil.isAbortSignal(new AbortController().signal); // true
+	* ```
 	*/
 	static isAbortSignal(value) {
 		return this.getPrototypeString(value) === this.PROTOTYPE_TAGS.ABORT_SIGNAL;
@@ -513,6 +653,10 @@ var TypeUtil = class {
 	* 检查 value 是否为可迭代对象 (Iterable)
 	* @param value 待检查值
 	* @returns 是否为 Iterable
+	* @example
+	* ```ts
+	* TypeUtil.isIterable([1, 2]); // true
+	* ```
 	*/
 	static isIterable(value) {
 		return !!value && typeof value[Symbol.iterator] === "function";
@@ -521,11 +665,27 @@ var TypeUtil = class {
 	* 检查 value 是否为 Falsy 值 (false, 0, "", null, undefined, NaN)
 	* @param value 待检查值
 	* @returns 是否为 Falsy
+	* @example
+	* ```ts
+	* TypeUtil.isFalsy(0); // true
+	* ```
 	*/
 	static isFalsy(value) {
 		if (this.isNaN(value) || this.isNull(value) || this.isUndefined(value)) return true;
 		return value === false || value === 0 || value === 0n || value === "";
 	}
+	/**
+	* 检查 value 是否为 FalsyLike 值
+	* - 包含字符串形式的 `"null"`、`"undefined"`、`"false"`、`"0"` 等
+	*
+	* @param value 待检查值
+	* @returns 是否为 FalsyLike
+	* @example
+	* ```ts
+	* TypeUtil.isFalsyLike("false"); // true
+	* TypeUtil.isFalsyLike("hello"); // false
+	* ```
+	*/
 	static isFalsyLike(value) {
 		if (this.isFalsy(value)) return true;
 		return typeof value === "string" && (value === "null" || value === "undefined" || value === "NaN" || value === "false" || value === "0" || value === "-0" || value === "0n");
@@ -581,6 +741,13 @@ _defineProperty(TypeUtil, "TYPED_ARRAY_TAGS", new Set([
 * 字符串工具类
 */
 var StringUtil = class {
+	static cast(candidate, checkEmpty = true) {
+		if (checkEmpty) {
+			if (candidate === null || candidate === void 0) return "";
+			if (typeof candidate === "string" && candidate.trim().length === 0) return "";
+		}
+		return String(candidate);
+	}
 	/**
 	* 从字符串中提取数字字符串
 	* - 移除非数字字符，保留符号和小数点

package/packages/utils/dist/vite.d.ts

@@ -9,6 +9,19 @@ declare class ViteUtil {
    * 开发服务器反向代理配置
    *
    * @param proxyList 代理配置项
+   * @param options 追加到每个代理项的 Vite `ProxyOptions`
+   * @returns Vite `server.proxy` 可直接使用的配置对象
+   * @example
+   * ```ts
+   * ViteUtil.toProxy([
+   *   ["/api", "http://localhost:3000"],
+   *   ["/mock", "https://example.com"],
+   * ]);
+   * // {
+   * //   "/api": { target: "http://localhost:3000", changeOrigin: true, ws: true, rewrite: [Function] },
+   * //   "/mock": { target: "https://example.com", changeOrigin: true, ws: true, secure: false, rewrite: [Function] }
+   * // }
+   * ```
    */
   static toProxy<L extends [string, string][]>(proxyList: L, options?: ProxyOptions | undefined): Record<string, ProxyOptions>;
 }

package/packages/utils/dist/vite.js

@@ -7,6 +7,19 @@ var ViteUtil = class {
 	* 开发服务器反向代理配置
 	*
 	* @param proxyList 代理配置项
+	* @param options 追加到每个代理项的 Vite `ProxyOptions`
+	* @returns Vite `server.proxy` 可直接使用的配置对象
+	* @example
+	* ```ts
+	* ViteUtil.toProxy([
+	*   ["/api", "http://localhost:3000"],
+	*   ["/mock", "https://example.com"],
+	* ]);
+	* // {
+	* //   "/api": { target: "http://localhost:3000", changeOrigin: true, ws: true, rewrite: [Function] },
+	* //   "/mock": { target: "https://example.com", changeOrigin: true, ws: true, secure: false, rewrite: [Function] }
+	* // }
+	* ```
 	*/
 	static toProxy(proxyList, options) {
 		const httpsRE = /^https:\/\//;