web-component-gallery 2.3.12 → 2.3.14

package/utils/Filter.js

@@ -1,16 +1,98 @@
 /**
- * 获取 n 天前的时间
+ * 格式化日期
+ * @param {string|number|Date} time - 时间
+ * @param {string} cFormat - 格式化模板
+ * {y}年 {m}月 {d}日 {h}时 {i}分 {s}秒 {a}星期 {q}季度
+ * @returns {string|null} 格式化后的日期字符串
+ */
+export function formatDate(time, cFormat) {
+    if (arguments.length === 0 || !time) return null
+
+    const format = cFormat || "{y}-{m}-{d} {h}:{i}:{s}"
+    let date
+
+    if (typeof time === "object") {
+        date = time
+    } else {
+        let timestamp = time
+
+        if (typeof timestamp === "string") {
+            timestamp = /^[0-9]+$/.test(timestamp)
+                ? parseInt(timestamp)
+                : timestamp.replace(/-/g, "/")
+        }
+
+        if (typeof timestamp === "number" && timestamp.toString().length === 10) {
+            timestamp *= 1000
+        }
+
+        date = new Date(timestamp)
+    }
+
+    if (isNaN(date.getTime())) {
+        console.warn('无效的日期格式')
+        return null
+    }
+
+    const formatObj = {
+        y: date.getFullYear(),
+        m: date.getMonth() + 1,
+        d: date.getDate(),
+        h: date.getHours(),
+        i: date.getMinutes(),
+        s: date.getSeconds(),
+        a: date.getDay(),
+        q: Math.floor((date.getMonth() + 3) / 3),
+    }
+
+    const timeStr = format.replace(/{([ymdhisaq])+}/g, (result, key) => {
+        const value = formatObj[key]
+
+        if (key === "a") {
+            return ["日", "一", "二", "三", "四", "五", "六"][value]
+        }
+
+        return String(value).padStart(2, "0")
+    })
+
+    return timeStr
+}
+
+/**
+ * 获取相对时间（通用函数）
  * @param {number} n - 数量
+ * @param {string} unit - 单位：'days'|'hours'|'minutes'|'seconds'
+ * @param {boolean} isBefore - 是否之前
  * @param {string|Date} baseTime - 基准时间（可选）
  * @param {string} cFormat - 格式化模板
  * @returns {string} 格式化日期
  */
