@mi-avalon/libs 1.0.3 → 1.0.5

package/dist/utils/util.d.ts

@@ -1,6 +1,56 @@
 export declare const noop: () => void;
-export declare const getClassName: (key1: string, key2: string) => string;
-export declare const getFieldsByPath: (data: any, path: string) => any;
-export declare const removeNull: (obj: any) => any;
-export declare const debounce: (func: any, wait: number) => (...args: any[]) => void;
-export declare const throttle: (func: any, wait: number) => (...args: any[]) => void;
+/**
+ * 生成类名 - 优化版本，支持空值处理和多修饰符
+ */
+export declare const getClassName: (key1: string, key2?: string) => string;
+/**
+ * 根据路径安全获取嵌套对象数据
+ * @param data 源对象
+ * @param path 路径字符串，支持点号分隔
+ * @param defaultValue 默认值，当路径不存在时返回
+ * @returns 获取到的值或默认值
+ */
+export declare const getFieldsByPath: <T = any>(data: any, path: string, defaultValue?: T) => T;
+/**
+ * 清理对象中的空值（null 和 undefined）
+ * @param obj 要清理的对象
+ * @param includeEmptyString 是否包含空字符串，默认false
+ * @param includeZero 是否包含0，默认false
+ * @returns 清理后的对象
+ */
+export declare const removeNull: <T extends Record<string, any>>(obj: T, includeEmptyString?: boolean, includeZero?: boolean) => Partial<T>;
+/**
+ * 防抖函数 - 增强版本，支持取消和立即执行
+ * @param func 要防抖的函数
+ * @param wait 等待时间（毫秒）
+ * @param options 选项配置
+ * @returns 防抖后的函数
+ */
+export declare const debounce: <T extends (...args: any[]) => any>(func: T, wait: number, options?: {
+    leading?: boolean;
+    trailing?: boolean;
+    maxWait?: number;
+}) => ((...args: Parameters<T>) => void) & {
+    cancel: () => void;
+    flush: () => void;
+};
+/**
+ * 节流函数 - 增强版本，支持选项配置
+ * @param func 要节流的函数
+ * @param wait 等待时间（毫秒）
+ * @param options 选项配置
+ * @returns 节流后的函数
+ */
+export declare const throttle: <T extends (...args: any[]) => any>(func: T, wait: number, options?: {
+    leading?: boolean;
+    trailing?: boolean;
+}) => ((...args: Parameters<T>) => void) & {
+    cancel: () => void;
+    flush: () => void;
+};
+/**
+ * 深度克隆对象
+ * @param obj 要克隆的对象
+ * @returns 克隆后的对象
+ */
+export declare const deepClone: <T>(obj: T) => T;

package/dist/utils/util.js

@@ -1,69 +1,268 @@
 export const noop = () => { };
