vxe-pc-ui 3.0.1 → 3.0.2

package/packages/list/src/list.ts

@@ -0,0 +1,403 @@
+import { PropType, CreateElement, VNode } from 'vue'
+import { defineVxeComponent } from '../../ui/src/comp'
+import XEUtils from 'xe-utils'
+import { getConfig, globalEvents, globalResize, createEvent, globalMixins } from '../../ui'
+import { browse } from '../../ui/src/dom'
+import VxeLoadingComponent from '../../loading/src/loading'
+
+import type { VxeListPropTypes, VxeListEmits, VxeComponentSizeType, ListReactData, ValueOf, ListInternalData } from '../../../types'
+
+export default defineVxeComponent({
+  name: 'VxeList',
+  mixins: [
+    globalMixins.sizeMixin
+  ],
+  props: {
+    data: Array as PropType<VxeListPropTypes.Data>,
+    height: [Number, String] as PropType<VxeListPropTypes.Height>,
+    maxHeight: [Number, String] as PropType<VxeListPropTypes.MaxHeight>,
+    loading: Boolean as PropType<VxeListPropTypes.Loading>,
+    className: [String, Function] as PropType<VxeListPropTypes.ClassName>,
+    size: { type: String as PropType<VxeListPropTypes.Size>, default: () => getConfig().list.size || getConfig().size },
+    autoResize: { type: Boolean as PropType<VxeListPropTypes.AutoResize>, default: () => getConfig().list.autoResize },
+    syncResize: [Boolean, String, Number] as PropType<VxeListPropTypes.SyncResize>,
+    scrollY: Object as PropType<VxeListPropTypes.ScrollY>
+  },
+  data () {
+    const xID = XEUtils.uniqueId()
+    const reactData: ListReactData = {
+      scrollYLoad: false,
+      bodyHeight: 0,
+      rowHeight: 0,
+      topSpaceHeight: 0,
+      items: []
+    }
+    const internalData: ListInternalData = {
+      resizeObserver: undefined,
+      fullData: [],
+      lastScrollLeft: 0,
+      lastScrollTop: 0,
+      scrollYStore: {
+        startIndex: 0,
+        endIndex: 0,
+        visibleSize: 0,
+        offsetSize: 0,
+        rowHeight: 0
+      }
+    }
+    return {
+      xID,
+      reactData,
+      internalData
+    }
+  },
+  computed: {
+    ...({} as {
+      computeSize(): VxeComponentSizeType
+    }),
+    computeSYOpts () {
+      const $xeList = this
+      const props = $xeList
+
+      return Object.assign({} as { gt: number }, getConfig().list.scrollY, props.scrollY)
+    },
+    computeStyles () {
+      const $xeList = this
+      const props = $xeList
+
+      const { height, maxHeight } = props
+      const style: { [key: string]: string | number } = {}
+      if (height) {
+        style.height = `${isNaN(height as number) ? height : `${height}px`}`
+      } else if (maxHeight) {
+        style.height = 'auto'
+        style.maxHeight = `${isNaN(maxHeight as number) ? maxHeight : `${maxHeight}px`}`
+      }
+      return style
+    }
+
+  },
+  methods: {
+    //
+    // Method
+    //
+    dispatchEvent (type: ValueOf<VxeListEmits>, params: Record<string, any>, evnt: Event | null) {
+      const $xeList = this
+      $xeList.$emit(type, createEvent(evnt, { $list: $xeList }, params))
+    },
+    /**
+       * 加载数据
+       * @param {Array} datas 数据
+       */
+    loadData (datas: any) {
+      const $xeList = this
+      const reactData = $xeList.reactData
+      const internalData = $xeList.internalData
+
+      const { scrollYStore } = internalData
+      const sYOpts = $xeList.computeSYOpts
+      const fullData = datas || []
+      Object.assign(scrollYStore, {
+        startIndex: 0,
+        endIndex: 1,
+        visibleSize: 0
+      })
+      internalData.fullData = fullData
+      // 如果gt为0，则总是启用
+      reactData.scrollYLoad = !!sYOpts.enabled && sYOpts.gt > -1 && (sYOpts.gt === 0 || sYOpts.gt <= fullData.length)
+      $xeList.handleData()
+      return $xeList.computeScrollLoad().then(() => {
+        $xeList.refreshScroll()
+      })
+    },
+    /**
+     * 重新加载数据
+     * @param {Array} datas 数据
+     */
+    reloadData (datas: any) {
+      const $xeList = this
+
+      $xeList.clearScroll()
+      return $xeList.loadData(datas)
+    },
+    updateYSpace  () {
+      const $xeList = this
+      const reactData = $xeList.reactData
+      const internalData = $xeList.internalData
+
+      const { scrollYLoad } = reactData
+      const { scrollYStore, fullData } = internalData
+      reactData.bodyHeight = scrollYLoad ? fullData.length * scrollYStore.rowHeight : 0
+      reactData.topSpaceHeight = scrollYLoad ? Math.max(scrollYStore.startIndex * scrollYStore.rowHeight, 0) : 0
+    },
+    handleData () {
+      const $xeList = this
+      const reactData = $xeList.reactData
+      const internalData = $xeList.internalData
+
+      const { scrollYLoad } = reactData
+      const { fullData, scrollYStore } = internalData
+      reactData.items = scrollYLoad ? fullData.slice(scrollYStore.startIndex, scrollYStore.endIndex) : fullData.slice(0)
+      return $xeList.$nextTick()
+    },
+    updateYData () {
+      const $xeList = this
+
+      $xeList.handleData()
+      $xeList.updateYSpace()
+    },
+    computeScrollLoad  () {
+      const $xeList = this
+      const reactData = $xeList.reactData
+      const internalData = $xeList.internalData
+
+      return $xeList.$nextTick().then(() => {
+        const { scrollYLoad } = reactData
+        const { scrollYStore } = internalData
+        const virtualBodyElem = $xeList.$refs.refVirtualBody as HTMLElement
+        const sYOpts = $xeList.computeSYOpts
+        let rowHeight = 0
+        let firstItemElem: HTMLElement | undefined
+        if (virtualBodyElem) {
+          if (sYOpts.sItem) {
+            firstItemElem = virtualBodyElem.querySelector(sYOpts.sItem) as HTMLElement
+          }
+          if (!firstItemElem) {
+            firstItemElem = virtualBodyElem.children[0] as HTMLElement
+          }
+        }
+        if (firstItemElem) {
+          rowHeight = firstItemElem.offsetHeight
+        }
+        rowHeight = Math.max(20, rowHeight)
+        scrollYStore.rowHeight = rowHeight
+        // 计算 Y 逻辑
+        if (scrollYLoad) {
+          const scrollBodyElem = $xeList.$refs.refVirtualWrapper as HTMLElement
+          const visibleYSize = Math.max(8, Math.ceil(scrollBodyElem.clientHeight / rowHeight))
+          const offsetYSize = sYOpts.oSize ? XEUtils.toNumber(sYOpts.oSize) : (browse.edge ? 10 : 0)
+          scrollYStore.offsetSize = offsetYSize
+          scrollYStore.visibleSize = visibleYSize
+          scrollYStore.endIndex = Math.max(scrollYStore.startIndex, visibleYSize + offsetYSize, scrollYStore.endIndex)
+          $xeList.updateYData()
+        } else {
+          $xeList.updateYSpace()
+        }
+        reactData.rowHeight = rowHeight
+      })
+    },
+    /**
+     * 清除滚动条
+     */
+    clearScroll () {
+      const $xeList = this
+
+      const scrollBodyElem = $xeList.$refs.refVirtualWrapper as HTMLElement
+      if (scrollBodyElem) {
+        scrollBodyElem.scrollTop = 0
+      }
+      return $xeList.$nextTick()
+    },
+    /**
+     * 如果有滚动条，则滚动到对应的位置
+     * @param {Number} scrollLeft 左距离
+     * @param {Number} scrollTop 上距离
+     */
+    scrollTo (scrollLeft: number | null, scrollTop?: number | null) {
+      const $xeList = this
+      const reactData = $xeList.reactData
+
+      const scrollBodyElem = $xeList.$refs.refVirtualWrapper as HTMLElement
+      if (XEUtils.isNumber(scrollLeft)) {
+        scrollBodyElem.scrollLeft = scrollLeft
+      }
+      if (XEUtils.isNumber(scrollTop)) {
+        scrollBodyElem.scrollTop = scrollTop
+      }
+      if (reactData.scrollYLoad) {
+        return new Promise<void>(resolve => {
+          setTimeout(() => {
+            $xeList.$nextTick(() => {
+              resolve()
+            })
+          }, 50)
+        })
+      }
+      return $xeList.$nextTick()
+    },
+    /**
+     * 刷新滚动条
+     */
+    refreshScroll  () {
+      const $xeList = this
+      const internalData = $xeList.internalData
+
+      const { lastScrollLeft, lastScrollTop } = internalData
+      return $xeList.clearScroll().then(() => {
+        if (lastScrollLeft || lastScrollTop) {
+          internalData.lastScrollLeft = 0
+          internalData.lastScrollTop = 0
+          return scrollTo(lastScrollLeft, lastScrollTop)
+        }
+      })
+    },
+    /**
+     * 重新计算列表
+     */
+    recalculate  () {
+      const $xeList = this
+
+      const el = $xeList.$refs.refElem as HTMLDivElement
+      if (el.clientWidth && el.clientHeight) {
+        return $xeList.computeScrollLoad()
+      }
+      return Promise.resolve()
+    },
+    loadYData  (evnt: Event) {
+      const $xeList = this
+      const internalData = $xeList.internalData
+
+      const { scrollYStore } = internalData
+      const { startIndex, endIndex, visibleSize, offsetSize, rowHeight } = scrollYStore
+      const scrollBodyElem = evnt.target as HTMLDivElement
+      const scrollTop = scrollBodyElem.scrollTop
+      const toVisibleIndex = Math.floor(scrollTop / rowHeight)
+      const offsetStartIndex = Math.max(0, toVisibleIndex - 1 - offsetSize)
+      const offsetEndIndex = toVisibleIndex + visibleSize + offsetSize
+      if (toVisibleIndex <= startIndex || toVisibleIndex >= endIndex - visibleSize - 1) {
+        if (startIndex !== offsetStartIndex || endIndex !== offsetEndIndex) {
+          scrollYStore.startIndex = offsetStartIndex
+          scrollYStore.endIndex = offsetEndIndex
+          $xeList.updateYData()
+        }
+      }
+    },
+    scrollEvent (evnt: Event) {
+      const $xeList = this
+      const reactData = $xeList.reactData
+      const internalData = $xeList.internalData
+
+      const scrollBodyElem = evnt.target as HTMLDivElement
+      const scrollTop = scrollBodyElem.scrollTop
+      const scrollLeft = scrollBodyElem.scrollLeft
+      const isX = scrollLeft !== internalData.lastScrollLeft
+      const isY = scrollTop !== internalData.lastScrollTop
+      internalData.lastScrollTop = scrollTop
+      internalData.lastScrollLeft = scrollLeft
+      if (reactData.scrollYLoad) {
+        $xeList.loadYData(evnt)
+      }
+      $xeList.dispatchEvent('scroll', { scrollLeft, scrollTop, isX, isY }, evnt)
+    },
+
+    //
+    // Render
+    //
+    renderVN (h: CreateElement): VNode {
+      const $xeList = this
+      const props = $xeList
+      const reactData = $xeList.reactData
+      const slots = $xeList.$scopedSlots
+
+      const { className, loading } = props
+      const { bodyHeight, topSpaceHeight, items } = reactData
+      const defaultSlot = slots.default
+      const vSize = $xeList.computeSize
+      const styles = $xeList.computeStyles
+      return h('div', {
+        ref: 'refElem',
+        class: ['vxe-list', className ? (XEUtils.isFunction(className) ? className({ $list: $xeList }) : className) : '', {
+          [`size--${vSize}`]: vSize,
+          'is--loading': loading
+        }]
+      }, [
+        h('div', {
+          ref: 'refVirtualWrapper',
+          class: 'vxe-list--virtual-wrapper',
+          style: styles,
+          on: {
+            scroll: $xeList.scrollEvent
+          }
+        }, [
+          h('div', {
+            class: 'vxe-list--y-space',
+            style: {
+              height: bodyHeight ? `${bodyHeight}px` : ''
+            }
+          }),
+          h('div', {
+            ref: 'refVirtualBody',
+            class: 'vxe-list--body',
+            style: {
+              marginTop: topSpaceHeight ? `${topSpaceHeight}px` : ''
+            }
+          }, defaultSlot ? defaultSlot({ items, $list: $xeList }) : [])
+        ]),
+        /**
+         * 加载中
+         */
+        h(VxeLoadingComponent, {
+          class: 'vxe-list--loading',
+          props: {
+            value: loading
+          }
+        })
+      ])
+    }
+  },
+  watch: {
+    data () {
+      const $xeList = this
+      const props = $xeList
+
+      $xeList.loadData(props.data || [])
+    },
+    syncResize (val) {
+      const $xeList = this
+
+      if (val) {
+        $xeList.recalculate()
+        $xeList.$nextTick(() => setTimeout(() => $xeList.recalculate()))
+      }
+    }
+  },
+  created () {
+    const $xeList = this
+    const props = $xeList
+
+    globalEvents.on($xeList, 'resize', () => {
+      $xeList.recalculate()
+    })
+    $xeList.loadData(props.data || [])
+  },
+  mounted () {
+    const $xeList = this
+    const props = $xeList
+    const internalData = $xeList.internalData
+
+    if (props.autoResize) {
+      const el = $xeList.$refs.refElem as HTMLDivElement
+      const resizeObserver = globalResize.create(() => $xeList.recalculate())
+      resizeObserver.observe(el)
+      internalData.resizeObserver = resizeObserver
+    }
+  },
+  activated () {
+    const $xeList = this
+
+    $xeList.recalculate().then(() => $xeList.refreshScroll())
+  },
+  beforeDestroy () {
+    const $xeList = this
+    const internalData = $xeList.internalData
+
+    const { resizeObserver } = internalData
+    if (resizeObserver) {
+      resizeObserver.disconnect()
+    }
+    globalEvents.off($xeList, 'resize')
+  },
+  render (this: any, h) {
+    return this.renderVN(h)
+  }
+})