-export function getNDaysBefore(n, baseTime = null, cFormat) {
+export function getRelativeTime(n, unit = 'days', isBefore = true, baseTime = null, cFormat) {
     const base = baseTime ? new Date(baseTime) : new Date()
-    const targetTime = new Date(base.getTime() - n * 24 * 60 * 60 * 1000)
+    const multipliers = {
+        days: 24 * 60 * 60 * 1000,
+        hours: 60 * 60 * 1000,
+        minutes: 60 * 1000,
+        seconds: 1000
+    }
+    
+    const diff = n * (multipliers[unit] || multipliers.days)
+    const targetTime = new Date(base.getTime() + (isBefore ? -diff : diff))
+    
     return formatDate(targetTime, cFormat)
 }
 
+/**
+ * 获取 n 天前的时间
+ * @param {number} n - 数量
+ * @param {string|Date} baseTime - 基准时间（可选）
+ * @param {string} cFormat - 格式化模板
+ * @returns {string} 格式化日期
+ */
+export function getNDaysBefore(n, baseTime = null, cFormat) {
+    return getRelativeTime(n, 'days', true, baseTime, cFormat)
+}
+
 /**
  * 获取 n 小时前的时间
  * @param {number} n - 小时数
@@ -19,9 +101,7 @@ export function getNDaysBefore(n, baseTime = null, cFormat) {
  * @returns {string} 格式化日期
  */
 export function getNHoursBefore(n, baseTime = null, cFormat) {
-    const base = baseTime ? new Date(baseTime) : new Date()
-    const targetTime = new Date(base.getTime() - n * 60 * 60 * 1000)
-    return formatDate(targetTime, cFormat)
+    return getRelativeTime(n, 'hours', true, baseTime, cFormat)
 }
 
 /**
@@ -32,9 +112,7 @@ export function getNHoursBefore(n, baseTime = null, cFormat) {
  * @returns {string} 格式化日期
  */
 export function getNMinutesBefore(n, baseTime = null, cFormat) {
-    const base = baseTime ? new Date(baseTime) : new Date()
-    const targetTime = new Date(base.getTime() - n * 60 * 1000)
-    return formatDate(targetTime, cFormat)
+    return getRelativeTime(n, 'minutes', true, baseTime, cFormat)
 }
 
 /**
@@ -45,9 +123,7 @@ export function getNMinutesBefore(n, baseTime = null, cFormat) {
  * @returns {string} 格式化日期
  */
 export function getNSecondsBefore(n, baseTime = null, cFormat) {
-    const base = baseTime ? new Date(baseTime) : new Date()
-    const targetTime = new Date(base.getTime() - n * 1000)
-    return formatDate(targetTime, cFormat)
+    return getRelativeTime(n, 'seconds', true, baseTime, cFormat)
 }
 
 /**
@@ -58,9 +134,7 @@ export function getNSecondsBefore(n, baseTime = null, cFormat) {
  * @returns {string} 格式化日期
  */
 export function getNDaysAfter(n, baseTime = null, cFormat) {
-    const base = baseTime ? new Date(baseTime) : new Date()
-    const targetTime = new Date(base.getTime() + n * 24 * 60 * 60 * 1000)
-    return formatDate(targetTime, cFormat)
+    return getRelativeTime(n, 'days', false, baseTime, cFormat)
 }
 
 /**
@@ -71,75 +145,7 @@ export function getNDaysAfter(n, baseTime = null, cFormat) {
  * @returns {string} 格式化日期
  */
 export function getNHoursAfter(n, baseTime = null, cFormat) {
-    const base = baseTime ? new Date(baseTime) : new Date()
-    const targetTime = new Date(base.getTime() + n * 60 * 60 * 1000)
-    return formatDate(targetTime, cFormat)
-}
-
-/**
- * 格式化日期
- * @param {string|number|Date} time - 时间
- * @param {string} cFormat - 格式化模板
- * {y}年 {m}月 {d}日 {h}时 {i}分 {s}秒 {a}星期 {q}季度
- * @returns {string|null} 格式化后的日期字符串
- */
-export function formatDate(time, cFormat) {
-    if (arguments.length === 0 || !time) return null
-
-    const format = cFormat || "{y}-{m}-{d} {h}:{i}:{s}"
-    let date
-
-    // 处理不同类型的输入
-    if (typeof time === "object") {
-        date = time
-    } else {
-        let timestamp = time
-
-        // 字符串处理
-        if (typeof timestamp === "string") {
-            timestamp = /^[0-9]+$/.test(timestamp)
-                ? parseInt(timestamp)
-                : timestamp.replace(/-/g, "/")
-        }
-
-        // 10 位时间戳转毫秒
-        if (typeof timestamp === "number" && timestamp.toString().length === 10) {
-            timestamp *= 1000
-        }
-
-        date = new Date(timestamp)
-    }
-
-    // 验证日期有效性
-    if (isNaN(date.getTime())) {
-        console.warn('无效的日期格式')
-        return null
-    }
-
-    const formatObj = {
-        y: date.getFullYear(),
-        m: date.getMonth() + 1,
-        d: date.getDate(),
-        h: date.getHours(),
-        i: date.getMinutes(),
-        s: date.getSeconds(),
-        a: date.getDay(),
-        q: Math.floor((date.getMonth() + 3) / 3), // 季度
-    }
-
-    const timeStr = format.replace(/{([ymdhisaq])+}/g, (result, key) => {
-        const value = formatObj[key]
-
-        // 星期处理
-        if (key === "a") {
-            return ["日", "一", "二", "三", "四", "五", "六"][value]
-        }
-
-        // 补零处理
-        return String(value).padStart(2, "0")
-    })
-
-    return timeStr
+    return getRelativeTime(n, 'hours', false, baseTime, cFormat)
 }
 
 /**
@@ -151,7 +157,6 @@ export function formatDate(time, cFormat) {
 export function formatTimestamp(timestamp, format) {
     if (!timestamp) return null
 
-    // 10 位时间戳转毫秒
     if (String(timestamp).length === 10) {
         timestamp *= 1000
     }
@@ -163,7 +168,7 @@ export function formatTimestamp(timestamp, format) {
  * 计算两个日期之间的差异
  * @param {string|Date} date1 - 日期 1
  * @param {string|Date} date2 - 日期 2
- * @returns {Object} 差异对象 {days, hours, minutes, seconds, milliseconds}
+ * @returns {Object} 差异对象
  */
 export function dateDiff(date1, date2) {
     const d1 = new Date(date1)
@@ -204,28 +209,27 @@ export function getDaysInMonth(year, month) {
 /**
  * 颜色十六进制转 RGB/RGBA
  * @param {string} sHex - 十六进制色值
- * @param {number} alpha - 透明度
- * @returns {string} rgba(r,g,b,a) 格式字符串
+ * @param {number} [alpha] - 透明度（0-1）
+ * @returns {string} rgba(r,g,b,a) 或 rgb(r,g,b) 格式字符串
  */
 export function colorRgba(sHex, alpha) {
     const reg = /^#([0-9a-fA-f]{3}|[0-9a-fA-f]{6})$/
     let sColor = sHex.toLowerCase()
 
     if (sColor && reg.test(sColor)) {
-        // 简写形式转为完整形式 #fff -> #ffffff
         if (sColor.length === 4) {
             sColor = "#" + [1, 2, 3].map(i =>
                 sColor.slice(i, i + 1).repeat(2)
             ).join("")
         }
 
-        // 提取 RGB 值
         const rgbValues = []
         for (let i = 1; i < 7; i += 2) {
             rgbValues.push(parseInt(`0x${sColor.slice(i, i + 2)}`))
         }
 
-        return alpha !== undefined
+        // 修复：使用 alpha == null 检查（同时排除 undefined 和 null）
+        return (alpha != null)
             ? `rgba(${rgbValues.join(",")},${alpha})`
             : `rgb(${rgbValues.join(",")})`
     }
@@ -258,7 +262,6 @@ export function randomColor(full = false) {
         return '#' + Math.floor(Math.random() * 16777215).toString(16).padStart(6, '0')
     }
 
-    // 生成柔和的彩色
     const hue = Math.floor(Math.random() * 360)
     const saturation = 70 + Math.floor(Math.random() * 20)
     const lightness = 60 + Math.floor(Math.random() * 20)
@@ -305,14 +308,12 @@ export function hslToHex(h, s, l) {
  * @returns {Array} [百分比数组，数值数组]
  */
 export function produceDataSeriesEx(segment, total, baseValue) {
-    // 生成分段百分比
     const percentArray = new Array(segment).fill(0)
     for (let i = 0; i < total; i++) {
         const randomIndex = Math.floor(Math.random() * segment)
         percentArray[randomIndex]++
     }
 
-    // 计算对应数值
     const valueArray = percentArray.map(percent =>
         Math.floor(percent / 100 * baseValue)
     )
@@ -321,7 +322,7 @@ export function produceDataSeriesEx(segment, total, baseValue) {
 }
 
 /**
- * 深拷贝
+ * 深拷贝（增强版）
  * @param {*} obj - 要拷贝的对象
  * @returns {*} 深拷贝后的结果
  */
@@ -334,6 +335,10 @@ export function deepClone(obj) {
         return new Date(obj.getTime())
     }
 
+    if (obj instanceof RegExp) {
+        return new RegExp(obj.source, obj.flags)
+    }
+
     if (obj instanceof Array) {
         return obj.reduce((arr, item) => {
             arr.push(deepClone(item))
@@ -347,55 +352,43 @@ export function deepClone(obj) {
             return newObj
         }, {})
     }
+    
+    return obj
 }
 
 /**
  * 数据类型转换工具函数
  * @param {*} data - 原始数据
- * @param {string|Object|null} format - 目标类型或转换配置对象
+ * @param {string|Object|null} format - 目标类型或转换配置
  *        - 字符串：'String'|'Number'|'Boolean'|'Array'|'Object'
- *        - 对象：转换映射配置 {key: type}
- *        - null/undefined：智能自动转换
+ *        - 对象：映射配置 {key: type}
+ *        - 数组：字段配置 [{ fields: ['a'], type: 'Number' }]
+ *        - null：智能转换
  * @param {Object} options - 配置选项
- * @param {boolean} options.useDefault - 转换不成功是否返回默认值（默认 true）
- * @param {*} options.defaultValue - 自定义默认值（可选）
+ * @param {*} options.defaultValue - 自定义默认值
  * @returns {*} 转换后的数据
  * 
  * @example
- * // 智能转换（不传 format）
- * transferData('123')           // 123 (自动推断为 Number)
- * transferData('true')          // true (自动推断为 Boolean)
- * transferData('[1,2]')         // [1,2] (自动推断为 Array)
- * transferData('hello')         // 'hello' (保持 String)
- * 
- * // 字符串模式：基本类型转换
- * transferData('123', 'Number') // 123
- * transferData(null, 'Array')   // []
- * 
- * // 对象模式：根据 key 批量转换
- * transferData({a:'1', b:'2'}, {a: 'Number', b: 'Number'}) 
- * // {a: 1, b: 2}
- * 
- * // 配置选项
- * transferData('abc', 'Number') // NaN
- * transferData('abc', 'Number', { defaultValue: -1 })  // -1
+ * transferData('123')                          // 智能转换：123
+ * transferData('123', 'Number')                // Number：123
+ * transferData('true', 'Boolean')              // Boolean：true
+ * transferData(123, 'String')                  // String：'123'
+ * transferData('[1,2]', 'Array')               // Array：[1,2]
+ * transferData('{"a":1}', 'Object')            // Object：{a:1}
+ * transferData({a:'1'}, ['a'])                 // 批量转 Number：{a:1}
+ * transferData({a:'1'}, [['a'],'Number'])      // 指定类型：{a:1}
+ * transferData({a:'1'}, [{fields:['a'],type:'Number'}])  // 对象配置：{a:1}
+ * transferData({a:null}, ['a'], {defaultValue:0})  // 带默认值：{a:0}
+ * transferData([{a:'1'},{a:'2'}], ['a'])       // 数组递归：[{a:1},{a:2}]
+ * transferData({a:'1',b:'2'}, {a:'Number'})    // 对象映射：{a:1,b:'2'}
  */
 export function transferData(data, format, options = {}) {
-    // 智能转换模式
     if (!format) return autoTransferDataInternal(data, options)
 
-    const { defaultValue } = options
-
-    // 数组模式：支持两种形式
-    // 1. ['a', 'b', 'c'] - 转换为 Number
-    // 2. [['a', 'b'], 'Number'] - 指定类型
-    // 3. [{ fields: ['a', 'b'], type: 'Number' }] - 对象配置
     if (Array.isArray(format)) return transferDataByFields(data, format, options)
 
-    // 对象映射模式
     if (typeof format === 'object') return transferDataByMap(data, format, options)
 
-    // 默认值配置
     const defaults = { 
         Number: 0, 
         Boolean: false, 
@@ -404,12 +397,10 @@ export function transferData(data, format, options = {}) {
         Object: {}
     }
 
-    const defaultVal = defaultValue ?? defaults[format]
+    const defaultVal = options.defaultValue ?? defaults[format]
 
-    // 空值处理
     if (data == null) return defaultVal
 
-    // 复杂类型处理 (Array/Object)
     if (format === 'Array' || format === 'Object') {
         const isTargetType = (format === 'Array' && Array.isArray(data)) ||
                              (format === 'Object' && typeof data === 'object' && !Array.isArray(data))
@@ -424,7 +415,6 @@ export function transferData(data, format, options = {}) {
         }
     }
 
-    // 基础类型转换
     try {
         switch (format) {
             case 'Number': {
@@ -439,7 +429,6 @@ export function transferData(data, format, options = {}) {
                 return Boolean(data)
             }
             case 'String': {
-                // 对象/数组转为 JSON 字符串
                 if (typeof data === 'object') {
                     try {
                         return JSON.stringify(data)
@@ -461,56 +450,76 @@ export function transferData(data, format, options = {}) {
  * 根据字段数组批量转换数据
  * @param {*} data - 原始数据
  * @param {Array} format - 格式配置
- *        - ['a', 'b', 'c'] - 默认转为 Number
- *        - [['a', 'b'], 'Number'] - 指定类型
- *        - [{ fields: ['a', 'b'], type: 'Number' }] - 对象配置
  * @param {Object} options - 配置选项
  * @returns {*} 转换后的数据
  */
 function transferDataByFields(data, format, options) {
+    // 边界情况处理
     if (data == null || typeof data !== 'object') {
         return data ?? options.defaultValue
     }
 
-    let fields = []
-    let type = 'Number' // 默认转为 Number
-
-    // 解析数组配置
-    if (format.length === 0) return data
-
-    // 形式 1: ['a', 'b', 'c'] - 默认转 Number
-    if (typeof format[0] === 'string') {
-        fields = format
-    }
-    // 形式 2: [['a', 'b'], 'Number'] - [fields, type]
-    else if (Array.isArray(format[0])) {
-        fields = format[0]
-        if (format[1]) type = format[1]
-    }
-    // 形式 3: [{ fields: ['a', 'b'], type: 'Number' }] - 对象配置
-    else if (typeof format[0] === 'object') {
-        const config = format[0]
-        fields = config.fields || []
-        type = config.type || 'Number'
-    }
+    // 空配置直接返回
+    if (!format || format.length === 0) return data
 
-    // 如果是数组，递归处理每个元素
+    // 数组处理：递归处理每个元素（提前到最前面）
     if (Array.isArray(data)) {
         return data.map(item => transferDataByFields(item, format, options))
     }
 
-    // 对象处理：转换指定字段
     const result = { ...data }
+    const configType = typeof format[0]
     
-    for (const field of fields) {
-        if (field in result) {
-            result[field] = transferData(result[field], type, options)
+    if (configType === 'string' || Array.isArray(format[0])) {
+        // 形式 1 和形式 2：统一解析
+        const { fields, type } = parseFormatConfig(format)
+        
+        for (const field of fields) {
+            if (field in result) {
+                result[field] = transferData(result[field], type, options)
+            }
         }
+    } else if (configType === 'object') {
+        // 形式 3：对象配置数组
+        format.forEach(config => {
+            const fields = config.fields || []
+            const type = config.type || 'Number'
+            
+            for (const field of fields) {
+                if (field in result) {
+                    const fieldOptions = config.defaultValue !== undefined
+                        ? { ...options, defaultValue: config.defaultValue }
+                        : options
+                    
+                    result[field] = transferData(result[field], type, fieldOptions)
+                }
+            }
+        })
     }
 
     return result
 }
 
+/**
+ * 解析传统格式配置
+ * @param {Array} format - 格式配置
+ * @returns {{fields: Array, type: string}} 解析后的配置
+ */
+function parseFormatConfig(format) {
+    if (typeof format[0] === 'string') {
+        return { fields: format, type: 'Number' }
+    }
+    
+    if (Array.isArray(format[0])) {
+        return { 
+            fields: format[0] || [], 
+            type: format[1] || 'Number' 
+        }
+    }
+    
+    return { fields: [], type: 'Number' }
+}
+
 /**
  * 智能数据类型转换（内部函数）
  * @param {*} data - 原始数据
@@ -542,18 +551,16 @@ function autoTransferDataInternal(data, options) {
 
 /**
  * 根据映射对象批量转换数据
- * @param {*} data - 原始数据（对象或数组）
- * @param {Object} formatMap - 转换映射对象 {key: type}
+ * @param {*} data - 原始数据
+ * @param {Object} formatMap - 转换映射对象
  * @param {Object} options - 配置选项
  * @returns {*} 转换后的数据
  */
 function transferDataByMap(data, formatMap, options) {
-    // 数据为空，返回空对象或原数据
     if (data === null || data === undefined) {
         return options.defaultValue ?? {}
     }
     
-    // 数组处理：对每个元素应用转换映射
     if (Array.isArray(data)) {
         return data.map(item => {
             if (typeof item !== 'object') return item
@@ -561,17 +568,14 @@ function transferDataByMap(data, formatMap, options) {
         })
     }
     
-    // 对象处理：根据 formatMap 的 key 进行转换
     const result = {}
     
-    // 遍历映射表进行类型转换
     for (const key in formatMap) {
         if (Object.hasOwn(formatMap, key)) {
             result[key] = transferData(data[key], formatMap[key], options)
         }
     }
 
-    // 保留未在映射表中定义的其他属性
     for (const key in data) {
         if (Object.hasOwn(data, key) && !Object.hasOwn(result, key)) {
             result[key] = data[key]
@@ -585,18 +589,21 @@ function transferDataByMap(data, formatMap, options) {
  * 查找字符串中第 n 次出现的位置
  * @param {string} str - 源字符串
  * @param {string} charToFind - 查找字符
- * @param {number} n - 第几次出现
+ * @param {number} n - 第几次出现（从 1 开始）
  * @returns {number} 位置索引，未找到返回 -1
  */
 export function findNthOccurrence(str, charToFind, n) {
+    if (n < 1) return -1
+    
+    let index = -1
     let count = 0
-    let index = str.indexOf(charToFind)
-   
-    while (count < n && index !== -1) {
-      index = str.indexOf(charToFind, index + 1)
-      count++
+    
+    while (count < n) {
+        index = str.indexOf(charToFind, index + 1)
+        if (index === -1) return -1
+        count++
     }
-   
+    
     return index
 }
 
@@ -612,7 +619,6 @@ export function setFormData(object) {
         if (Object.prototype.hasOwnProperty.call(object, key)) {
             const value = object[key]
 
-            // 处理嵌套对象和数组
             value instanceof Object || Array.isArray(value)
                 ? formData.append(key, JSON.stringify(value))
                 : formData.append(key, value)
@@ -656,7 +662,7 @@ export function throttle(func, delay = 300) {
 /**
  * 数组去重
  * @param {Array} arr - 要去重的数组
- * @param {string} key - 对象去重的键（可选）
+ * @param {string} [key] - 对象去重的键（可选）
  * @returns {Array} 去重后的数组
  */
 export function uniqueArray(arr, key) {