wui-components-v2 1.1.70 → 1.1.72

package/utils/index.ts

@@ -1,979 +1,979 @@
-import type { Comparator } from '../type'
-
-// const filefxd = ['image', 'video', 'audio', 'file', 'wav']
-const baseUrl = uni.getStorageSync('BASE_URL')
-const token = uni.getStorageSync('TOKEN')
-const hydrocarbonProgramToken = uni.getStorageSync('HYDROCARBON_PROGRAM_TOKEN')
-
-/**
- * 获取当前页面路径
- * @returns 当前页面路径
- */
-export function getCurrentPath() {
-  const pages = getCurrentPages()
-  const currentPage = pages[pages.length - 1]
-  return currentPage.route || ''
-}
-
-/**
- * 格式化列表项展示数据
- * @param data 数据值
- * @param type 数据类型
- * @returns 格式化后的数据
- */
-export function formatItemData(data: any, type: string) {
-  // console.log('[Mock] formatItemData', data, type)
-  if (type === 'relselect' || type === 'tree-entity-select' || type === 'table-entity-select') {
-    // 判断data是否为数组
-    if (Array.isArray(data)) {
-      const dataArr = data.map(item => item.split('@R@')[1]).join(',')
-      return dataArr
-    }
-    // 字符串中是否包含@,@
-    if (typeof data === 'string' && data.includes('@,@')) {
-      return data.split('@,@').map((item: string) => item.split('@R@')[1]).join(',')
-    }
-
-    // 字符串中是否包含@R@
-    if (typeof data === 'string' && data.includes('@R@')) {
-      return data.split('@R@')[1]
-    }
-
-    return data || ''
-  }
-
-  if (type === 'datetime') {
-    return data ? data.split('.')[0] : ''
-  }
-
-  if (type === 'file' || type === 'relfile' || type === 'video') {
-    if (data) {
-      // 判断是否为JSON文件
-      if (typeof data === 'string') {
-        const a = JSON.parse(data)
-        return [{
-          url: `${baseUrl}/v3/files${a.base.path}?@token=${token}&@programToken=${hydrocarbonProgramToken}&name=${a.base.fileName || ''}`,
-          name: a.base.fileName,
-          type: a.base.type,
-        }]
-      }
-      else if (Array.isArray(data)) {
-        return data.map((item) => {
-          if (item.includes('@R@')) {
-            const a = JSON.parse(item.split('@R@')[1])
-            return {
-              url: `${baseUrl}/v3/files${a.base.path}?@token=${token}&@programToken=${hydrocarbonProgramToken}&name=${a.base.fileName || ''}`,
-              name: a.base.fileName,
-              type: a.base.type,
-            }
-          }
-          else {
-            const a = JSON.parse(item)
-            return {
-              url: `${baseUrl}/v3/files${a.base.path}?@token=${token}&@programToken=${hydrocarbonProgramToken}&name=${a.base.fileName || ''}`,
-              name: a.base.fileName,
-              type: a.base.type,
-            }
-          }
-        })
-      }
-      else {
-        return [{
-          url: data.url,
-          name: data.name,
-          type: getAfterLastMatch(data.name, '.') || getAfterLastMatch(data.url, '.'),
-        }]
-      }
-    }
-    return [{
-      url: 'https://',
-      name: '',
-      type: 'img',
-    }]
-  }
-
-  return data
-}
-
-/**
- * 高并发环境下也能保证唯一的ID生成器
- * @returns 25字符的唯一字符串
- */
-let counter = 0
-export function generateHighResolutionID(): string {
-  const time = Date.now().toString(36)
-  const random = Math.random().toString(36).substring(2, 10)
-  counter = (counter + 1) % Number.MAX_SAFE_INTEGER
-  return `${time}-${random}-${counter.toString(36).padStart(6, '0')}`
-}
-
-// 下载文件
-export function downloadFile(url: string) {
-  console.log('下载', url)
-  uni.downloadFile({
-    url, // 文件的网络地址
-    success: (res) => {
-      if (res.statusCode === 200) {
-        console.log('下载成功', res.tempFilePath)
-        // 打开文件（如PDF、Word等）
-        uni.openDocument({
-          filePath: res.tempFilePath,
-          showMenu: true,
-          success: () => console.log('打开文件成功'),
-        })
-      }
-      else {
-        console.error('下载失败', res)
-        uni.showToast({
-          title: '下载失败',
-          icon: 'none',
-        })
-      }
-    },
-    fail: (err) => {
-      console.error('下载失败', err)
-      uni.showToast({
-        title: '下载失败',
-        icon: 'none',
-      })
-    },
-  })
-}
-
-/**
- * 字符串截取匹配最后一项（不包含匹配字符）
- *
- *
- */
-function getAfterLastMatch(str: string, pattern: string) {
-  const lastIndex = str.lastIndexOf(pattern)
-  if (lastIndex === -1)
-    return null
-  return str.substring(lastIndex + pattern.length)
-}
-
-/****
- *
- * 根据comparator、defaultValue、val
- * 判断按钮是否满足显示
- *
- *
- */
-export function comparator(
-  comparator: Comparator,
-  val: string,
-  defaultValue: string,
-): boolean {
-  let dvs: string[]
-  let value = val
-  if (val && val.indexOf && val.indexOf('@R@') > 0) {
-    const vs = val.split('@R@')
-    value = vs[1]
-  }
-
-  if (!comparator) {
-    comparator = 'equals'
-  }
-
-  if (comparator === 'none1') {
-    return !value || value === ''
-  }
-  else if (comparator === 'none1n') {
-    return !!value && value !== ''
-  }
-
-  if (!defaultValue) {
-    return true
-  }
-
-  if (!value && value !== '0') {
-    return false
-  }
-  let vals
-  switch (comparator) {
-    case 'contain':
-      return value.includes(defaultValue)
-    case 'equal':
-    case 'equals':
-      return isEqual(value, defaultValue)
-    case 'exclude':
-      dvs = toArray(defaultValue)
-      vals = toArray(value)
-      for (let i = 0; i < dvs.length; i++) {
-        for (let j = 0; j < vals.length; j++) {
-          if (dvs[i] === vals[j]) {
-            return false
-          }
-        }
-      }
-      return true
-    case 'includeOne':
-    case 'include_anyone':
-      dvs = toArray(defaultValue)
-      vals = toArray(value)
-      for (let i = 0; i < dvs.length; i++) {
-        for (let j = 0; j < vals.length; j++) {
-          if (dvs[i] === vals[j]) {
-            return true
-          }
-        }
-      }
-      return false
-
-    case 'include_all':
-    {
-      dvs = toArray(defaultValue)
-      vals = toArray(value)
-      let count = 0
-      const targetCount = dvs.length
-      for (let i = 0; i < dvs.length; i++) {
-        for (let j = 0; j < vals.length; j++) {
-          if (dvs[i] === vals[j]) {
-            count++
-            break
-          }
-        }
-      }
-      return targetCount <= count
-    }
-    case 'Greater':
-    case 'greater':
-      if (!Number.isNaN(Number(value)) && !Number.isNaN(Number(defaultValue))) {
-        return Number(value) > Number(defaultValue)
-      }
-      else {
-        return value > defaultValue
-      }
-    case 'Less':
-    case 'less':
-      if (!Number.isNaN(Number(value)) && !Number.isNaN(Number(defaultValue))) {
-        return Number(value) < Number(defaultValue)
-      }
-      else {
-        return value < defaultValue
-      }
-    case 'noGreater':
-    case 'nogreater':
-      if (!Number.isNaN(Number(value)) && !Number.isNaN(Number(defaultValue))) {
-        return Number(value) <= Number(defaultValue)
-      }
-      else {
-        return value <= defaultValue
-      }
-    case 'noLess':
-    case 'noless':
-      if (!Number.isNaN(Number(value)) && !Number.isNaN(Number(defaultValue))) {
-        return Number(value) >= Number(defaultValue)
-      }
-      else {
-        return value >= defaultValue
-      }
-    case 'unequal':
-    case 'unequals':
-      return !isEqual(value, defaultValue)
-    default:
-      console.log(`暂不支持的比较关系：${comparator};请联系管理员添加。`)
-      return false // 兜底返回值
-  }
-}
-
-function isEqual(value: string, defaultValue: string) {
-  if (defaultValue === '是' || defaultValue === '否' || defaultValue === 'true' || defaultValue === 'false') {
-    if (value === 'true' || value === '是') {
-      if (defaultValue === '是' || defaultValue === 'true') {
-        return true
-      }
-      else {
-        return false
-      }
-    }
-    else if (value === 'false' || value === '否') {
-      if (defaultValue === '否' || defaultValue === 'false') {
-        return true
-      }
-      else {
-        return false
-      }
-    }
-    else {
-      return false
-    }
-  }
-  else {
-    if (!Number.isNaN(Number(value)) && !Number.isNaN(Number(defaultValue))) {
-      return Number(value) === Number(defaultValue)
-    }
-    else {
-      return value === defaultValue
-    }
-  }
-}
-
-function toArray(value: string) {
-  let val
-  if (typeof value == 'string') {
-    val = value.split(',')
-  }
-  else if (Array.isArray(value)) {
-    val = value
-  }
-  else {
-    val = [value]
-  }
-  return val
-}
-
-/**
- * 根据目标颜色生成渐变色字符串
- * @param color - 目标颜色，可以是十六进制颜色或RGB颜色
- * @param angle - 渐变角度，默认为180deg
- * @param startOpacity - 起始透明度，默认为1(不透明)
- * @param endOpacity - 结束透明度，默认为0.3
- * @returns 渐变色字符串
- */
-export function generateGradientColor(
-  color: string,
-  angle: number = 180,
-  startOpacity: number = 1,
-  endOpacity: number = 0.3,
-): string {
-  // 处理十六进制颜色转换为RGB
-  const hexToRgb = (hex: string): { r: number, g: number, b: number } | null => {
-    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex)
-    return result
-      ? {
-          r: Number.parseInt(result[1], 16),
-          g: Number.parseInt(result[2], 16),
-          b: Number.parseInt(result[3], 16),
-        }
-      : null
-  }
-
-  // 将RGB颜色转换为rgba格式
-  const toRgba = (color: string, opacity: number): string => {
-    if (color.startsWith('#')) {
-      const rgb = hexToRgb(color)
-      if (rgb) {
-        return `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, ${opacity})`
-      }
-    }
-    else if (color.startsWith('rgb(')) {
-      // 处理rgb()格式
-      const rgbValues = color.match(/\d+/g)
-      if (rgbValues && rgbValues.length === 3) {
-        return `rgba(${rgbValues[0]}, ${rgbValues[1]}, ${rgbValues[2]}, ${opacity})`
-      }
-    }
-    // 如果已经是rgba或其他格式，直接返回带透明度的版本
-    return color.replace(/rgb\(/, 'rgba(').replace(/\)/, `, ${opacity})`)
-  }
-
-  // 生成渐变色字符串
-  const startColor = color.startsWith('rgba') ? color : toRgba(color, startOpacity)
-  const endColor = toRgba(color, endOpacity)
-
-  return `linear-gradient(${angle}deg, ${startColor} 0%, ${endColor} 100%)`
-}
-
-// 使用示例
-// console.log(generateGradientColor('#2094FF'));
-// 输出: linear-gradient(180deg, rgba(32,148,255,1) 0%, rgba(32,148,255,0.3) 100%)
-
-// console.log(generateGradientColor('#2094FF', 90, 0.8, 0.1));
-// 输出: linear-gradient(90deg, rgba(32,148,255,0.8) 0%, rgba(32,148,255,0.1) 100%)
-
-/**
- * 格式化日期显示
- * @param date - 要格式化的日期，默认为当前日期
- * @returns 格式化后的日期字符串，如"2025年9月25日 周四 下午"
- */
-export function formatChineseDate(date: Date = new Date()): string {
-  // 年份
-  const year = date.getFullYear()
-
-  // 月份（月份从0开始，需要+1）
-  const month = date.getMonth() + 1
-
-  // 日期
-  const day = date.getDate()
-
-  // 星期几
-  const weekdays = ['周日', '周一', '周二', '周三', '周四', '周五', '周六']
-  const weekday = weekdays[date.getDay()]
-
-  // 上午/下午判断
-  const hour = date.getHours()
-  const period = hour < 12 ? '上午' : '下午'
-
-  return `${year}年${month}月${day}日 ${weekday} ${period}`
-}
-
-// 使用示例
-// console.log(formatChineseDate(new Date(2025, 8, 25)));
-// 输出: 2025年9月25日 周四 下午
-
-// console.log(formatChineseDate(new Date(2025, 8, 25, 10, 30)));
-// 输出: 2025年9月25日 周四 上午
-
-// console.log(formatChineseDate());
-// 输出当前日期的格式化结果
-
-/**
- * 淡化颜色
- * @param color - 目标颜色，可以是十六进制颜色或RGB颜色
- * @returns 淡化后的颜色字符串
- */
-export function desaturateColor(color: string, opacity: number = 0.04): string {
-  // 处理十六进制颜色转换为RGB
-  const hexToRgb = (hex: string): { r: number, g: number, b: number } | null => {
-    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex)
-    return result
-      ? {
-          r: Number.parseInt(result[1], 16),
-          g: Number.parseInt(result[2], 16),
-          b: Number.parseInt(result[3], 16),
-        }
-      : null
-  }
-  // 将RGB颜色转换为rgba格式
-  const toRgba = (color: string, opacity: number): string => {
-    if (color.startsWith('#')) {
-      const rgb = hexToRgb(color)
-      if (rgb) {
-        return `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, ${opacity})`
-      }
-    }
-    else if (color.startsWith('rgb(')) {
-      // 处理rgb()格式
-      const rgbValues = color.match(/\d+/g)
-      if (rgbValues && rgbValues.length === 3) {
-        return `rgba(${rgbValues[0]}, ${rgbValues[1]}, ${rgbValues[2]}, ${opacity})`
-      }
-    }
-    // 如果已经是rgba或其他格式，直接返回带透明度的版本
-    return color.replace(/rgb\(/, 'rgba(').replace(/\)/, `, ${opacity})`)
-  }
-
-  return toRgba(color, opacity)
-}
-
-/**
- * 扩展版本：判断字符串中是否包含多个字符中的任意一个
- */
-export function containsAnyCharacter(str: string, chars: string[]): boolean {
-  if (typeof str !== 'string' || !Array.isArray(chars)) {
-    return false
-  }
-
-  // 验证数组中的每个元素都是单个字符
-  for (const char of chars) {
-    if (typeof char !== 'string' || char.length !== 1) {
-      throw new Error('数组中的每个元素必须是单个字符')
-    }
-  }
-
-  return chars.some(char => str.includes(char))
-}
-// 测试用例
-// console.log(containsAnyCharacter("hello world", ["a", "e", "i", "o", "u"])); // true (包含o)
-
-/**
- * 颜色转换和生成工具类 (针对十六进制颜色优化)
- */
-
-/**
- * 十六进制颜色转换为RGB对象
- * @param {string} hex - 十六进制颜色值，如 #2164F3 或 2164F3
- * @returns {object} RGB对象 {r, g, b}
- */
-export function hexToRgb(hex: string) {
-  // 移除 # 号
-  hex = hex.replace(/^#/, '')
-
-  // 处理简写形式如 #FFF
-  if (hex.length === 3) {
-    hex = hex.split('').map(c => c + c).join('')
-  }
-
-  // 解析十六进制值
-  const bigint = Number.parseInt(hex, 16)
-
-  return {
-    r: (bigint >> 16) & 255,
-    g: (bigint >> 8) & 255,
-    b: bigint & 255,
-  }
-}
-
-/**
- * RGB对象转换为十六进制颜色
- * @param {object} rgb - RGB对象 {r, g, b}
- * @returns {string} 十六进制颜色值
- */
-export function rgbToHex(rgb: { r: any, g: any, b: any }) {
-  const toHex = (c: { toString: (arg0: number) => any }) => {
-    const hex = c.toString(16)
-    return hex.length === 1 ? `0${hex}` : hex
-  }
-  return `#${toHex(rgb.r)}${toHex(rgb.g)}${toHex(rgb.b)}`.toUpperCase()
-}
-
-/**
- * 将 RGB 颜色转换为 HSL 颜色模型
- * @param {number} r - 红色值 (0-255)
- * @param {number} g - 绿色值 (0-255)
- * @param {number} b - 蓝色值 (0-255)
- * @returns {object} HSL对象 {h, s, l}
- */
-export function rgbToHsl(r: number, g: number, b: number) {
-  r /= 255
-  g /= 255
-  b /= 255
-
-  const max = Math.max(r, g, b)
-  const min = Math.min(r, g, b)
-  let h
-  let s
-  const l = (max + min) / 2
-
-  if (max === min) {
-    h = s = 0
-  }
-  else {
-    const d = max - min
-    s = l > 0.5 ? d / (2 - max - min) : d / (max + min)
-
-    switch (max) {
-      case r: h = (g - b) / d + (g < b ? 6 : 0)
-        break
-      case g: h = (b - r) / d + 2
-        break
-      case b: h = (r - g) / d + 4
-        break
-      default: h = 0 // 添加默认情况，确保h被初始化
-    }
-
-    h /= 6
-  }
-
-  return {
-    h: Math.round(h * 360),
-    s: Math.round(s * 100),
-    l: Math.round(l * 100),
-  }
-}
-
-/**
- * 将 HSL 颜色转换为 RGB 颜色
- * @param {number} h - 色相 (0-360)
- * @param {number} s - 饱和度 (0-100)
- * @param {number} l - 亮度 (0-100)
- * @returns {object} RGB对象 {r, g, b}
- */
-export function hslToRgb(h: number, s: number = 50, l: number = 50): { r: number, g: number, b: number } {
-  h = h !== undefined ? h / 360 : 0
-  s = s !== undefined ? s / 100 : 0.5
-  l = l !== undefined ? l / 100 : 0.5
-
-  let r, g, b
-
-  if (s === 0) {
-    r = g = b = l
-  }
-  else {
-    const hue2rgb = (p: number, q: number, t: number) => {
-      if (t < 0)
-        t += 1
-      if (t > 1)
-        t -= 1
-      if (t < 1 / 6)
-        return p + (q - p) * 6 * t
-      if (t < 1 / 2)
-        return q
-      if (t < 2 / 3)
-        return p + (q - p) * (2 / 3 - t) * 6
-      return p
-    }
-
-    const q = l < 0.5 ? l * (1 + s) : l + s - l * s
-    const p = 2 * l - q
-
-    r = hue2rgb(p, q, h + 1 / 3)
-    g = hue2rgb(p, q, h)
-    b = hue2rgb(p, q, h - 1 / 3)
-  }
-
-  return {
-    r: Math.round(r * 255),
-    g: Math.round(g * 255),
-    b: Math.round(b * 255),
-  }
-}
-
-/**
- * 基于主色调生成随机颜色
- * @param {string} baseHex - 基础十六进制颜色，如 #2164F3
- * @param {object} options - 配置选项
- * @returns {object} 颜色对象
- */
-export function generateRandomColorFromHex(baseHex: string, options = { hueRange: 15, saturationRange: 20, lightnessRange: 20 }) {
-  const {
-    hueRange = 15,
-    saturationRange = 20,
-    lightnessRange = 20,
-  } = options
-
-  // 转换为RGB
-  const baseRgb = hexToRgb(baseHex)
-
-  // 转换为HSL
-  const baseHsl = rgbToHsl(baseRgb.r, baseRgb.g, baseRgb.b)
-
-  // 在指定范围内随机调整HSL值
-  const randomH = baseHsl.h + (Math.random() * 2 - 1) * hueRange
-  const randomS = baseHsl.s + (Math.random() * 2 - 1) * saturationRange
-  const randomL = baseHsl.l + (Math.random() * 2 - 1) * lightnessRange
-
-  // 确保值在有效范围内
-  const h = Math.max(0, Math.min(360, randomH))
-  const s = Math.max(0, Math.min(100, randomS))
-  const l = Math.max(0, Math.min(100, randomL))
-
-  // 转换回RGB
-  const rgb = hslToRgb(h, s, l)
-  const hex = rgbToHex(rgb)
-
-  return {
-    hex,
-    rgb,
-    hsl: { h: Math.round(h), s: Math.round(s), l: Math.round(l) },
-  }
-}
-
-/**
- * 批量生成协调的颜色
- * @param {string} baseHex - 基础十六进制颜色
- * @param {number} count - 需要生成的颜色数量
- * @param {object} options - 配置选项
- * @returns {Array} 颜色数组
- */
-export function generateHarmoniousColors(baseHex: string, count: number, options = { hueRange: 15, saturationRange: 20, lightnessRange: 20, colorType: 'all' }) {
-  const colors = []
-  const baseRgb = hexToRgb(baseHex)
-  const baseHsl = rgbToHsl(baseRgb.r, baseRgb.g, baseRgb.b)
-
-  const {
-    hueRange = 15,
-    saturationRange = 20,
-    lightnessRange = 20,
-    // 新增：颜色类型，可选值：'all', 'light', 'dark', 'muted'
-    colorType = 'all',
-  } = options
-
-  // 使用let声明，允许重新赋值
-  let adjustedSaturationRange = saturationRange
-
-  // 根据颜色类型调整基础亮度
-  let baseLightness = baseHsl.l
-  if (colorType === 'light') {
-    baseLightness = Math.min(80, baseHsl.l + 20)
-  }
-  else if (colorType === 'dark') {
-    baseLightness = Math.max(20, baseHsl.l - 20)
-  }
-  else if (colorType === 'muted') {
-    adjustedSaturationRange = Math.min(adjustedSaturationRange, 15)
-  }
-
-  for (let i = 0; i < count; i++) {
-    // 在指定范围内随机调整HSL值
-    const randomH = baseHsl.h + (Math.random() * 2 - 1) * hueRange
-    const randomS = baseHsl.s + (Math.random() * 2 - 1) * adjustedSaturationRange
-    const randomL = baseLightness + (Math.random() * 2 - 1) * lightnessRange
-
-    // 确保值在有效范围内
-    const h = Math.max(0, Math.min(360, randomH))
-    const s = Math.max(0, Math.min(100, randomS))
-    const l = Math.max(0, Math.min(100, randomL))
-
-    // 转换回RGB
-    const rgb = hslToRgb(h, s, l)
-    const hex = rgbToHex(rgb)
-
-    colors.push({
-      hex,
-      rgb,
-      hsl: { h: Math.round(h), s: Math.round(s), l: Math.round(l) },
-      rgbString: `rgb(${rgb.r}, ${rgb.g}, ${rgb.b})`,
-    })
-  }
-
-  return colors
-}
-
-/**
- * 生成一组完美的图标颜色（智能算法）
- * @param {string} baseHex - 基础颜色
- * @param {number} count - 图标数量
- * @returns {Array} 优化后的颜色数组
- */
-export function generateIconColors(baseHex: string, count: number) {
-  const baseRgb = hexToRgb(baseHex)
-  const baseHsl = rgbToHsl(baseRgb.r, baseRgb.g, baseRgb.b)
-  const colors = []
-
-  // 根据数量调整色相分布
-  const hueStep = 360 / (count + 1)
-
-  for (let i = 0; i < count; i++) {
-    // 创建更均匀的色相分布
-    let hue = (baseHsl.h + (i * hueStep)) % 360
-
-    // 保持主色调附近有一些颜色
-    if (i < 3) {
-      hue = baseHsl.h + (i - 1) * 10
-    }
-
-    // 智能调整饱和度和亮度
-    // 重要图标更鲜艳，次要图标更柔和
-    const saturation = Math.max(60, Math.min(90, baseHsl.s + (Math.random() * 20 - 10),
-    ))
-
-    // 创建对比度：一些更亮，一些更暗
-    const lightness = i % 2 === 0
-      ? Math.min(70, baseHsl.l + 15 + Math.random() * 10)
-      : Math.max(30, baseHsl.l - 10 + Math.random() * 10)
-
-    const rgb = hslToRgb(hue, saturation, lightness)
-    const hex = rgbToHex(rgb)
-
-    colors.push({
-      hex,
-      rgb,
-      hsl: { h: Math.round(hue), s: Math.round(saturation), l: Math.round(lightness) },
-      rgbString: `rgb(${rgb.r}, ${rgb.g}, ${rgb.b})`,
-    })
-  }
-
-  return colors
-}
-
-/**
- * 检查颜色对比度是否足够（用于文本可读性）
- * @param {string} hexColor - 十六进制颜色
- * @param {string} backgroundColor - 背景十六进制颜色，默认白色
- * @returns {number} 对比度比率
- */
-export function getContrastRatio(hexColor: string, backgroundColor = '#FFFFFF') {
-  const rgb1 = hexToRgb(hexColor)
-  const rgb2 = hexToRgb(backgroundColor)
-
-  const luminance1 = getLuminance(rgb1)
-  const luminance2 = getLuminance(rgb2)
-
-  const lighter = Math.max(luminance1, luminance2)
-  const darker = Math.min(luminance1, luminance2)
-
-  return (lighter + 0.05) / (darker + 0.05)
-}
-
-/**
- * 计算颜色亮度
- * @param {object} rgb - RGB对象
- * @returns {number} 亮度值
- */
-function getLuminance(rgb: { r: number, g: number, b: number }) {
-  const [r, g, b] = [rgb.r, rgb.g, rgb.b].map((v) => {
-    v /= 255
-    return v <= 0.03928 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4
-  })
-
-  return 0.2126 * r + 0.7152 * g + 0.0722 * b
-}
-
-/**
- * 生成颜色变体（浅色、深色等）
- * @param {string} hex - 基础颜色
- * @param {string} variant - 变体类型：'lighter', 'light', 'dark', 'darker', 'muted'
- * @returns {string} 变体颜色的十六进制值
- */
-export function getColorVariant(hex: string, variant = 'light') {
-  const rgb = hexToRgb(hex)
-  const hsl = rgbToHsl(rgb.r, rgb.g, rgb.b)
-
-  switch (variant) {
-    case 'lighter':
-      hsl.l = Math.min(95, hsl.l + 40)
-      hsl.s = Math.max(30, hsl.s - 10)
-      break
-    case 'light':
-      hsl.l = Math.min(85, hsl.l + 30)
-      hsl.s = Math.max(40, hsl.s - 15)
-      break
-    case 'dark':
-      hsl.l = Math.max(20, hsl.l - 20)
-      hsl.s = Math.min(80, hsl.s + 10)
-      break
-    case 'darker':
-      hsl.l = Math.max(10, hsl.l - 30)
-      hsl.s = Math.min(70, hsl.s + 20)
-      break
-    case 'muted':
-      hsl.s = Math.max(20, hsl.s - 30)
-      break
-  }
-
-  const variantRgb = hslToRgb(hsl.h, hsl.s, hsl.l)
-  return rgbToHex(variantRgb)
-}
-
-/**
- *
- *
- * 获取字符串的第一个字符
- * @param {string} str - 输入的字符串
- * @returns {string} 字符串的第一个字符
- */
-export function getFirstChar(str: string) {
-  return str.charAt(0)
-}
-
-// 生成七彩虹范围内的任意颜色
-/**
- * 七彩虹颜色范围（HSL表示）
- * 每个颜色范围：色相(H)范围，饱和度(S)固定，亮度(L)固定
- * 选择较高的饱和度(70-80%)和中等亮度(45-55%)以确保白色文字可见
- */
-const COLOR_RANGES = [
-  { name: '红', hueRange: [0, 10], saturation: 75, lightness: 50 },
-  { name: '橙', hueRange: [20, 40], saturation: 75, lightness: 50 },
-  { name: '黄', hueRange: [45, 60], saturation: 75, lightness: 45 }, // 黄色稍微暗一点以保证白色文字可见
-  { name: '绿', hueRange: [90, 140], saturation: 70, lightness: 45 },
-  { name: '青', hueRange: [160, 190], saturation: 70, lightness: 50 },
-  { name: '蓝', hueRange: [200, 240], saturation: 75, lightness: 45 },
-  { name: '紫', hueRange: [260, 300], saturation: 70, lightness: 50 },
-  { name: '粉', hueRange: [310, 340], saturation: 70, lightness: 55 },
-] as const
-
-type ColorRange = typeof COLOR_RANGES[number]
-
-/**
- * 将HSL转换为十六进制颜色
- */
-function hslToHex(h: number, s: number, l: number): string {
-  l /= 100
-  const a = s * Math.min(l, 1 - l) / 100
-  const f = (n: number) => {
-    const k = (n + h / 30) % 12
-    const color = l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1)
-    return Math.round(255 * color).toString(16).padStart(2, '0')
-  }
-  return `#${f(0)}${f(8)}${f(4)}`
-}
-
-/**
- * 检查颜色是否为暗色系
- * 通过HSL的亮度判断，亮度低于30%的被认为是暗色
- */
-function isDarkColor(h: number, s: number, l: number): boolean {
-  return l < 30
-}
-
-/**
- * 七彩虹颜色生成器类
- */
-export class RainbowColorGenerator {
-  private lastColorRange: ColorRange | null = null
-  private lastColorHex: string | null = null
-
-  /**
-   * 生成随机颜色值
-   */
-  private generateRandomColorFromRange(range: ColorRange): string {
-    const { hueRange, saturation, lightness } = range
-    const hue = Math.floor(Math.random() * (hueRange[1] - hueRange[0] + 1)) + hueRange[0]
-
-    // 确保颜色不是暗色系
-    if (isDarkColor(hue, saturation, lightness)) {
-      // 如果亮度太低，增加亮度到安全范围
-      return hslToHex(hue, saturation, Math.max(lightness, 40))
-    }
-
-    return hslToHex(hue, saturation, lightness)
-  }
-
-  /**
-   * 检查两个颜色是否属于同一个色系
-   */
-  private isSameColorRange(range1: ColorRange, range2: ColorRange): boolean {
-    return range1.name === range2.name
-  }
-
-  /**
-   * 获取可用的颜色范围（排除上一个使用的颜色范围）
-   */
-  private getAvailableRanges(): ColorRange[] {
-    if (!this.lastColorRange) {
-      return [...COLOR_RANGES]
-    }
-    return COLOR_RANGES.filter(range => !this.isSameColorRange(range, this.lastColorRange!))
-  }
-
-  /**
-   * 获取下一个随机颜色
-   * @returns 十六进制颜色字符串
-   */
-  getNextColor(): string {
-    const availableRanges = this.getAvailableRanges()
-
-    // 随机选择一个颜色范围
-    const randomIndex = Math.floor(Math.random() * availableRanges.length)
-    const selectedRange = availableRanges[randomIndex]
-
-    // 生成颜色
-    const color = this.generateRandomColorFromRange(selectedRange)
-
-    // 更新上一个颜色
-    this.lastColorRange = selectedRange
-    this.lastColorHex = color
-
-    return color
-  }
-
-  /**
-   * 重置生成器状态
-   */
-  reset(): void {
-    this.lastColorRange = null
-    this.lastColorHex = null
-  }
-
-  /**
-   * 获取上一个生成的颜色
-   */
-  getLastColor(): string | null {
-    return this.lastColorHex
-  }
-}
-/**
- * 格式化手机号
- * @param phone 手机号字符串
- * @param mask 隐藏码，默认为****
- * @returns 格式化后的手机号字符串
- */
-export function formatPhone(phone: string, mask = '****') {
-  if (!phone) return '';
-
-  const cleanPhone = phone.replace(/\D/g, '');
-  const len = cleanPhone.length;
-
-  // 根据号码长度决定显示方式
-  if (len === 11) {
-    return cleanPhone.slice(0, 3) + mask + cleanPhone.slice(-4);
-  } else if (len === 8) {
-    // 座机号码等短号码
-    return cleanPhone.slice(0, 2) + mask + cleanPhone.slice(-2);
-  }
-
-  return phone;
-}
+import type { Comparator } from '../type'
+
+// const filefxd = ['image', 'video', 'audio', 'file', 'wav']
+const baseUrl = uni.getStorageSync('BASE_URL')
+const token = uni.getStorageSync('TOKEN')
+const hydrocarbonProgramToken = uni.getStorageSync('HYDROCARBON_PROGRAM_TOKEN')
+
+/**
+ * 获取当前页面路径
+ * @returns 当前页面路径
+ */
+export function getCurrentPath() {
+  const pages = getCurrentPages()
+  const currentPage = pages[pages.length - 1]
+  return currentPage.route || ''
+}
+
+/**
+ * 格式化列表项展示数据
+ * @param data 数据值
+ * @param type 数据类型
+ * @returns 格式化后的数据
+ */
+export function formatItemData(data: any, type: string) {
+  // console.log('[Mock] formatItemData', data, type)
+  if (type === 'relselect' || type === 'tree-entity-select' || type === 'table-entity-select') {
+    // 判断data是否为数组
+    if (Array.isArray(data)) {
+      const dataArr = data.map(item => item.split('@R@')[1]).join(',')
+      return dataArr
+    }
+    // 字符串中是否包含@,@
+    if (typeof data === 'string' && data.includes('@,@')) {
+      return data.split('@,@').map((item: string) => item.split('@R@')[1]).join(',')
+    }
+
+    // 字符串中是否包含@R@
+    if (typeof data === 'string' && data.includes('@R@')) {
+      return data.split('@R@')[1]
+    }
+
+    return data || ''
+  }
+
+  if (type === 'datetime') {
+    return data ? data.split('.')[0] : ''
+  }
+
+  if (type === 'file' || type === 'relfile' || type === 'video') {
+    if (data) {
+      // 判断是否为JSON文件
+      if (typeof data === 'string') {
+        const a = JSON.parse(data)
+        return [{
+          url: `${baseUrl}/v3/files${a.base.path}?@token=${token}&@programToken=${hydrocarbonProgramToken}&name=${a.base.fileName || ''}`,
+          name: a.base.fileName,
+          type: a.base.type,
+        }]
+      }
+      else if (Array.isArray(data)) {
+        return data.map((item) => {
+          if (item.includes('@R@')) {
+            const a = JSON.parse(item.split('@R@')[1])
+            return {
+              url: `${baseUrl}/v3/files${a.base.path}?@token=${token}&@programToken=${hydrocarbonProgramToken}&name=${a.base.fileName || ''}`,
+              name: a.base.fileName,
+              type: a.base.type,
+            }
+          }
+          else {
+            const a = JSON.parse(item)
+            return {
+              url: `${baseUrl}/v3/files${a.base.path}?@token=${token}&@programToken=${hydrocarbonProgramToken}&name=${a.base.fileName || ''}`,
+              name: a.base.fileName,
+              type: a.base.type,
+            }
+          }
+        })
+      }
+      else {
+        return [{
+          url: data.url,
+          name: data.name,
+          type: getAfterLastMatch(data.name, '.') || getAfterLastMatch(data.url, '.'),
+        }]
+      }
+    }
+    return [{
+      url: 'https://',
+      name: '',
+      type: 'img',
+    }]
+  }
+
+  return data
+}
+
+/**
+ * 高并发环境下也能保证唯一的ID生成器
+ * @returns 25字符的唯一字符串
+ */
+let counter = 0
+export function generateHighResolutionID(): string {
+  const time = Date.now().toString(36)
+  const random = Math.random().toString(36).substring(2, 10)
+  counter = (counter + 1) % Number.MAX_SAFE_INTEGER
+  return `${time}-${random}-${counter.toString(36).padStart(6, '0')}`
+}
+
+// 下载文件
+export function downloadFile(url: string) {
+  console.log('下载', url)
+  uni.downloadFile({
+    url, // 文件的网络地址
+    success: (res) => {
+      if (res.statusCode === 200) {
+        console.log('下载成功', res.tempFilePath)
+        // 打开文件（如PDF、Word等）
+        uni.openDocument({
+          filePath: res.tempFilePath,
+          showMenu: true,
+          success: () => console.log('打开文件成功'),
+        })
+      }
+      else {
+        console.error('下载失败', res)
+        uni.showToast({
+          title: '下载失败',
+          icon: 'none',
+        })
+      }
+    },
+    fail: (err) => {
+      console.error('下载失败', err)
+      uni.showToast({
+        title: '下载失败',
+        icon: 'none',
+      })
+    },
+  })
+}
+
+/**
+ * 字符串截取匹配最后一项（不包含匹配字符）
+ *
+ *
+ */
+function getAfterLastMatch(str: string, pattern: string) {
+  const lastIndex = str.lastIndexOf(pattern)
+  if (lastIndex === -1)
+    return null
+  return str.substring(lastIndex + pattern.length)
+}
+
+/****
+ *
+ * 根据comparator、defaultValue、val
+ * 判断按钮是否满足显示
+ *
+ *
+ */
+export function comparator(
+  comparator: Comparator,
+  val: string,
+  defaultValue: string,
+): boolean {
+  let dvs: string[]
+  let value = val
+  if (val && val.indexOf && val.indexOf('@R@') > 0) {
+    const vs = val.split('@R@')
+    value = vs[1]
+  }
+
+  if (!comparator) {
+    comparator = 'equals'
+  }
+
+  if (comparator === 'none1') {
+    return !value || value === ''
+  }
+  else if (comparator === 'none1n') {
+    return !!value && value !== ''
+  }
+
+  if (!defaultValue) {
+    return true
+  }
+
+  if (!value && value !== '0') {
+    return false
+  }
+  let vals
+  switch (comparator) {
+    case 'contain':
+      return value.includes(defaultValue)
+    case 'equal':
+    case 'equals':
+      return isEqual(value, defaultValue)
+    case 'exclude':
+      dvs = toArray(defaultValue)
+      vals = toArray(value)
+      for (let i = 0; i < dvs.length; i++) {
+        for (let j = 0; j < vals.length; j++) {
+          if (dvs[i] === vals[j]) {
+            return false
+          }
+        }
+      }
+      return true
+    case 'includeOne':
+    case 'include_anyone':
+      dvs = toArray(defaultValue)
+      vals = toArray(value)
+      for (let i = 0; i < dvs.length; i++) {
+        for (let j = 0; j < vals.length; j++) {
+          if (dvs[i] === vals[j]) {
+            return true
+          }
+        }
+      }
+      return false
+
+    case 'include_all':
+    {
+      dvs = toArray(defaultValue)
+      vals = toArray(value)
+      let count = 0
+      const targetCount = dvs.length
+      for (let i = 0; i < dvs.length; i++) {
+        for (let j = 0; j < vals.length; j++) {
+          if (dvs[i] === vals[j]) {
+            count++
+            break
+          }
+        }
+      }
+      return targetCount <= count
+    }
+    case 'Greater':
+    case 'greater':
+      if (!Number.isNaN(Number(value)) && !Number.isNaN(Number(defaultValue))) {
+        return Number(value) > Number(defaultValue)
+      }
+      else {
+        return value > defaultValue
+      }
+    case 'Less':
+    case 'less':
+      if (!Number.isNaN(Number(value)) && !Number.isNaN(Number(defaultValue))) {
+        return Number(value) < Number(defaultValue)
+      }
+      else {
+        return value < defaultValue
+      }
+    case 'noGreater':
+    case 'nogreater':
+      if (!Number.isNaN(Number(value)) && !Number.isNaN(Number(defaultValue))) {
+        return Number(value) <= Number(defaultValue)
+      }
+      else {
+        return value <= defaultValue
+      }
+    case 'noLess':
+    case 'noless':
+      if (!Number.isNaN(Number(value)) && !Number.isNaN(Number(defaultValue))) {
+        return Number(value) >= Number(defaultValue)
+      }
+      else {
+        return value >= defaultValue
+      }
+    case 'unequal':
+    case 'unequals':
+      return !isEqual(value, defaultValue)
+    default:
+      console.log(`暂不支持的比较关系：${comparator};请联系管理员添加。`)
+      return false // 兜底返回值
+  }
+}
+
+function isEqual(value: string, defaultValue: string) {
+  if (defaultValue === '是' || defaultValue === '否' || defaultValue === 'true' || defaultValue === 'false') {
+    if (value === 'true' || value === '是') {
+      if (defaultValue === '是' || defaultValue === 'true') {
+        return true
+      }
+      else {
+        return false
+      }
+    }
+    else if (value === 'false' || value === '否') {
+      if (defaultValue === '否' || defaultValue === 'false') {
+        return true
+      }
+      else {
+        return false
+      }
+    }
+    else {
+      return false
+    }
+  }
+  else {
+    if (!Number.isNaN(Number(value)) && !Number.isNaN(Number(defaultValue))) {
+      return Number(value) === Number(defaultValue)
+    }
+    else {
+      return value === defaultValue
+    }
+  }
+}
+
+function toArray(value: string) {
+  let val
+  if (typeof value == 'string') {
+    val = value.split(',')
+  }
+  else if (Array.isArray(value)) {
+    val = value
+  }
+  else {
+    val = [value]
+  }
+  return val
+}
+
+/**
+ * 根据目标颜色生成渐变色字符串
+ * @param color - 目标颜色，可以是十六进制颜色或RGB颜色
+ * @param angle - 渐变角度，默认为180deg
+ * @param startOpacity - 起始透明度，默认为1(不透明)
+ * @param endOpacity - 结束透明度，默认为0.3
+ * @returns 渐变色字符串
+ */
+export function generateGradientColor(
+  color: string,
+  angle: number = 180,
+  startOpacity: number = 1,
+  endOpacity: number = 0.3,
+): string {
+  // 处理十六进制颜色转换为RGB
+  const hexToRgb = (hex: string): { r: number, g: number, b: number } | null => {
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex)
+    return result
+      ? {
+          r: Number.parseInt(result[1], 16),
+          g: Number.parseInt(result[2], 16),
+          b: Number.parseInt(result[3], 16),
+        }
+      : null
+  }
+
+  // 将RGB颜色转换为rgba格式
+  const toRgba = (color: string, opacity: number): string => {
+    if (color.startsWith('#')) {
+      const rgb = hexToRgb(color)
+      if (rgb) {
+        return `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, ${opacity})`
+      }
+    }
+    else if (color.startsWith('rgb(')) {
+      // 处理rgb()格式
+      const rgbValues = color.match(/\d+/g)
+      if (rgbValues && rgbValues.length === 3) {
+        return `rgba(${rgbValues[0]}, ${rgbValues[1]}, ${rgbValues[2]}, ${opacity})`
+      }
+    }
+    // 如果已经是rgba或其他格式，直接返回带透明度的版本
+    return color.replace(/rgb\(/, 'rgba(').replace(/\)/, `, ${opacity})`)
+  }
+
+  // 生成渐变色字符串
+  const startColor = color.startsWith('rgba') ? color : toRgba(color, startOpacity)
+  const endColor = toRgba(color, endOpacity)
+
+  return `linear-gradient(${angle}deg, ${startColor} 0%, ${endColor} 100%)`
+}
+
+// 使用示例
+// console.log(generateGradientColor('#2094FF'));
+// 输出: linear-gradient(180deg, rgba(32,148,255,1) 0%, rgba(32,148,255,0.3) 100%)
+
+// console.log(generateGradientColor('#2094FF', 90, 0.8, 0.1));
+// 输出: linear-gradient(90deg, rgba(32,148,255,0.8) 0%, rgba(32,148,255,0.1) 100%)
+
+/**
+ * 格式化日期显示
+ * @param date - 要格式化的日期，默认为当前日期
+ * @returns 格式化后的日期字符串，如"2025年9月25日 周四 下午"
+ */
+export function formatChineseDate(date: Date = new Date()): string {
+  // 年份
+  const year = date.getFullYear()
+
+  // 月份（月份从0开始，需要+1）
+  const month = date.getMonth() + 1
+
+  // 日期
+  const day = date.getDate()
+
+  // 星期几
+  const weekdays = ['周日', '周一', '周二', '周三', '周四', '周五', '周六']
+  const weekday = weekdays[date.getDay()]
+
+  // 上午/下午判断
+  const hour = date.getHours()
+  const period = hour < 12 ? '上午' : '下午'
+
+  return `${year}年${month}月${day}日 ${weekday} ${period}`
+}
+
+// 使用示例
+// console.log(formatChineseDate(new Date(2025, 8, 25)));
+// 输出: 2025年9月25日 周四 下午
+
+// console.log(formatChineseDate(new Date(2025, 8, 25, 10, 30)));
+// 输出: 2025年9月25日 周四 上午
+
+// console.log(formatChineseDate());
+// 输出当前日期的格式化结果
+
+/**
+ * 淡化颜色
+ * @param color - 目标颜色，可以是十六进制颜色或RGB颜色
+ * @returns 淡化后的颜色字符串
+ */
+export function desaturateColor(color: string, opacity: number = 0.04): string {
+  // 处理十六进制颜色转换为RGB
+  const hexToRgb = (hex: string): { r: number, g: number, b: number } | null => {
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex)
+    return result
+      ? {
+          r: Number.parseInt(result[1], 16),
+          g: Number.parseInt(result[2], 16),
+          b: Number.parseInt(result[3], 16),
+        }
+      : null
+  }
+  // 将RGB颜色转换为rgba格式
+  const toRgba = (color: string, opacity: number): string => {
+    if (color.startsWith('#')) {
+      const rgb = hexToRgb(color)
+      if (rgb) {
+        return `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, ${opacity})`
+      }
+    }
+    else if (color.startsWith('rgb(')) {
+      // 处理rgb()格式
+      const rgbValues = color.match(/\d+/g)
+      if (rgbValues && rgbValues.length === 3) {
+        return `rgba(${rgbValues[0]}, ${rgbValues[1]}, ${rgbValues[2]}, ${opacity})`
+      }
+    }
+    // 如果已经是rgba或其他格式，直接返回带透明度的版本
+    return color.replace(/rgb\(/, 'rgba(').replace(/\)/, `, ${opacity})`)
+  }
+
+  return toRgba(color, opacity)
+}
+
+/**
+ * 扩展版本：判断字符串中是否包含多个字符中的任意一个
+ */
+export function containsAnyCharacter(str: string, chars: string[]): boolean {
+  if (typeof str !== 'string' || !Array.isArray(chars)) {
+    return false
+  }
+
+  // 验证数组中的每个元素都是单个字符
+  for (const char of chars) {
+    if (typeof char !== 'string' || char.length !== 1) {
+      throw new Error('数组中的每个元素必须是单个字符')
+    }
+  }
+
+  return chars.some(char => str.includes(char))
+}
+// 测试用例
+// console.log(containsAnyCharacter("hello world", ["a", "e", "i", "o", "u"])); // true (包含o)
+
+/**
+ * 颜色转换和生成工具类 (针对十六进制颜色优化)
+ */
+
+/**
+ * 十六进制颜色转换为RGB对象
+ * @param {string} hex - 十六进制颜色值，如 #2164F3 或 2164F3
+ * @returns {object} RGB对象 {r, g, b}
+ */
+export function hexToRgb(hex: string) {
+  // 移除 # 号
+  hex = hex.replace(/^#/, '')
+
+  // 处理简写形式如 #FFF
+  if (hex.length === 3) {
+    hex = hex.split('').map(c => c + c).join('')
+  }
+
+  // 解析十六进制值
+  const bigint = Number.parseInt(hex, 16)
+
+  return {
+    r: (bigint >> 16) & 255,
+    g: (bigint >> 8) & 255,
+    b: bigint & 255,
+  }
+}
+
+/**
+ * RGB对象转换为十六进制颜色
+ * @param {object} rgb - RGB对象 {r, g, b}
+ * @returns {string} 十六进制颜色值
+ */
+export function rgbToHex(rgb: { r: any, g: any, b: any }) {
+  const toHex = (c: { toString: (arg0: number) => any }) => {
+    const hex = c.toString(16)
+    return hex.length === 1 ? `0${hex}` : hex
+  }
+  return `#${toHex(rgb.r)}${toHex(rgb.g)}${toHex(rgb.b)}`.toUpperCase()
+}
+
+/**
+ * 将 RGB 颜色转换为 HSL 颜色模型
+ * @param {number} r - 红色值 (0-255)
+ * @param {number} g - 绿色值 (0-255)
+ * @param {number} b - 蓝色值 (0-255)
+ * @returns {object} HSL对象 {h, s, l}
+ */
+export function rgbToHsl(r: number, g: number, b: number) {
+  r /= 255
+  g /= 255
+  b /= 255
+
+  const max = Math.max(r, g, b)
+  const min = Math.min(r, g, b)
+  let h
+  let s
+  const l = (max + min) / 2
+
+  if (max === min) {
+    h = s = 0
+  }
+  else {
+    const d = max - min
+    s = l > 0.5 ? d / (2 - max - min) : d / (max + min)
+
+    switch (max) {
+      case r: h = (g - b) / d + (g < b ? 6 : 0)
+        break
+      case g: h = (b - r) / d + 2
+        break
+      case b: h = (r - g) / d + 4
+        break
+      default: h = 0 // 添加默认情况，确保h被初始化
+    }
+
+    h /= 6
+  }
+
+  return {
+    h: Math.round(h * 360),
+    s: Math.round(s * 100),
+    l: Math.round(l * 100),
+  }
+}
+
+/**
+ * 将 HSL 颜色转换为 RGB 颜色
+ * @param {number} h - 色相 (0-360)
+ * @param {number} s - 饱和度 (0-100)
+ * @param {number} l - 亮度 (0-100)
+ * @returns {object} RGB对象 {r, g, b}
+ */
+export function hslToRgb(h: number, s: number = 50, l: number = 50): { r: number, g: number, b: number } {
+  h = h !== undefined ? h / 360 : 0
+  s = s !== undefined ? s / 100 : 0.5
+  l = l !== undefined ? l / 100 : 0.5
+
+  let r, g, b
+
+  if (s === 0) {
+    r = g = b = l
+  }
+  else {
+    const hue2rgb = (p: number, q: number, t: number) => {
+      if (t < 0)
+        t += 1
+      if (t > 1)
+        t -= 1
+      if (t < 1 / 6)
+        return p + (q - p) * 6 * t
+      if (t < 1 / 2)
+        return q
+      if (t < 2 / 3)
+        return p + (q - p) * (2 / 3 - t) * 6
+      return p
+    }
+
+    const q = l < 0.5 ? l * (1 + s) : l + s - l * s
+    const p = 2 * l - q
+
+    r = hue2rgb(p, q, h + 1 / 3)
+    g = hue2rgb(p, q, h)
+    b = hue2rgb(p, q, h - 1 / 3)
+  }
+
+  return {
+    r: Math.round(r * 255),
+    g: Math.round(g * 255),
+    b: Math.round(b * 255),
+  }
+}
+
+/**
+ * 基于主色调生成随机颜色
+ * @param {string} baseHex - 基础十六进制颜色，如 #2164F3
+ * @param {object} options - 配置选项
+ * @returns {object} 颜色对象
+ */
+export function generateRandomColorFromHex(baseHex: string, options = { hueRange: 15, saturationRange: 20, lightnessRange: 20 }) {
+  const {
+    hueRange = 15,
+    saturationRange = 20,
+    lightnessRange = 20,
+  } = options
+
+  // 转换为RGB
+  const baseRgb = hexToRgb(baseHex)
+
+  // 转换为HSL
+  const baseHsl = rgbToHsl(baseRgb.r, baseRgb.g, baseRgb.b)
+
+  // 在指定范围内随机调整HSL值
+  const randomH = baseHsl.h + (Math.random() * 2 - 1) * hueRange
+  const randomS = baseHsl.s + (Math.random() * 2 - 1) * saturationRange
+  const randomL = baseHsl.l + (Math.random() * 2 - 1) * lightnessRange
+
+  // 确保值在有效范围内
+  const h = Math.max(0, Math.min(360, randomH))
+  const s = Math.max(0, Math.min(100, randomS))
+  const l = Math.max(0, Math.min(100, randomL))
+
+  // 转换回RGB
+  const rgb = hslToRgb(h, s, l)
+  const hex = rgbToHex(rgb)
+
+  return {
+    hex,
+    rgb,
+    hsl: { h: Math.round(h), s: Math.round(s), l: Math.round(l) },
+  }
+}
+
+/**
+ * 批量生成协调的颜色
+ * @param {string} baseHex - 基础十六进制颜色
+ * @param {number} count - 需要生成的颜色数量
+ * @param {object} options - 配置选项
+ * @returns {Array} 颜色数组
+ */
+export function generateHarmoniousColors(baseHex: string, count: number, options = { hueRange: 15, saturationRange: 20, lightnessRange: 20, colorType: 'all' }) {
+  const colors = []
+  const baseRgb = hexToRgb(baseHex)
+  const baseHsl = rgbToHsl(baseRgb.r, baseRgb.g, baseRgb.b)
+
+  const {
+    hueRange = 15,
+    saturationRange = 20,
+    lightnessRange = 20,
+    // 新增：颜色类型，可选值：'all', 'light', 'dark', 'muted'
+    colorType = 'all',
+  } = options
+
+  // 使用let声明，允许重新赋值
+  let adjustedSaturationRange = saturationRange
+
+  // 根据颜色类型调整基础亮度
+  let baseLightness = baseHsl.l
+  if (colorType === 'light') {
+    baseLightness = Math.min(80, baseHsl.l + 20)
+  }
+  else if (colorType === 'dark') {
+    baseLightness = Math.max(20, baseHsl.l - 20)
+  }
+  else if (colorType === 'muted') {
+    adjustedSaturationRange = Math.min(adjustedSaturationRange, 15)
+  }
+
+  for (let i = 0; i < count; i++) {
+    // 在指定范围内随机调整HSL值
+    const randomH = baseHsl.h + (Math.random() * 2 - 1) * hueRange
+    const randomS = baseHsl.s + (Math.random() * 2 - 1) * adjustedSaturationRange
+    const randomL = baseLightness + (Math.random() * 2 - 1) * lightnessRange
+
+    // 确保值在有效范围内
+    const h = Math.max(0, Math.min(360, randomH))
+    const s = Math.max(0, Math.min(100, randomS))
+    const l = Math.max(0, Math.min(100, randomL))
+
+    // 转换回RGB
+    const rgb = hslToRgb(h, s, l)
+    const hex = rgbToHex(rgb)
+
+    colors.push({
+      hex,
+      rgb,
+      hsl: { h: Math.round(h), s: Math.round(s), l: Math.round(l) },
+      rgbString: `rgb(${rgb.r}, ${rgb.g}, ${rgb.b})`,
+    })
+  }
+
+  return colors
+}
+
+/**
+ * 生成一组完美的图标颜色（智能算法）
+ * @param {string} baseHex - 基础颜色
+ * @param {number} count - 图标数量
+ * @returns {Array} 优化后的颜色数组
+ */
+export function generateIconColors(baseHex: string, count: number) {
+  const baseRgb = hexToRgb(baseHex)
+  const baseHsl = rgbToHsl(baseRgb.r, baseRgb.g, baseRgb.b)
+  const colors = []
+
+  // 根据数量调整色相分布
+  const hueStep = 360 / (count + 1)
+
+  for (let i = 0; i < count; i++) {
+    // 创建更均匀的色相分布
+    let hue = (baseHsl.h + (i * hueStep)) % 360
+
+    // 保持主色调附近有一些颜色
+    if (i < 3) {
+      hue = baseHsl.h + (i - 1) * 10
+    }
+
+    // 智能调整饱和度和亮度
+    // 重要图标更鲜艳，次要图标更柔和
+    const saturation = Math.max(60, Math.min(90, baseHsl.s + (Math.random() * 20 - 10),
+    ))
+
+    // 创建对比度：一些更亮，一些更暗
+    const lightness = i % 2 === 0
+      ? Math.min(70, baseHsl.l + 15 + Math.random() * 10)
+      : Math.max(30, baseHsl.l - 10 + Math.random() * 10)
+
+    const rgb = hslToRgb(hue, saturation, lightness)
+    const hex = rgbToHex(rgb)
+
+    colors.push({
+      hex,
+      rgb,
+      hsl: { h: Math.round(hue), s: Math.round(saturation), l: Math.round(lightness) },
+      rgbString: `rgb(${rgb.r}, ${rgb.g}, ${rgb.b})`,
+    })
+  }
+
+  return colors
+}
+
+/**
+ * 检查颜色对比度是否足够（用于文本可读性）
+ * @param {string} hexColor - 十六进制颜色
+ * @param {string} backgroundColor - 背景十六进制颜色，默认白色
+ * @returns {number} 对比度比率
+ */
+export function getContrastRatio(hexColor: string, backgroundColor = '#FFFFFF') {
+  const rgb1 = hexToRgb(hexColor)
+  const rgb2 = hexToRgb(backgroundColor)
+
+  const luminance1 = getLuminance(rgb1)
+  const luminance2 = getLuminance(rgb2)
+
+  const lighter = Math.max(luminance1, luminance2)
+  const darker = Math.min(luminance1, luminance2)
+
+  return (lighter + 0.05) / (darker + 0.05)
+}
+
+/**
+ * 计算颜色亮度
+ * @param {object} rgb - RGB对象
+ * @returns {number} 亮度值
+ */
+function getLuminance(rgb: { r: number, g: number, b: number }) {
+  const [r, g, b] = [rgb.r, rgb.g, rgb.b].map((v) => {
+    v /= 255
+    return v <= 0.03928 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4
+  })
+
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b
+}
+
+/**
+ * 生成颜色变体（浅色、深色等）
+ * @param {string} hex - 基础颜色
+ * @param {string} variant - 变体类型：'lighter', 'light', 'dark', 'darker', 'muted'
+ * @returns {string} 变体颜色的十六进制值
+ */
+export function getColorVariant(hex: string, variant = 'light') {
+  const rgb = hexToRgb(hex)
+  const hsl = rgbToHsl(rgb.r, rgb.g, rgb.b)
+
+  switch (variant) {
+    case 'lighter':
+      hsl.l = Math.min(95, hsl.l + 40)
+      hsl.s = Math.max(30, hsl.s - 10)
+      break
+    case 'light':
+      hsl.l = Math.min(85, hsl.l + 30)
+      hsl.s = Math.max(40, hsl.s - 15)
+      break
+    case 'dark':
+      hsl.l = Math.max(20, hsl.l - 20)
+      hsl.s = Math.min(80, hsl.s + 10)
+      break
+    case 'darker':
+      hsl.l = Math.max(10, hsl.l - 30)
+      hsl.s = Math.min(70, hsl.s + 20)
+      break
+    case 'muted':
+      hsl.s = Math.max(20, hsl.s - 30)
+      break
+  }
+
+  const variantRgb = hslToRgb(hsl.h, hsl.s, hsl.l)
+  return rgbToHex(variantRgb)
+}
+
+/**
+ *
+ *
+ * 获取字符串的第一个字符
+ * @param {string} str - 输入的字符串
+ * @returns {string} 字符串的第一个字符
+ */
+export function getFirstChar(str: string) {
+  return str.charAt(0)
+}
+
+// 生成七彩虹范围内的任意颜色
+/**
+ * 七彩虹颜色范围（HSL表示）
+ * 每个颜色范围：色相(H)范围，饱和度(S)固定，亮度(L)固定
+ * 选择较高的饱和度(70-80%)和中等亮度(45-55%)以确保白色文字可见
+ */
+const COLOR_RANGES = [
+  { name: '红', hueRange: [0, 10], saturation: 75, lightness: 50 },
+  { name: '橙', hueRange: [20, 40], saturation: 75, lightness: 50 },
+  { name: '黄', hueRange: [45, 60], saturation: 75, lightness: 45 }, // 黄色稍微暗一点以保证白色文字可见
+  { name: '绿', hueRange: [90, 140], saturation: 70, lightness: 45 },
+  { name: '青', hueRange: [160, 190], saturation: 70, lightness: 50 },
+  { name: '蓝', hueRange: [200, 240], saturation: 75, lightness: 45 },
+  { name: '紫', hueRange: [260, 300], saturation: 70, lightness: 50 },
+  { name: '粉', hueRange: [310, 340], saturation: 70, lightness: 55 },
+] as const
+
+type ColorRange = typeof COLOR_RANGES[number]
+
+/**
+ * 将HSL转换为十六进制颜色
+ */
+function hslToHex(h: number, s: number, l: number): string {
+  l /= 100
+  const a = s * Math.min(l, 1 - l) / 100
+  const f = (n: number) => {
+    const k = (n + h / 30) % 12
+    const color = l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1)
+    return Math.round(255 * color).toString(16).padStart(2, '0')
+  }
+  return `#${f(0)}${f(8)}${f(4)}`
+}
+
+/**
+ * 检查颜色是否为暗色系
+ * 通过HSL的亮度判断，亮度低于30%的被认为是暗色
+ */
+function isDarkColor(h: number, s: number, l: number): boolean {
+  return l < 30
+}
+
+/**
+ * 七彩虹颜色生成器类
+ */
+export class RainbowColorGenerator {
+  private lastColorRange: ColorRange | null = null
+  private lastColorHex: string | null = null
+
+  /**
+   * 生成随机颜色值
+   */
+  private generateRandomColorFromRange(range: ColorRange): string {
+    const { hueRange, saturation, lightness } = range
+    const hue = Math.floor(Math.random() * (hueRange[1] - hueRange[0] + 1)) + hueRange[0]
+
+    // 确保颜色不是暗色系
+    if (isDarkColor(hue, saturation, lightness)) {
+      // 如果亮度太低，增加亮度到安全范围
+      return hslToHex(hue, saturation, Math.max(lightness, 40))
+    }
+
+    return hslToHex(hue, saturation, lightness)
+  }
+
+  /**
+   * 检查两个颜色是否属于同一个色系
+   */
+  private isSameColorRange(range1: ColorRange, range2: ColorRange): boolean {
+    return range1.name === range2.name
+  }
+
+  /**
+   * 获取可用的颜色范围（排除上一个使用的颜色范围）
+   */
+  private getAvailableRanges(): ColorRange[] {
+    if (!this.lastColorRange) {
+      return [...COLOR_RANGES]
+    }
+    return COLOR_RANGES.filter(range => !this.isSameColorRange(range, this.lastColorRange!))
+  }
+
+  /**
+   * 获取下一个随机颜色
+   * @returns 十六进制颜色字符串
+   */
+  getNextColor(): string {
+    const availableRanges = this.getAvailableRanges()
+
+    // 随机选择一个颜色范围
+    const randomIndex = Math.floor(Math.random() * availableRanges.length)
+    const selectedRange = availableRanges[randomIndex]
+
+    // 生成颜色
+    const color = this.generateRandomColorFromRange(selectedRange)
+
+    // 更新上一个颜色
+    this.lastColorRange = selectedRange
+    this.lastColorHex = color
+
+    return color
+  }
+
+  /**
+   * 重置生成器状态
+   */
+  reset(): void {
+    this.lastColorRange = null
+    this.lastColorHex = null
+  }
+
+  /**
+   * 获取上一个生成的颜色
+   */
+  getLastColor(): string | null {
+    return this.lastColorHex
+  }
+}
+/**
+ * 格式化手机号
+ * @param phone 手机号字符串
+ * @param mask 隐藏码，默认为****
+ * @returns 格式化后的手机号字符串
+ */
+export function formatPhone(phone: string, mask = '****') {
+  if (!phone) return '';
+
+  const cleanPhone = phone.replace(/\D/g, '');
+  const len = cleanPhone.length;
+
+  // 根据号码长度决定显示方式
+  if (len === 11) {
+    return cleanPhone.slice(0, 3) + mask + cleanPhone.slice(-4);
+  } else if (len === 8) {
+    // 座机号码等短号码
+    return cleanPhone.slice(0, 2) + mask + cleanPhone.slice(-2);
+  }
+
+  return phone;
+}