adtec-core-package 2.2.2 → 2.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adtec-core-package",
-  "version": "2.2.2",
+  "version": "2.2.4",
   "private": false,
   "type": "module",
   "scripts": {
@@ -40,7 +40,6 @@
     "vue-focus-lock": "^3.0.0",
     "vue-img-viewr": "2.0.11",
     "vue-router": "^4.5.0",
-    "vxe-pc-ui": "4.6.8",
     "vxe-table": "4.13.28",
     "wujie-vue3": "^1.0.24",
     "xlsx-js-style": "^1.2.0"

package/src/components/tooltip/index.ts

@@ -0,0 +1,11 @@
+import VxeTooltipComponent from './src/tooltip'
+
+export const VxeTooltip = Object.assign({}, VxeTooltipComponent, {
+  install (app: import("vue").App) {
+    app.component(VxeTooltipComponent.name as string, VxeTooltipComponent)
+  }
+})
+
+
+export const Tooltip = VxeTooltip
+export default VxeTooltip

package/src/components/tooltip/src/tooltip.ts

@@ -0,0 +1,518 @@
+//@ts-ignore
+import {
+  h,
+  ref,
+  nextTick,
+  onBeforeUnmount,
+  onMounted,
+  computed,
+  reactive,
+  watch,
+  type PropType,
+  type VNode
+} from 'vue'
+
+// 定义属性类型
+interface VxeTooltipPropTypes {
+  modelValue?: boolean
+  content?: string | number
+  trigger?: 'hover' | 'click'
+  theme?: 'dark' | 'light'
+  enterDelay?: number
+  leaveDelay?: number
+  isArrow?: boolean
+  enterable?: boolean
+}
+
+// 定义响应式数据类型
+interface TooltipReactData {
+  target: HTMLElement | null
+  isUpdate: boolean
+  visible: boolean
+  tipContent: string | number
+  tipActive: boolean
+  tipTarget: HTMLElement | null
+  tipZindex: number
+  tipStore: {
+    style: Record<string, string | number>
+    placement: string
+    arrowStyle: Record<string, string | number> | null
+  }
+}
+
+// 定义内部数据类型
+interface TooltipInternalData {
+  showDelayTip?: Function
+}
+
+// 定义组件方法类型
+interface TooltipMethods {
+  open: (target?: HTMLElement | null, content?: string | number) => void
+  close: () => void
+  updatePlacement: () => Promise<void>
+  isActived: () => boolean
+  setActived: (active: boolean) => void
+}
+
+// 简单的防抖函数
+function debounce(func: Function, wait: number) {
+  let timeout: number | null = null
+  return function (this: any, ...args: any[]) {
+    if (timeout) {
+      clearTimeout(timeout)
+    }
+    timeout = window.setTimeout(() => {
+      func.apply(this, args)
+    }, wait) as any
+  }
+}
+
+// 检查值是否为空
+function isNull(value: any): boolean {
+  return value === null || value === undefined
+}
+
+// 检查值是否相等
+function eqNull(value: any): boolean {
+  return value === null || value === undefined || value === ''
+}
+
+export default {
+  name: 'VxeTooltip',
+  props: {
+    modelValue: Boolean,
+    content: [String, Number],
+    trigger: {
+      type: String as PropType<'hover' | 'click'>,
+      default: 'hover'
+    },
+    theme: {
+      type: String as PropType<'dark' | 'light'>,
+      default: 'dark'
+    },
+    isArrow: {
+      type: Boolean,
+      default: true
+    },
+    enterable: {
+      type: Boolean,
+      default: true
+    },
+    enterDelay: {
+      type: Number,
+      default: 0
+    },
+    leaveDelay: {
+      type: Number,
+      default: 0
+    }
+  },
+  emits: ['update:modelValue'],
+  setup(props: VxeTooltipPropTypes, { slots, emit }: any) {
+    // 响应式数据
+    const reactData = reactive<TooltipReactData>({
+      target: null,
+      isUpdate: false,
+      visible: false,
+      tipContent: '',
+      tipActive: false,
+      tipTarget: null,
+      tipZindex: 0,
+      tipStore: {
+        style: {},
+        placement: '',
+        arrowStyle: {}
+      }
+    })
+
+    // 内部数据
+    const internalData: TooltipInternalData = {}
+
+    // DOM 引用
+    const refElem = ref<HTMLDivElement>()
+    const contentWrapperfElem = ref<HTMLDivElement>()
+
+    // 获取 DOM 位置信息
+    const getDomNode = () => {
+      return {
+        scrollTop: window.scrollY || document.documentElement.scrollTop,
+        scrollLeft: window.scrollX || document.documentElement.scrollLeft,
+        visibleWidth: document.documentElement.clientWidth
+      }
+    }
+
+    // 获取元素绝对位置
+    const getAbsolutePos = (element: HTMLElement) => {
+      const rect = element.getBoundingClientRect()
+      return {
+        top: rect.top + getDomNode().scrollTop,
+        left: rect.left + getDomNode().scrollLeft
+      }
+    }
+
+    // 更新提示框位置
+    const updateTipStyle = () => {
+      const { tipTarget, tipStore } = reactData
+      if (tipTarget) {
+        const { scrollTop, scrollLeft, visibleWidth } = getDomNode()
+        const { top, left } = getAbsolutePos(tipTarget)
+        const el = refElem.value
+        if (!el) return
+
+        const marginSize = 6
+        const offsetHeight = el.offsetHeight
+        const offsetWidth = el.offsetWidth
+
+        let tipLeft = left
+        let tipTop = top - offsetHeight - marginSize
+
+        // 水平居中
+        tipLeft = Math.max(
+          marginSize,
+          left + Math.floor((tipTarget.offsetWidth - offsetWidth) / 2)
+        )
+
+        // 检查是否超出右边界
+        if (tipLeft + offsetWidth + marginSize > scrollLeft + visibleWidth) {
+          tipLeft = scrollLeft + visibleWidth - offsetWidth - marginSize
+        }
+
+        // 检查是否超出上边界，如果超出则显示在底部
+        if (top - offsetHeight < scrollTop + marginSize) {
+          tipStore.placement = 'bottom'
+          tipTop = top + tipTarget.offsetHeight + marginSize
+        }
+
+        tipStore.style.top = `${tipTop}px`
+        tipStore.style.left = `${tipLeft}px`
+        tipStore.arrowStyle = {
+          left: `${left - tipLeft + tipTarget.offsetWidth / 2}px`
+        }
+      }
+    }
+
+    // 更新值
+    const updateValue = (value: boolean) => {
+      if (value !== reactData.visible) {
+        reactData.visible = value
+        reactData.isUpdate = true
+        emit('update:modelValue', value)
+      }
+    }
+
+    // 显示提示框
+    const showTip = () => {
+      const el = refElem.value
+      if (el) {
+        const parentNode = el.parentNode
+        if (!parentNode) {
+          document.body.appendChild(el)
+        }
+      }
+
+      updateValue(true)
+      reactData.tipZindex = 1000 // 简化的 z-index
+      reactData.tipStore.placement = 'top'
+      reactData.tipStore.style = {
+        width: 'auto',
+        left: 0,
+        top: 0,
+        zIndex: reactData.tipZindex
+      }
+      reactData.tipStore.arrowStyle = { left: '50%' }
+
+      return nextTick().then(() => {
+        updateTipStyle()
+        return nextTick().then(() => {
+          updateTipStyle()
+        })
+      })
+    }
+
+    // 处理延迟函数
+    const handleDelayFn = () => {
+      internalData.showDelayTip = debounce(() => {
+        if (reactData.tipActive) {
+          showTip()
+        }
+        //@ts-ignore
+      }, props.enterDelay)
+    }
+
+    // 处理显示逻辑
+    const handleVisible = (target: HTMLElement | null, content?: string | number) => {
+      const contentSlot = slots.content
+      if (!contentSlot && (content === '' || eqNull(content))) {
+        return nextTick()
+      }
+
+      if (target) {
+        const { showDelayTip } = internalData
+        const { trigger, enterDelay } = props
+        reactData.tipActive = true
+        reactData.tipTarget = target
+        //@ts-ignore
+        reactData.tipContent = isNull(content) ? '' : content
+
+        if (enterDelay && trigger === 'hover') {
+          if (showDelayTip) {
+            showDelayTip()
+          }
+        } else {
+          return showTip()
+        }
+      }
+      return nextTick()
+    }
+
+    // 事件处理函数
+    const targetMouseenterEvent = () => {
+      handleVisible(reactData.target, props.content)
+    }
+
+    const targetMouseleaveEvent = () => {
+      const { trigger, enterable, leaveDelay } = props
+      reactData.tipActive = false
+
+      if (enterable && trigger === 'hover') {
+        setTimeout(() => {
+          if (!reactData.tipActive) {
+            close()
+          }
+        }, leaveDelay)
+      } else {
+        close()
+      }
+    }
+
+    const wrapperMouseenterEvent = () => {
+      reactData.tipActive = true
+    }
+
+    const wrapperMouseleaveEvent = () => {
+      const { trigger, enterable, leaveDelay } = props
+      reactData.tipActive = false
+
+      if (enterable && trigger === 'hover') {
+        setTimeout(() => {
+          if (!reactData.tipActive) {
+            close()
+          }
+        }, leaveDelay)
+      }
+    }
+
+    const clickEvent = () => {
+      if (reactData.visible) {
+        close()
+      } else {
+        handleVisible(reactData.target, props.content)
+      }
+    }
+
+    // 关闭方法
+    const close = () => {
+      reactData.tipTarget = null
+      reactData.tipActive = false
+      Object.assign(reactData.tipStore, {
+        style: {},
+        placement: '',
+        arrowStyle: null
+      })
+      updateValue(false)
+      return nextTick()
+    }
+
+    // 公开方法
+    const tooltipMethods: TooltipMethods = {
+      open(target?: HTMLElement | null, content?: string | number) {
+        return handleVisible(target || reactData.target, content)
+      },
+      close,
+      updatePlacement() {
+        return nextTick().then(() => {
+          const { tipTarget } = reactData
+          const el = refElem.value
+          if (tipTarget && el) {
+            updateTipStyle()
+            return nextTick().then(() => {
+              updateTipStyle()
+            })
+          }
+        })
+      },
+      isActived() {
+        return reactData.tipActive
+      },
+      setActived(active: boolean) {
+        reactData.tipActive = !!active
+      }
+    }
+
+    // 渲染内容
+    const renderContent = () => {
+      const { tipContent } = reactData
+      const contentSlot = slots.content
+
+      const contVNs: VNode[] = []
+      if (contentSlot) {
+        contVNs.push(
+          h('div', {}, contentSlot({}))
+        )
+      } else {
+        contVNs.push(
+          h('div', {}, `${tipContent}`)
+        )
+      }
+
+      return h('div', {
+        ref: contentWrapperfElem,
+        class: 'vxe-tooltip--content'
+      }, contVNs)
+    }
+
+    // 渲染虚拟节点
+    const renderVN = () => {
+      const { theme, isArrow, enterable } = props
+      const { tipActive, visible, tipStore } = reactData
+      const defaultSlot = slots.default
+
+      let ons
+      if (enterable) {
+        ons = {
+          onMouseenter: wrapperMouseenterEvent,
+          onMouseleave: wrapperMouseleaveEvent
+        }
+      }
+
+      return h('div', {
+        ref: refElem,
+        class: [
+          'vxe-tooltip--wrapper',
+          `theme--${theme}`,
+          {
+            [`placement--${tipStore.placement}`]: tipStore.placement,
+            'is--enterable': enterable,
+            'is--visible': visible,
+            'is--arrow': isArrow,
+            'is--active': tipActive
+          }
+        ],
+        style: {
+          ...tipStore.style,
+          // 添加过渡效果
+          transition: 'opacity 0.2s ease, transform 0.2s ease',
+          opacity: visible ? 1 : 0,
+          transform: visible ? 'scale(1)' : 'scale(0.95)'
+        },
+        ...ons
+      }, [
+        renderContent(),
+        isArrow
+          ? h('div', {
+            class: 'vxe-tooltip--arrow',
+            style: tipStore.arrowStyle
+          })
+          : null,
+        ...(defaultSlot ? defaultSlot({}) : [])
+      ])
+    }
+
+    // 监听器
+    watch(() => props.enterDelay, () => {
+      handleDelayFn()
+    })
+
+    watch(() => props.content, (val) => {
+      //@ts-ignore
+      reactData.tipContent = isNull(val) ? '' : val
+    })
+
+    watch(() => props.modelValue, (val) => {
+      if (!reactData.isUpdate) {
+        if (val) {
+          handleVisible(reactData.target, props.content)
+        } else {
+          close()
+        }
+      }
+      reactData.isUpdate = false
+    })
+
+    // 生命周期钩子
+    onMounted(() => {
+      nextTick(() => {
+        const { trigger, content } = props
+        const wrapperElem = refElem.value
+
+        if (wrapperElem) {
+          const parentNode = wrapperElem.parentNode
+          if (parentNode) {
+            //@ts-ignore
+            reactData.tipContent = isNull(content) ? '' : content
+            reactData.tipZindex = 1000
+
+            // 将子元素移动到父级
+            const children = Array.from(wrapperElem.children)
+            children.forEach((elem, index) => {
+              if (index > 1) {
+                parentNode.insertBefore(elem, wrapperElem)
+                if (!reactData.target) {
+                  reactData.target = elem as HTMLElement
+                }
+              }
+            })
+
+            parentNode.removeChild(wrapperElem)
+
+            // 绑定事件
+            const { target } = reactData
+            if (target) {
+              if (trigger === 'hover') {
+                target.onmouseenter = targetMouseenterEvent
+                target.onmouseleave = targetMouseleaveEvent
+              } else if (trigger === 'click') {
+                target.onclick = clickEvent
+              }
+            }
+
+            // 如果 modelValue 为 true，则显示
+            if (props.modelValue) {
+              handleVisible(target, content)
+            }
+          }
+        }
+      })
+    })
+
+    onBeforeUnmount(() => {
+      const { target } = reactData
+      const wrapperElem = refElem.value
+
+      if (target) {
+        target.onmouseenter = null
+        target.onmouseleave = null
+        target.onclick = null
+      }
+
+      if (wrapperElem) {
+        const parentNode = wrapperElem.parentNode
+        if (parentNode) {
+          parentNode.removeChild(wrapperElem)
+        }
+      }
+    })
+
+    handleDelayFn()
+
+    return {
+      ...tooltipMethods,
+      renderVN
+    }
+  },
+  //@ts-ignore
+  render() {
+    //@ts-ignore
+    return this.renderVN()
+  }
+}

package/src/config/VxeTableConfig.ts

@@ -1,5 +1,6 @@
-import { VxeGrid } from 'vxe-table'
-import { VxeUI } from 'vxe-pc-ui'
+import { VxeGrid,VxeUI } from 'vxe-table'
+//@ts-ignore
+import { VxeTooltip } from '../components/tooltip/index.ts'
 
 import VxeUIPluginRenderElement from '@vxe-ui/plugin-render-element'
 import '@vxe-ui/plugin-render-element/dist/style.css'
@@ -15,15 +16,19 @@ import zhCN from 'vxe-table/lib/locale/lang/zh-CN'
 /**
  * 局部初始化 vxe-table 插件与配置
  */
-export function initVxeTableInPage(enableExcel: boolean = false, enablePdf: boolean = false) {
+export function initVxeTableInPage(
+  enableExcel: boolean = false,
+  enablePdf: boolean = false,
+  enableElementPlus: boolean = true,
+) {
   // 设置语言
   VxeUI.setI18n('zh-CN', zhCN)
   VxeUI.setLanguage('zh-CN')
-
+  VxeUI.component(VxeTooltip)
   // 局部注册插件
-  VxeUI.use(VxeUIPluginRenderElement)
-  if (enableExcel) VxeUI.use(VxeUIPluginExportXLSX, { ExcelJS })
-  if (enablePdf) VxeUI.use(VxeUIPluginExportPDF, { jsPDF })
+  enableElementPlus && VxeUI.use(VxeUIPluginRenderElement)
+  enableExcel && VxeUI.use(VxeUIPluginExportXLSX, { ExcelJS })
+  enablePdf && VxeUI.use(VxeUIPluginExportPDF, { jsPDF })
 
   // 设置表格配置（可复制你在 VxeTableConfig.ts 中的配置）
   VxeUI.setConfig({

package/src/hooks/useOpenNewMenu.ts

@@ -0,0 +1,30 @@
+import frameworkUtils from '../utils/FrameworkUtils.ts'
+import usePermissionHooks from '../hooks/usePermissionHooks'
+import { userInfoStore } from '../stores/userInfoStore'
+import commonUtils from '../utils/commonUtils'
+
+export default function useOpenNewMenu(menuCode: string, module: { getModules: Function }) {
+  const usePermission = usePermissionHooks(module)
+  const userInfo = userInfoStore()
+  const handleView = async (businessId: string,menuName?: string, params: any = '') => {
+    const newId = menuCode + businessId
+    let menu = frameworkUtils.getOpenMenuInfoWujie().find((item: any) => item.id === newId)
+    if (!menu) {
+      menu = JSON.parse(
+        JSON.stringify(userInfo.getUserInfo.menuList.find((item) => item.code === menuCode)),
+      )
+      if (menu) {
+        menu.code = menuCode + commonUtils.jsonToUrlQuery(params)
+        menu.id = newId
+        menu.name = menuName??menu.name
+        await usePermission.openMenuByFramework(menu, params)
+      }
+    } else {
+      await usePermission.openMenuByFramework(menu)
+    }
+  }
+
+  return {
+    handleView,
+  }
+}

package/src/hooks/usePermissionHooks.ts

@@ -0,0 +1,139 @@
+import {useRouter} from 'vue-router'
+import {h} from 'vue'
+import type {ISysMenuInfoVo} from '../interface/ISysMenuInfoVo.ts'
+import {permissionStore} from '../stores/permissionStore.ts'
+import WujieVue from 'wujie-vue3'
+import frameworkUtil from '../utils/FrameworkUtils.ts'
+import { ElMessage } from 'element-plus'
+import { userInfoStore } from '../stores/userInfoStore'
+
+export default function usePermissionHooks(module:{getModules:Function}) {
+  const router = useRouter()
+  const permission = permissionStore()
+  /**
+   * 获取当前路由菜单信息
+   */
+  const getRouteMenuInfo = (): ISysMenuInfoVo => {
+    return router.currentRoute.value.meta.sysMenuData as ISysMenuInfoVo
+  }
+  /**
+   * 新增菜单路由
+   * @param sysMenu
+   */
+  const addRoute = async (sysMenu: ISysMenuInfoVo,params?:any): Promise<string> => {
+    const rootRoute = router.getRoutes().find((c) => c.name === '/')
+    if (!rootRoute?.children.find((c: any) => c.name === sysMenu.code)) {
+      // const comp = modules[sysMenu.component]
+      // console.log(comp, text)
+      let comp = null
+      if (sysMenu.isLink !== 1 && sysMenu.applicationModule !== 'system') {
+        comp = module.getModules(sysMenu.path)
+      }
+      if (comp) {
+        const r = {
+          name: sysMenu.code,
+          path: '/' + sysMenu.code,
+          meta: {
+            sysMenuData: sysMenu,
+            params:params,
+            link: sysMenu.isLink === 1,
+            applicationModule: sysMenu.applicationModule,
+          },
+          component: async () => {
+            const cpn = await comp()
+            cpn.default.__name = sysMenu.code
+            return h(cpn.default)
+          },
+        }
+
+        // rootRoute?.children.push(r)
+        //@ts-ignore
+        // router.addRoute(rootRoute)
+        router.addRoute('/', r)
+        return sysMenu.code
+      } else {
+        const r1 = {
+          name: sysMenu.code,
+          path: '/' + sysMenu.code,
+          meta: {
+            sysMenuData: sysMenu,
+            params:params,
+            link: sysMenu.isLink === 1,
+            applicationModule: sysMenu.applicationModule,
+          },
+          component: null,
+        }
+        //@ts-ignore
+        rootRoute?.children.push(r1)
+        //@ts-ignore
+        router.addRoute(rootRoute)
+        return sysMenu.code
+      }
+    } else {
+      return sysMenu.code
+    }
+  }
+  /**
+   * 打开菜单
+   * @param sysMenu
+   */
+  const openMenu = async (sysMenu: ISysMenuInfoVo, params?: any) => {
+    // permission.setOpenMenuInfo(sysMenu)
+    const name = await addRoute(sysMenu,params)
+    router.push({ name: name })
+  }
+  /**
+   * 通过框架打开菜单
+   * @param sysMenu
+   */
+  const openMenuByFramework = async (sysMenu: ISysMenuInfoVo,params?: any) => {
+    WujieVue.bus.$emit('openMenu', sysMenu,params)
+  }
+  /**
+   * 通过随机数打开菜单
+   * @param menuId 菜单id(用于判断是否打开过)
+   * @param menuCode 菜单code
+   * @param name 菜单tab显示名称
+   * @param param 菜单参数 route.meta.params
+   */
+  const openMenuByRandom = async (menuId: string, menuCode: string, name: string,  param?: any) => {
+    if (!menuId || !menuCode || !name) {
+      ElMessage.error('菜单打开参数缺失')
+      return ''
+    }
+    let menu = frameworkUtil.getOpenMenuInfoWujie().find((item:any)=>item.id === menuId)
+    if (!menu) {
+      const userInfo = userInfoStore()
+      menu = JSON.parse(JSON.stringify(userInfo.getUserInfo.menuList.find(item => item.code === menuCode)))
+      if (menu) {
+        const random = (Math.random() * 100000).toFixed(0)
+        menu.code = menu.code + random
+        menu.name = name
+        menu.id = menuId
+        await openMenuByFramework(menu, param)
+        return menu.code
+      } else {
+        ElMessage.error('无"'+ name +'"权限')
+      }
+    } else {
+      await openMenuByFramework(menu, param)
+      return menu.code
+    }
+    return ''
+  }
+  /**
+   * 关闭当前菜单
+   * @param sysMenu
+   */
+  const closeMenu = (sysMenu: ISysMenuInfoVo) => {
+    if (sysMenu.id === permission.getActiveMenuInfo?.id) {
+      WujieVue.bus.$emit('close-sonPage')
+    }
+
+  }
+  const closeCurrentMenu = () => {
+    closeMenu(getRouteMenuInfo())
+  }
+
+  return {openMenu, getRouteMenuInfo, openMenuByFramework, closeMenu, closeCurrentMenu, openMenuByRandom}
+}

package/src/utils/commonUtils.ts

@@ -1,3 +1,5 @@
+import {ElMessageBox} from 'element-plus'
+
 export default {
   /**
    * 校验身份证号码
@@ -111,5 +113,223 @@ export default {
       birthday: '',
       sex: ''
     }
+  },
+  /**
+   * 判断数组中是否有props相同的对象
+   * @param arr
+   * @param props
+   */
+  hasDuplicate(arr: any[], props: string[]): boolean {
+    const map = new Map()
+    for (const obj of arr) {
+      let key = ''
+      for (const prop of props) {
+        key += obj[prop] + '|'
+      }
+      if (map.has(key)) {
+        return true
+      }
+      map.set(key, true)
+    }
+    return false
+  },
+  /**
+   * 删除确认函数
+   * @param fun
+   * @param args
+   */
+  deleteFun(fun: Function, ...args: any[]): void {
+    ElMessageBox.confirm(`是否确认删除该数据？`, '删除提示', {
+      confirmButtonText: '确定',
+      cancelButtonText: '取消',
+      type: 'warning',
+    }).then(async () => {
+      fun(...args)
+    })
+  },
+  calculateAge(birthDateStr: string | undefined): number | undefined {
+    if (!birthDateStr) return undefined
+    const birthDate = new Date(birthDateStr)
+    const currentDate = new Date()
+
+    let age = currentDate.getFullYear() - birthDate.getFullYear()
+    const monthDiff = currentDate.getMonth() - birthDate.getMonth()
+
+    if (monthDiff < 0 || (monthDiff === 0 && currentDate.getDate() < birthDate.getDate())) {
+      age--
+    }
+
+    return age
+  },
+  formatCurrency(amount: number): number {
+    return (Math.round(amount * 100) / 100).toFixed(2) as unknown as number;
+  },
+  stripRichText(html: string): string {
+    // 如果输入不是字符串或为空，直接返回空字符串
+    if (typeof html !== 'string' || html.trim() === '') {
+      return '';
+    }
+
+    // 1. 移除所有HTML标签
+    let text = html.replace(/<[^>]*>?/gm, '');
+
+    // 2. 处理HTML实体（如&nbsp; &amp; &lt; &gt;等）
+    const entities: Record<string, string> = {
+      '&nbsp;': ' ',
+      '&amp;': '&',
+      '&lt;': '<',
+      '&gt;': '>',
+      '&quot;': '"',
+      '&#39;': "'",
+      '&#160;': ' '
+    };
+
+    text = text.replace(/&[a-zA-Z0-9#]+;/g, match => {
+      return entities[match] || match;
+    });
+
+    // 3. 去除多余的空格和空行
+    text = text
+      .replace(/\s+/g, ' ') // 将多个空格/换行符替换为单个空格
+      .trim(); // 去除首尾空格
+
+    return text;
+  },
+  isRichTextEmpty(content: string | undefined): boolean {
+    if (!content) return true;
+    const textContent = this.stripRichText(content);
+    return !textContent;
+  },
+  /**
+   * 解析数学不等式规则，判断x是否满足规则
+   * @param {string} rule - 不等式规则，如"x=100"、"x≤50"、"10<x<20"等
+   * @param {string|number} xValue - 变量x的值，可为字符串或数字
+   * @returns {boolean} - x是否满足规则
+   */
+  isValueValidForRule(rule: string, xValue: number | string): boolean {
+    // 去除规则中的空格，统一格式
+    rule = rule.replace(/\s/g, '');
+
+    // 将字符串类型的数值转换为数字，若转换失败则设为NaN
+    const x = typeof xValue === 'string' ? parseFloat(xValue) : xValue;
+
+    // 检查转换后的值是否为有效数字
+    if (isNaN(x)) {
+      throw new Error(`Invalid xValue: ${xValue}`);
+    }
+
+    // 解析规则中的数值并进行匹配
+    try {
+      // 处理 "x=a" 类型规则
+      if (rule.includes('=')) {
+        const match = rule.match(/^x=([+-]?\d+(\.\d+)?)$/);
+        if (match) {
+          const a = parseFloat(match[1]);
+          if (isNaN(a)) {
+            throw new Error(`Invalid rule value: ${match[1]}`);
+          }
+          return x === a;
+        }
+      }
+
+      // 处理 "x<a" 类型规则
+      if (rule.includes('<') && !rule.includes('≤') && !rule.includes('±')) {
+        // 先尝试匹配 "a<x<b" 类型
+        const rangeMatch = rule.match(/^([+-]?\d+(\.\d+)?)<x<([+-]?\d+(\.\d+)?)$/);
+        if (rangeMatch) {
+          const a = parseFloat(rangeMatch[1]);
+          const b = parseFloat(rangeMatch[3]);
+          if (isNaN(a) || isNaN(b)) {
+            throw new Error(`Invalid rule values: ${rangeMatch[1]} or ${rangeMatch[3]}`);
+          }
+          return x > a && x < b;
+        }
+
+        // 再尝试匹配 "x<a" 类型
+        const match = rule.match(/^x<([+-]?\d+(\.\d+)?)$/);
+        if (match) {
+          const a = parseFloat(match[1]);
+          if (isNaN(a)) {
+            throw new Error(`Invalid rule value: ${match[1]}`);
+          }
+          return x < a;
+        }
+      }
+
+      // 处理 "x≤a" 类型规则
+      if (rule.includes('≤')) {
+        const match = rule.match(/^x≤([+-]?\d+(\.\d+)?)$/);
+        if (match) {
+          const a = parseFloat(match[1]);
+          if (isNaN(a)) {
+            throw new Error(`Invalid rule value: ${match[1]}`);
+          }
+          return x <= a;
+        }
+      }
+
+      // 处理 "x>a" 类型规则
+      if (rule.includes('>') && !rule.includes('≥')) {
+        const match = rule.match(/^x>([+-]?\d+(\.\d+)?)$/);
+        if (match) {
+          const a = parseFloat(match[1]);
+          if (isNaN(a)) {
+            throw new Error(`Invalid rule value: ${match[1]}`);
+          }
+          return x > a;
+        }
+      }
+
+      // 处理 "x≥a" 类型规则
+      if (rule.includes('≥')) {
+        const match = rule.match(/^x≥([+-]?\d+(\.\d+)?)$/);
+        if (match) {
+          const a = parseFloat(match[1]);
+          if (isNaN(a)) {
+            throw new Error(`Invalid rule value: ${match[1]}`);
+          }
+          return x >= a;
+        }
+      }
+
+      // 处理 "x±a" 类型规则
+      if (rule.includes('±')) {
+        const match = rule.match(/^x±([+-]?\d+(\.\d+)?)$/);
+        if (match) {
+          const a = parseFloat(match[1]);
+          if (isNaN(a)) {
+            throw new Error(`Invalid rule value: ${match[1]}`);
+          }
+          return x >= a - Math.abs(a) && x <= a + Math.abs(a);
+        }
+      }
+
+      // 处理 "a≤x<b" 类型规则
+      if (rule.includes('≤x<')) {
+        const match = rule.match(/^([+-]?\d+(\.\d+)?)≤x<([+-]?\d+(\.\d+)?)$/);
+        if (match) {
+          const a = parseFloat(match[1]);
+          const b = parseFloat(match[3]);
+          if (isNaN(a) || isNaN(b)) {
+            throw new Error(`Invalid rule values: ${match[1]} or ${match[3]}`);
+          }
+          return x >= a && x < b;
+        }
+      }
+
+    } catch (error) {
+      throw new Error(`Rule parsing error: ${(error as Error).message}`);
+    }
+
+    throw new Error(`Unsupported rule format: ${rule}`);
+  },
+  parseUrlParams: (queryStr: string):Record<string, any> => {
+    return Object.fromEntries(new URLSearchParams(queryStr.slice(queryStr.indexOf('?') + 1)));
+  },
+  jsonToUrlQuery: (jsonObj: Record<string, string>) => {
+    const keyValuePairs = Object.entries(jsonObj).map(([key, value]) => {
+      return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`
+    })
+    return keyValuePairs.length > 0 ? `?${keyValuePairs.join('&')}` : ''
   }
 }