@gx-design-vue/pro-utils 0.1.4 → 0.2.0-alpha.1

package/dist/is/primitive.d.ts

@@ -0,0 +1,10 @@
+//#region src/is/primitive.d.ts
+/**
+ * 判断是否为原始类型
+ *
+ * @param value - 要判断的值
+ * @returns 是否为原始类型
+ */
+declare function isPrimitive(value: unknown): value is string | number | boolean | null | undefined | symbol | bigint;
+//#endregion
+export { isPrimitive };

package/dist/is/primitive.js

@@ -0,0 +1,13 @@
+//#region src/is/primitive.ts
+/**
+* 判断是否为原始类型
+*
+* @param value - 要判断的值
+* @returns 是否为原始类型
+*/
+function isPrimitive(value) {
+	return value === null || typeof value !== "object" && typeof value !== "function";
+}
+
+//#endregion
+export { isPrimitive };

package/dist/is/server.d.ts

@@ -0,0 +1,9 @@
+//#region src/is/server.d.ts
+/**
+ * 检查是否为服务端环境
+ *
+ * @returns 是否为服务端
+ */
+declare const isServer: boolean;
+//#endregion
+export { isServer };

package/dist/is/server.js

@@ -0,0 +1,10 @@
+//#region src/is/server.ts
+/**
+* 检查是否为服务端环境
+*
+* @returns 是否为服务端
+*/
+const isServer = typeof window === "undefined";
+
+//#endregion
+export { isServer };

package/dist/is/type.d.ts

@@ -0,0 +1,60 @@
+//#region src/is/type.d.ts
+/**
+ * 基础类型判断
+ *
+ * @param val - 要判断的值
+ * @param type - 类型名称
+ * @returns 是否为该类型
+ */
+declare function is(val: unknown, type: string): boolean;
+/**
+ * 判断是否为布尔值
+ *
+ * @param val - 要判断的值
+ * @returns 是否为布尔值
+ */
+declare function isBoolean(val: unknown): val is boolean;
+/**
+ * 判断是否为数字
+ *
+ * @param val - 要判断的值
+ * @returns 是否为数字
+ */
+declare function isNumber(val: unknown): val is number;
+/**
+ * 判断是否为数组
+ *
+ * @param val - 要判断的值
+ * @returns 是否为数组
+ */
+declare function isArray(val: any): val is Array<any>;
+/**
+ * 判断是否为对象
+ *
+ * @param val - 要判断的值
+ * @returns 是否为对象
+ */
+declare function isObject(val: any): val is Record<any, any>;
+/**
+ * 判断是否为字符串
+ *
+ * @param value - 要判断的值
+ * @returns 是否为字符串
+ */
+declare function isString(value: unknown): value is string;
+/**
+ * 判断是否为函数
+ *
+ * @param func - 要判断的值
+ * @returns 是否为函数
+ */
+declare function isFunction(func: unknown): func is (...args: any[]) => any;
+/**
+ * 判断是否为 JSON 字符串
+ *
+ * @param str - 要判断的字符串
+ * @returns 是否为 JSON 字符串
+ */
+declare function isJSONStr(str: any): boolean;
+//#endregion
+export { is, isArray, isBoolean, isFunction, isJSONStr, isNumber, isObject, isString };

package/dist/is/type.js