package/packages/loading/src/loading.ts

@@ -76,6 +76,12 @@ export default defineVxeComponent({
       const $xeLoading = this
       $xeLoading.$emit(type, createEvent(evnt, { $loading: $xeLoading }, params))
     },
+    emitModel  (value: any) {
+      const $xeLoading = this
+
+      $xeLoading.$emit('input', value)
+      $xeLoading.$emit('modelValue', value)
+    },
     handleInit () {
       const $xeLoading = this
       const reactData = $xeLoading.reactData

package/packages/menu/src/menu.ts

@@ -88,6 +88,12 @@ export default defineVxeComponent({
       const $xeMenu = this
       $xeMenu.$emit(type, createEvent(evnt, { $menu: $xeMenu }, params))
     },
+    emitModel  (value: any) {
+      const $xeMenu = this
+
+      $xeMenu.$emit('input', value)
+      $xeMenu.$emit('modelValue', value)
+    },
     getMenuTitle  (item: VxeMenuPropTypes.MenuOption) {
       return `${item.title || item.name}`
     },
@@ -184,8 +190,7 @@ export default defineVxeComponent({
       if (routerLink) {
         const value = item.itemKey
         reactData.activeName = value
-        $xeMenu.$emit('input', value)
-        $xeMenu.$emit('modelValue', value)
+        $xeMenu.emitModel(value)
       } else {
         if (hasChild) {
           $xeMenu.handleClickIconCollapse(evnt, item)

package/packages/modal/src/modal.ts

@@ -263,6 +263,12 @@ export default defineVxeComponent({
       const $xeModal = this
       $xeModal.$emit(type, createEvent(evnt, { $modal: $xeModal }, params))
     },
+    emitModel  (value: any) {
+      const $xeModal = this
+
+      $xeModal.$emit('input', value)
+      $xeModal.$emit('modelValue', value)
+    },
     open () {
       const $xeModal = this
 
@@ -454,8 +460,7 @@ export default defineVxeComponent({
             $xeModal.dispatchEvent('before-hide', params, null)
             setTimeout(() => {
               reactData.visible = false
-              $xeModal.$emit('input', false)
-              $xeModal.$emit('modelValue', false)
+              $xeModal.emitModel(false)
               $xeModal.dispatchEvent('hide', params, null)
             }, 200)
             $xeModal.removeBodyLockScroll()
@@ -780,8 +785,7 @@ export default defineVxeComponent({
             }
             const type = ''
             const params = { type }
-            $xeModal.$emit('input', true)
-            $xeModal.$emit('modelValue', true)
+            $xeModal.emitModel(true)
             $xeModal.dispatchEvent('show', params, null)
           })
         }, 10)

package/packages/number-input/src/number-input.ts

@@ -265,6 +265,11 @@ export default defineVxeComponent({
       const $xeNumberInput = this
       $xeNumberInput.$emit(type, createEvent(evnt, { $numberInput: $xeNumberInput }, params))
     },
+    emitModel  (value: any) {
+      const $xeModal = this
+
+      $xeModal.$emit('modelValue', value)
+    },
     focus () {
       const $xeNumberInput = this
       const reactData = $xeNumberInput.reactData
@@ -312,7 +317,7 @@ export default defineVxeComponent({
       const { inputValue } = reactData
       $xeNumberInput.dispatchEvent(evnt.type, { value: inputValue }, evnt)
     },
-    emitModel (val: number | null, inputValue: string, evnt: Event | { type: string }) {
+    handleChange (val: number | null, inputValue: string, evnt: Event | { type: string }) {
       const $xeNumberInput = this
       const props = $xeNumberInput
       const reactData = $xeNumberInput.reactData
@@ -323,7 +328,7 @@ export default defineVxeComponent({
       const isChange = value !== props.value
       if (isChange) {
         reactData.inputValue = inputValue || ''
-        $xeNumberInput.$emit('modelValue', value)
+        $xeNumberInput.emitModel(value)
       }
       $xeNumberInput.dispatchEvent('input', { value }, evnt as Event)
       if (isChange) {
@@ -342,7 +347,7 @@ export default defineVxeComponent({
       const value = inputValue ? XEUtils.toNumber(inputValue) : null
       reactData.inputValue = inputValue
       if (inpImmediate) {
-        $xeNumberInput.emitModel(value, inputValue, evnt)
+        $xeNumberInput.handleChange(value, inputValue, evnt)
       } else {
         $xeNumberInput.dispatchEvent('input', { value }, evnt)
       }
@@ -383,7 +388,7 @@ export default defineVxeComponent({
       const $xeNumberInput = this
 
       $xeNumberInput.focus()
-      $xeNumberInput.emitModel(null, '', evnt)
+      $xeNumberInput.handleChange(null, '', evnt)
       $xeNumberInput.dispatchEvent('clear', { value }, evnt)
     },
     clickSuffixEvent (evnt: Event) {
@@ -416,7 +421,7 @@ export default defineVxeComponent({
             validValue = Number(textValue)
           }
           if (inputValue !== validValue) {
-            $xeNumberInput.emitModel(validValue, textValue, { type: 'init' })
+            $xeNumberInput.handleChange(validValue, textValue, { type: 'init' })
           }
         }
       }
@@ -456,7 +461,7 @@ export default defineVxeComponent({
             }
           }
           const inpValue = $xeNumberInput.getNumberValue(inpNumVal)
-          $xeNumberInput.emitModel(inpValue === null ? null : Number(inpValue), inpValue, { type: 'check' })
+          $xeNumberInput.handleChange(inpValue === null ? null : Number(inpValue), inpValue, { type: 'check' })
         }
       }
     },
@@ -468,7 +473,7 @@ export default defineVxeComponent({
       const inpImmediate = $xeNumberInput.computeInpImmediate
       const value = inputValue ? Number(inputValue) : null
       if (!inpImmediate) {
-        $xeNumberInput.emitModel(value, `${inputValue || ''}`, evnt)
+        $xeNumberInput.handleChange(value, `${inputValue || ''}`, evnt)
       }
       $xeNumberInput.afterCheckValue()
       reactData.isActivated = false

package/packages/password-input/src/password-input.ts

@@ -109,6 +109,11 @@ export default defineVxeComponent({
       const $xePasswordInput = this
       $xePasswordInput.$emit(type, createEvent(evnt, { $passwordInput: $xePasswordInput }, params))
     },
+    emitModel  (value: any) {
+      const $xeModal = this
+
+      $xeModal.$emit('modelValue', value)
+    },
     focus () {
       const $xePasswordInput = this
       const reactData = $xePasswordInput.reactData
@@ -157,7 +162,7 @@ export default defineVxeComponent({
       const value = inputElem.value
       $xePasswordInput.emitInputEvent(value, evnt)
     },
-    emitModel (value: string, evnt: Event | { type: string }) {
+    handleChange (value: string, evnt: Event | { type: string }) {
       const $xePasswordInput = this
       const props = $xePasswordInput
       const reactData = $xePasswordInput.reactData
@@ -165,7 +170,7 @@ export default defineVxeComponent({
       const formItemInfo = $xePasswordInput.formItemInfo
 
       reactData.inputValue = value
-      $xePasswordInput.$emit('modelValue', value)
+      $xePasswordInput.emitModel(value)
       $xePasswordInput.dispatchEvent('input', { value }, evnt as any)
       if (XEUtils.toValueString(props.value) !== value) {
         $xePasswordInput.dispatchEvent('change', { value }, evnt as any)
@@ -223,7 +228,7 @@ export default defineVxeComponent({
       const $xePasswordInput = this
 
       $xePasswordInput.focus()
-      $xePasswordInput.emitModel('', evnt)
+      $xePasswordInput.handleChange('', evnt)
       $xePasswordInput.dispatchEvent('clear', { value }, evnt)
     },
     clickSuffixEvent  (evnt: Event) {

package/packages/pulldown/src/pulldown.ts

@@ -113,6 +113,11 @@ export default defineVxeComponent({
       const $xePulldown = this
       $xePulldown.$emit(type, createEvent(evnt, { $pulldown: $xePulldown }, params))
     },
+    emitModel  (value: any) {
+      const $xePulldown = this
+
+      $xePulldown.$emit('modelValue', value)
+    },
     updateZindex () {
       const $xePulldown = this
       const reactData = $xePulldown.reactData
@@ -234,7 +239,7 @@ export default defineVxeComponent({
           reactData.visibleAnimate = true
           setTimeout(() => {
             reactData.visiblePanel = true
-            $xePulldown.$emit('modelValue', true)
+            $xePulldown.emitModel(true)
             $xePulldown.updatePlacement()
             setTimeout(() => {
               resolve($xePulldown.updatePlacement())
@@ -257,7 +262,7 @@ export default defineVxeComponent({
       const internalData = $xePulldown.internalData
 
       reactData.visiblePanel = false
-      $xePulldown.$emit('modelValue', false)
+      $xePulldown.emitModel(false)
       return new Promise<void>(resolve => {
         if (reactData.visibleAnimate) {
           internalData.hpTimeout = window.setTimeout(() => {

package/packages/radio/src/button.ts

@@ -103,6 +103,12 @@ export default defineVxeComponent({
       const $xeRadioButton = this
       $xeRadioButton.$emit(type, createEvent(evnt, { $radioButton: $xeRadioButton }, params))
     },
+    emitModel  (value: any) {
+      const $xeRadioButton = this
+
+      $xeRadioButton.$emit('input', value)
+      $xeRadioButton.$emit('modelValue', value)
+    },
     handleValue (label: VxeRadioButtonPropTypes.Label, evnt: Event) {
       const $xeRadioButton = this
       const $xeForm = $xeRadioButton.$xeForm
@@ -112,8 +118,7 @@ export default defineVxeComponent({
       if ($xeRadioGroup) {
         $xeRadioGroup.handleChecked({ label }, evnt)
       } else {
-        $xeRadioButton.$emit('input', label)
-        $xeRadioButton.$emit('modelValue', label)
+        $xeRadioButton.emitModel(label)
         $xeRadioButton.dispatchEvent('change', { label }, evnt)
         // 自动更新校验状态
         if ($xeForm && formItemInfo) {

package/packages/radio/src/group.ts

@@ -110,6 +110,12 @@ export default defineVxeComponent({
 
       $xeRadioGroup.$emit(type, createEvent(evnt, { $radioGroup: $xeRadioGroup }, params))
     },
+    emitModel  (value: any) {
+      const $xeRadioGroup = this
+
+      $xeRadioGroup.$emit('input', value)
+      $xeRadioGroup.$emit('modelValue', value)
+    },
     handleChecked (params: {
       label: any
     }, evnt: Event) {
@@ -118,8 +124,7 @@ export default defineVxeComponent({
       const formItemInfo = $xeRadioGroup.formItemInfo
 
       const value = params.label
-      $xeRadioGroup.$emit('input', value)
-      $xeRadioGroup.$emit('modelValue', value)
+      $xeRadioGroup.emitModel(value)
       $xeRadioGroup.dispatchEvent('change', params, evnt)
       // 自动更新校验状态
       if ($xeForm && formItemInfo) {

package/packages/radio/src/radio.ts

@@ -105,6 +105,12 @@ export default defineVxeComponent({
       const $xeRadio = this
       $xeRadio.$emit(type, createEvent(evnt, { $radio: $xeRadio }, params))
     },
+    emitModel  (value: any) {
+      const $xeRadio = this
+
+      $xeRadio.$emit('input', value)
+      $xeRadio.$emit('modelValue', value)
+    },
     handleValue  (label: VxeRadioPropTypes.Label, evnt: Event) {
       const $xeRadio = this
       const formItemInfo = $xeRadio.formItemInfo
@@ -114,8 +120,7 @@ export default defineVxeComponent({
       if ($xeRadioGroup) {
         $xeRadioGroup.handleChecked({ label }, evnt)
       } else {
-        $xeRadio.$emit('input', label)
-        $xeRadio.$emit('modelValue', label)
+        $xeRadio.emitModel(label)
         $xeRadio.dispatchEvent('change', { label }, evnt)
         // 自动更新校验状态
         if ($xeForm && formItemInfo) {