-// 生成类名
+/**
+ * 生成类名 - 优化版本，支持空值处理和多修饰符
+ */
 export const getClassName = (key1, key2) => {
-    const cn = key1;
-    let str = key1;
-    if (key2.includes(' ')) {
-        str = '';
-        const nArr = key2?.split(' ');
-        for (const i of nArr) {
-            str += ` ${cn}-${i}`;
-        }
-    }
-    else if (key2) {
-        str = `${key1}-${key2}`;
+    if (!key1)
+        return '';
+    const cn = key1.trim();
+    if (!key2)
+        return cn;
+    const modifiers = key2.trim();
+    if (!modifiers)
+        return cn;
+    // 处理多个修饰符
+    if (modifiers.includes(' ')) {
+        const modifierArray = modifiers.split(/\s+/).filter(Boolean);
+        return `${cn} ${modifierArray.map(mod => `${cn}-${mod}`).join(' ')}`;
     }
-    return str;
+    return `${cn}-${modifiers}`;
 };
-// 根据路径获取数据
-export const getFieldsByPath = (data, path) => {
-    const arr = path?.split('.');
-    let res = data;
-    for (const i of arr) {
-        res = res[i];
+/**
+ * 根据路径安全获取嵌套对象数据
+ * @param data 源对象
+ * @param path 路径字符串，支持点号分隔
+ * @param defaultValue 默认值，当路径不存在时返回
+ * @returns 获取到的值或默认值
+ */
+export const getFieldsByPath = (data, path, defaultValue) => {
+    if (!data || !path)
+        return defaultValue;
+    try {
+        const keys = path.split('.');
+        let result = data;
+        for (const key of keys) {
+            if (result === null || result === undefined || !(key in result)) {
+                return defaultValue;
+            }
+            result = result[key];
+        }
+        return result !== undefined ? result : defaultValue;
+    }
+    catch {
+        return defaultValue;
     }
-    return res;
 };
-// 删除空值
-export const removeNull = (obj) => {
+/**
+ * 清理对象中的空值（null 和 undefined）
+ * @param obj 要清理的对象
+ * @param includeEmptyString 是否包含空字符串，默认false
+ * @param includeZero 是否包含0，默认false
+ * @returns 清理后的对象
+ */
+export const removeNull = (obj, includeEmptyString = false, includeZero = false) => {
+    if (!obj || typeof obj !== 'object')
+        return obj;
+    const cleaned = {};
     for (const key in obj) {
-        if (obj[key] === null) {
-            delete obj[key];
+        if (obj.hasOwnProperty(key)) {
+            const value = obj[key];
+            // 检查是否应该跳过该值
+            const shouldSkip = value === null ||
+                value === undefined ||
+                (includeEmptyString && value === '') ||
+                (includeZero && value === 0);
+            if (!shouldSkip) {
+                cleaned[key] = value;
+            }
         }
     }
-    return obj;
+    return cleaned;
 };
-// 防抖函数
-export const debounce = (func, wait) => {
+/**
+ * 防抖函数 - 增强版本，支持取消和立即执行
+ * @param func 要防抖的函数
+ * @param wait 等待时间（毫秒）
+ * @param options 选项配置
+ * @returns 防抖后的函数
+ */
+export const debounce = (func, wait, options = {}) => {
     let timeout = null;
-    return (...args) => {
+    let lastArgs = null;
+    let lastCallTime = 0;
+    let lastInvokeTime = 0;
+    let maxTimeout = null;
+    const { leading = false, trailing = true, maxWait } = options;
+    const invokeFunc = (time) => {
+        const args = lastArgs;
+        lastArgs = null;
+        lastInvokeTime = time;
+        if (args) {
+            func(...args);
+        }
+    };
+    const shouldInvoke = (time) => {
+        const timeSinceLastCall = time - lastCallTime;
+        const timeSinceLastInvoke = time - lastInvokeTime;
+        return lastCallTime === 0 ||
+            timeSinceLastCall >= wait ||
+            timeSinceLastInvoke < 0 ||
+            (maxWait && timeSinceLastInvoke >= maxWait);
+    };
+    const startTimer = (pendingFunc, waitMs) => {
+        return setTimeout(pendingFunc, waitMs);
+    };
+    const cancelTimer = (timer) => {
+        if (timer) {
+            clearTimeout(timer);
+        }
+    };
+    const debounced = (...args) => {
+        const now = Date.now();
+        const shouldInvokeNow = shouldInvoke(now);
+        lastArgs = args;
+        lastCallTime = now;
+        if (shouldInvokeNow) {
+            if (timeout) {
+                cancelTimer(timeout);
+                timeout = null;
+            }
+            if (leading && lastInvokeTime === 0) {
+                lastInvokeTime = now;
+                func(...args);
+                return;
+            }
+            if (maxWait) {
+                cancelTimer(maxTimeout);
+                maxTimeout = startTimer(() => {
+                    if (trailing && lastArgs) {
+                        invokeFunc(Date.now());
+                    }
+                    maxTimeout = null;
+                }, maxWait);
+            }
+        }
+        if (!timeout && trailing) {
+            timeout = startTimer(() => {
+                timeout = null;
+                if (trailing && lastArgs) {
+                    invokeFunc(Date.now());
+                }
+            }, wait);
+        }
+    };
+    debounced.cancel = () => {
         if (timeout) {
-            clearTimeout(timeout);
+            cancelTimer(timeout);
+            timeout = null;
         }
-        timeout = setTimeout(() => {
-            func(...args);
-        }, wait);
+        if (maxTimeout) {
+            cancelTimer(maxTimeout);
+            maxTimeout = null;
+        }
+        lastArgs = null;
+        lastCallTime = 0;
+        lastInvokeTime = 0;
     };
+    debounced.flush = () => {
+        if (timeout) {
+            cancelTimer(timeout);
+            timeout = null;
+        }
+        if (lastArgs) {
+            invokeFunc(Date.now());
+        }
+    };
+    return debounced;
 };
-// 节流函数
-export const throttle = (func, wait) => {
+/**
+ * 节流函数 - 增强版本，支持选项配置
+ * @param func 要节流的函数
+ * @param wait 等待时间（毫秒）
+ * @param options 选项配置
+ * @returns 节流后的函数
+ */
+export const throttle = (func, wait, options = {}) => {
     let timeout = null;
-    let lastTime = 0;
-    return (...args) => {
-        const nowTime = Date.now();
-        if (!timeout) {
+    let lastArgs = null;
+    let lastCallTime = 0;
+    let lastInvokeTime = 0;
+    const { leading = true, trailing = true } = options;
+    const invokeFunc = (time) => {
+        const args = lastArgs;
+        lastArgs = null;
+        lastInvokeTime = time;
+        if (args) {
             func(...args);
-            lastTime = nowTime;
-            timeout = setTimeout(() => {
+        }
+    };
+    const shouldInvoke = (time) => {
+        const timeSinceLastCall = time - lastCallTime;
+        const timeSinceLastInvoke = time - lastInvokeTime;
+        return lastCallTime === 0 ||
+            timeSinceLastCall >= wait ||
+            timeSinceLastInvoke < 0;
+    };
+    const startTimer = (pendingFunc, waitMs) => {
+        return setTimeout(pendingFunc, waitMs);
+    };
+    const throttled = (...args) => {
+        const now = Date.now();
+        const shouldInvokeNow = shouldInvoke(now);
+        lastArgs = args;
+        lastCallTime = now;
+        if (shouldInvokeNow) {
+            if (timeout) {
+                clearTimeout(timeout);
+                timeout = null;
+            }
+            if (leading && lastInvokeTime === 0) {
+                invokeFunc(now);
+                return;
+            }
+        }
+        if (!timeout && trailing) {
+            timeout = startTimer(() => {
                 timeout = null;
+                if (trailing && lastArgs) {
+                    invokeFunc(Date.now());
+                }
             }, wait);
         }
-        else {
-            const diffTime = nowTime - lastTime;
-            if (diffTime >= wait) {
-                func(...args);
-                lastTime = nowTime;
-            }
+    };
+    throttled.cancel = () => {
+        if (timeout) {
+            clearTimeout(timeout);
+            timeout = null;
         }
+        lastArgs = null;
+        lastCallTime = 0;
+        lastInvokeTime = 0;
     };
+    throttled.flush = () => {
+        if (timeout) {
+            clearTimeout(timeout);
+            timeout = null;
+        }
+        if (lastArgs) {
+            invokeFunc(Date.now());
+        }
+    };
+    return throttled;
+};
+/**
+ * 深度克隆对象
+ * @param obj 要克隆的对象
+ * @returns 克隆后的对象
+ */
+export const deepClone = (obj) => {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+    if (obj instanceof Date) {
+        return new Date(obj.getTime());
+    }
+    if (obj instanceof Array) {
+        return obj.map(item => deepClone(item));
+    }
+    if (typeof obj === 'object') {
+        const clonedObj = {};
+        for (const key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                clonedObj[key] = deepClone(obj[key]);
+            }
+        }
+        return clonedObj;
+    }
+    return obj;
 };

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@mi-avalon/libs",
 	"private": false,
-	"version": "1.0.3",
+	"version": "1.0.5",
 	"type": "module",
 	"main": "./dist/index.umd.js",
 	"module": "./dist/index.es.js",
@@ -37,4 +37,4 @@
 		"@ant-design/icons": ">=6.0.0"
 	},
 	"dependencies": {}
-}
+}