@@ -0,0 +1,84 @@
+//#region src/is/type.ts
+/**
+* 基础类型判断
+*
+* @param val - 要判断的值
+* @param type - 类型名称
+* @returns 是否为该类型
+*/
+function is(val, type) {
+	return Object.prototype.toString.call(val) === `[object ${type}]`;
+}
+/**
+* 判断是否为布尔值
+*
+* @param val - 要判断的值
+* @returns 是否为布尔值
+*/
+function isBoolean(val) {
+	return typeof val === "boolean";
+}
+/**
+* 判断是否为数字
+*
+* @param val - 要判断的值
+* @returns 是否为数字
+*/
+function isNumber(val) {
+	return typeof val === "number";
+}
+/**
+* 判断是否为数组
+*
+* @param val - 要判断的值
+* @returns 是否为数组
+*/
+function isArray(val) {
+	if (typeof Array.isArray === "undefined") return Object.prototype.toString.call(val) === "[object Array]";
+	return Array.isArray(val);
+}
+/**
+* 判断是否为对象
+*
+* @param val - 要判断的值
+* @returns 是否为对象
+*/
+function isObject(val) {
+	return val !== null && is(val, "Object");
+}
+/**
+* 判断是否为字符串
+*
+* @param value - 要判断的值
+* @returns 是否为字符串
+*/
+function isString(value) {
+	return typeof value === "string";
+}
+/**
+* 判断是否为函数
+*
+* @param func - 要判断的值
+* @returns 是否为函数
+*/
+function isFunction(func) {
+	return typeof func === "function" || Object.prototype.toString.call(func) === "[object Function]";
+}
+/**
+* 判断是否为 JSON 字符串
+*
+* @param str - 要判断的字符串
+* @returns 是否为 JSON 字符串
+*/
+function isJSONStr(str) {
+	if (typeof str !== "string") return false;
+	try {
+		const obj = JSON.parse(str);
+		return typeof obj === "object" && obj !== null;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+export { is, isArray, isBoolean, isFunction, isJSONStr, isNumber, isObject, isString };

package/dist/is/typedArray.d.ts

@@ -0,0 +1,30 @@
+//#region src/is/typedArray.d.ts
+/**
+ * Checks if a value is a TypedArray.
+ * @param {unknown} x The value to check.
+ * @returns {x is
+ *     Uint8Array
+ *   | Uint8ClampedArray
+ *   | Uint16Array
+ *   | Uint32Array
+ *   | BigUint64Array
+ *   | Int8Array
+ *   | Int16Array
+ *   | Int32Array
+ *   | BigInt64Array
+ *   | Float32Array
+ *   | Float64Array} Returns true if `x` is a TypedArray, false otherwise.
+ *
+ * @example
+ * const arr = new Uint8Array([1, 2, 3]);
+ * isTypedArray(arr); // true
+ *
+ * const regularArray = [1, 2, 3];
+ * isTypedArray(regularArray); // false
+ *
+ * const buffer = new ArrayBuffer(16);
+ * isTypedArray(buffer); // false
+ */
+declare function isTypedArray(x: unknown): x is Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | BigUint64Array | Int8Array | Int16Array | Int32Array | BigInt64Array | Float32Array | Float64Array;
+//#endregion
+export { isTypedArray };

package/dist/is/typedArray.js

@@ -0,0 +1,33 @@
+//#region src/is/typedArray.ts
+/**
+* Checks if a value is a TypedArray.
+* @param {unknown} x The value to check.
+* @returns {x is
+*     Uint8Array
+*   | Uint8ClampedArray
+*   | Uint16Array
+*   | Uint32Array
+*   | BigUint64Array
+*   | Int8Array
+*   | Int16Array
+*   | Int32Array
+*   | BigInt64Array
+*   | Float32Array
+*   | Float64Array} Returns true if `x` is a TypedArray, false otherwise.
+*
+* @example
+* const arr = new Uint8Array([1, 2, 3]);
+* isTypedArray(arr); // true
+*
+* const regularArray = [1, 2, 3];
+* isTypedArray(regularArray); // false
+*
+* const buffer = new ArrayBuffer(16);
+* isTypedArray(buffer); // false
+*/
+function isTypedArray(x) {
+	return ArrayBuffer.isView(x) && !(x instanceof DataView);
+}
+
+//#endregion
+export { isTypedArray };

package/dist/is/unsafeProperty.d.ts

@@ -0,0 +1,10 @@
+//#region src/is/unsafeProperty.d.ts
+/**
+ * 检查属性名是否为不安全的属性名（原型链上的属性或构造函数）
+ *
+ * @param property - 属性名
+ * @returns 是否为不安全的属性名
+ */
+declare function isUnsafeProperty(property: string | symbol): boolean;
+//#endregion
+export { isUnsafeProperty };

package/dist/is/unsafeProperty.js

@@ -0,0 +1,18 @@
+//#region src/is/unsafeProperty.ts
+/**
+* 检查属性名是否为不安全的属性名（原型链上的属性或构造函数）
+*
+* @param property - 属性名
+* @returns 是否为不安全的属性名
+*/
+function isUnsafeProperty(property) {
+	if (typeof property === "symbol") return false;
+	return [
+		"__proto__",
+		"constructor",
+		"prototype"
+	].includes(property);
+}
+
+//#endregion
+export { isUnsafeProperty };

package/dist/is/url.d.ts

@@ -0,0 +1,10 @@
+//#region src/is/url.d.ts
+/**
+ * 判断是否为 URL
+ *
+ * @param path - 路径
+ * @returns 是否为 URL
+ */
+declare function isUrl(path: string | undefined): boolean;
+//#endregion
+export { isUrl };

package/dist/is/url.js

@@ -0,0 +1,20 @@
+//#region src/is/url.ts
+/**
+* 判断是否为 URL
+*
+* @param path - 路径
+* @returns 是否为 URL
+*/
+function isUrl(path) {
+	if (!path) return false;
+	if (!path.startsWith("http")) return false;
+	try {
+		return !!new URL(path);
+	} catch (_) {
+		console.error("isUrl error", _);
+		return false;
+	}
+}
+
+//#endregion
+export { isUrl };

package/dist/is/valid.d.ts

@@ -0,0 +1,17 @@
+//#region src/is/valid.d.ts
+/**
+ * 判断值是否有效（不为 undefined、null 或空字符串）
+ *
+ * @param value - 要判断的值
+ * @returns 是否有效
+ */
+declare function isValid(value: any): boolean;
+/**
+ * 将值转换为布尔值
+ *
+ * @param value - 要转换的值
+ * @returns 转换后的布尔值
+ */
+declare function convertValueBoolean(value: any): boolean;
+//#endregion
+export { convertValueBoolean, isValid };

package/dist/is/valid.js

@@ -0,0 +1,23 @@
+//#region src/is/valid.ts
+/**
+* 判断值是否有效（不为 undefined、null 或空字符串）
+*
+* @param value - 要判断的值
+* @returns 是否有效
+*/
+function isValid(value) {
+	return value !== void 0 && value !== null && value !== "";
+}
+/**
+* 将值转换为布尔值
+*
+* @param value - 要转换的值
+* @returns 转换后的布尔值
+*/
+function convertValueBoolean(value) {
+	if (typeof value === "boolean") return value;
+	return !!value;
+}
+
+//#endregion
+export { convertValueBoolean, isValid };

package/dist/merge/index.d.ts

@@ -1,7 +1,21 @@
+import { useDeepMerge } from "./useDeepMege.js";
+import { mergeWith } from "./mergeWith.js";
+
+//#region src/merge/index.d.ts
 /**
- * 用于合并 n 个对象
- * @param  {any[]} ...rest
- * @returns T
+ * 合并多个对象
+ *
+ * @param rest - 要合并的对象
+ * @returns 合并后的对象
  */
-declare const merge: <T>(...rest: any[]) => T;
-export { merge };
+declare function merge<T = any>(...rest: any[]): T;
+/**
+ * 深度合并对象
+ *
+ * @param target - 目标对象
+ * @param source - 源对象(一般是 default 对象)
+ * @returns 合并后的对象
+ */
+declare function deepMerge<T extends Record<PropertyKey, any>, S extends Record<PropertyKey, any>>(target: T, source: S): T & S;
+//#endregion
+export { deepMerge, merge, mergeWith, useDeepMerge };

package/dist/merge/index.js

@@ -0,0 +1,42 @@
+import { isPlainObject } from "../is/plainObject.js";
+import "../is/index.js";
+import { cloneDeep } from "../clone/cloneDeep.js";
+import "../clone/index.js";
+import { mergeWith } from "./mergeWith.js";
+import { useDeepMerge } from "./useDeepMege.js";
+
+//#region src/merge/index.ts
+/**
+* 合并多个对象
+*
+* @param rest - 要合并的对象
+* @returns 合并后的对象
+*/
+function merge(...rest) {
+	const obj = {};
+	const il = rest.length;
+	let key;
+	let i = 0;
+	for (; i < il; i += 1) for (key in rest[i]) if (Object.prototype.hasOwnProperty.call(rest[i], key)) if (typeof obj[key] === "object" && typeof rest[i][key] === "object" && obj[key] !== void 0 && obj[key] !== null && !Array.isArray(obj[key]) && !Array.isArray(rest[i][key])) obj[key] = {
+		...obj[key],
+		...rest[i][key]
+	};
+	else obj[key] = rest[i][key];
+	return obj;
+}
+/**
+* 深度合并对象
+*
+* @param target - 目标对象
+* @param source - 源对象(一般是 default 对象)
+* @returns 合并后的对象
+*/
+function deepMerge(target, source) {
+	return mergeWith(cloneDeep(target), source, function mergeRecursively(targetValue, sourceValue) {
+		if (isPlainObject(sourceValue)) if (isPlainObject(targetValue)) return mergeWith(cloneDeep(targetValue), sourceValue, mergeRecursively);
+		else return mergeWith({}, sourceValue, mergeRecursively);
+	});
+}
+
+//#endregion
+export { deepMerge, merge, mergeWith, useDeepMerge };

package/dist/merge/mergeWith.d.ts

@@ -0,0 +1,12 @@
+//#region src/merge/mergeWith.d.ts
+/**
+ * 合并对象（带自定义处理）
+ *
+ * @param target - 目标对象
+ * @param source - 源对象
+ * @param merge - 自定义合并函数
+ * @returns 合并后的对象
+ */
+declare function mergeWith<T extends Record<PropertyKey, any>, S extends Record<PropertyKey, any>>(target: T, source: S, merge: (targetValue: any, sourceValue: any, key: string, target: T, source: S) => any): T & S;
+//#endregion
+export { mergeWith };

package/dist/merge/mergeWith.js

@@ -0,0 +1,31 @@
+import { isPlainObject } from "../is/plainObject.js";
+import { isUnsafeProperty } from "../is/unsafeProperty.js";
+import "../is/index.js";
+
+//#region src/merge/mergeWith.ts
+/**
+* 合并对象（带自定义处理）
+*
+* @param target - 目标对象
+* @param source - 源对象
+* @param merge - 自定义合并函数
+* @returns 合并后的对象
+*/
+function mergeWith(target, source, merge) {
+	const sourceKeys = Object.keys(source);
+	for (let i = 0; i < sourceKeys.length; i++) {
+		const key = sourceKeys[i];
+		if (isUnsafeProperty(key)) continue;
+		const sourceValue = source[key];
+		const targetValue = target[key];
+		const merged = merge(targetValue, sourceValue, key, target, source);
+		if (merged !== void 0) target[key] = merged;
+		else if (isPlainObject(sourceValue)) if (isPlainObject(targetValue)) target[key] = mergeWith(targetValue, sourceValue, merge);
+		else target[key] = mergeWith({}, sourceValue, merge);
+		else target[key] = sourceValue;
+	}
+	return target;
+}
+
+//#endregion
+export { mergeWith };

package/dist/merge/useDeepMege.d.ts

@@ -0,0 +1,46 @@
+//#region src/merge/useDeepMege.d.ts
+/**
+ * Merges the properties of the source object into a deep clone of the target object.
+ * Unlike `merge`, This function does not modify the original target object.
+ *
+ * This function performs a deep merge, meaning nested objects and arrays are merged recursively.
+ *
+ * - If a property in the source object is an array or object and the corresponding property in the target object is also an array or object, they will be merged.
+ * - If a property in the source object is undefined, it will not overwrite a defined property in the target object.
+ *
+ * Note that this function does not mutate the target object.
+ *
+ * @param {T} target - The target object to be cloned and merged into. This object is not modified directly.
+ * @param {S} source - The source object whose properties will be merged into the cloned target object.
+ * @returns {T & S} A new object with properties from the source object merged into a deep clone of the target object.
+ *
+ * @template T - Type of the target object.
+ * @template S - Type of the source object.
+ *
+ * @example
+ * const target = { a: 1, b: { x: 1, y: 2 } };
+ * const source = { b: { y: 3, z: 4 }, c: 5 };
+ *
+ * const result = toMerged(target, source);
+ * console.log(result);
+ * // Output: { a: 1, b: { x: 1, y: 3, z: 4 }, c: 5 }
+ *
+ * @example
+ * const target = { a: [1, 2], b: { x: 1 } };
+ * const source = { a: [3], b: { y: 2 } };
+ *
+ * const result = toMerged(target, source);
+ * console.log(result);
+ * // Output: { a: [3, 2], b: { x: 1, y: 2 } }
+ *
+ * @example
+ * const target = { a: null };
+ * const source = { a: [1, 2, 3] };
+ *
+ * const result = toMerged(target, source);
+ * console.log(result);
+ * // Output: { a: [1, 2, 3] }
+ */
+declare function useDeepMerge<T extends Record<PropertyKey, any>, S extends Record<PropertyKey, any>>(target: T, source: S): T & S;
+//#endregion
+export { useDeepMerge };

package/dist/merge/useDeepMege.js

@@ -0,0 +1,56 @@
+import { isPlainObject } from "../is/plainObject.js";
+import "../is/index.js";
+import { mergeWith } from "./mergeWith.js";
+
+//#region src/merge/useDeepMege.ts
+/**
+* Merges the properties of the source object into a deep clone of the target object.
+* Unlike `merge`, This function does not modify the original target object.
+*
+* This function performs a deep merge, meaning nested objects and arrays are merged recursively.
+*
+* - If a property in the source object is an array or object and the corresponding property in the target object is also an array or object, they will be merged.
+* - If a property in the source object is undefined, it will not overwrite a defined property in the target object.
+*
+* Note that this function does not mutate the target object.
+*
+* @param {T} target - The target object to be cloned and merged into. This object is not modified directly.
+* @param {S} source - The source object whose properties will be merged into the cloned target object.
+* @returns {T & S} A new object with properties from the source object merged into a deep clone of the target object.
+*
+* @template T - Type of the target object.
+* @template S - Type of the source object.
+*
+* @example
+* const target = { a: 1, b: { x: 1, y: 2 } };
+* const source = { b: { y: 3, z: 4 }, c: 5 };
+*
+* const result = toMerged(target, source);
+* console.log(result);
+* // Output: { a: 1, b: { x: 1, y: 3, z: 4 }, c: 5 }
+*
+* @example
+* const target = { a: [1, 2], b: { x: 1 } };
+* const source = { a: [3], b: { y: 2 } };
+*
+* const result = toMerged(target, source);
+* console.log(result);
+* // Output: { a: [3, 2], b: { x: 1, y: 2 } }
+*
+* @example
+* const target = { a: null };
+* const source = { a: [1, 2, 3] };
+*
+* const result = toMerged(target, source);
+* console.log(result);
+* // Output: { a: [1, 2, 3] }
+*/
+function useDeepMerge(target, source) {
+	return mergeWith(target, source, function mergeRecursively(targetValue, sourceValue) {
+		if (isPlainObject(sourceValue)) if (isPlainObject(targetValue)) return mergeWith(targetValue, sourceValue, mergeRecursively);
+		else return mergeWith({}, sourceValue, mergeRecursively);
+	});
+}
+
+//#endregion
+export { useDeepMerge };

package/dist/number/chinese.d.ts

@@ -0,0 +1,10 @@
+//#region src/number/chinese.d.ts
+/**
+ * 数字转中文
+ *
+ * @param num - 要转换的数字
+ * @returns 中文数字
+ */
+declare function toChinesNum(num: number): string;
+//#endregion
+export { toChinesNum };

package/dist/number/chinese.js

@@ -0,0 +1,46 @@
+import { isNumber } from "../is/type.js";
+import "../is/index.js";
+
+//#region src/number/chinese.ts
+/**
+* 数字转中文
+*
+* @param num - 要转换的数字
+* @returns 中文数字
+*/
+function toChinesNum(num) {
+	num = isNumber(num) && !Number.isNaN(num) ? num : 0;
+	const changeNum = [
+		"零",
+		"一",
+		"二",
+		"三",
+		"四",
+		"五",
+		"六",
+		"七",
+		"八",
+		"九"
+	];
+	const unit = [
+		"",
+		"十",
+		"百",
+		"千",
+		"万"
+	];
+	num = Number.parseInt(`${num}`);
+	const getWan = (temp) => {
+		const strArr = temp.toString().split("").reverse();
+		let newNum = "";
+		for (let i = 0; i < strArr.length; i++) newNum = (i === 0 && strArr[i] === "0" ? "" : i > 0 && strArr[i] === "0" && strArr[i - 1] === "0" ? "" : (num < 20 && i > 0 ? "" : changeNum[strArr[i]]) + (strArr[i] === "0" ? unit[0] : unit[i])) + newNum;
+		return newNum;
+	};
+	const overWan = Math.floor(num / 1e4);
+	let noWan = num % 1e4;
+	if (noWan.toString().length < 4) noWan = `0${noWan}`;
+	return overWan ? `${getWan(overWan)}万${getWan(noWan)}` : getWan(num);
+}
+
+//#endregion
+export { toChinesNum };

package/dist/number/format.d.ts

@@ -0,0 +1,27 @@
+//#region src/number/format.d.ts
+/**
+ * 格式化数字，保留指定小数位
+ *
+ * @param fixedNum - 小数位数
+ * @param value - 要格式化的值
+ * @returns 格式化后的字符串
+ */
+declare function formatNumber(fixedNum: number, value: number): string;
+/**
+ * 转换数字为带单位的显示格式
+ *
+ * @param number - 要转换的数字
+ * @param options - 配置选项
+ * @returns 转换结果
+ */
+declare function toConvertNumberShow(number: number, options?: {
+  toChinese?: boolean;
+  fixed?: number;
+  min?: number;
+}): {
+  str: string;
+  number: string;
+  unit?: string;
+};
+//#endregion
+export { formatNumber, toConvertNumberShow };