vxe-table 3.15.39 → 3.15.41

package/packages/table/src/table.ts

@@ -90,27 +90,31 @@ function renderFixed (h: CreateElement, $xeTable: VxeTableConstructor & VxeTable
   ])
 }
 
-function renderEmptyBody (h: CreateElement, _vm: any) {
-  const { $scopedSlots, emptyOpts } = _vm
+function renderEmptyBody (h: CreateElement, $xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
+  const slots = $xeTable.$scopedSlots
+  const $xeGrid = $xeTable.$xeGrid
+
+  const emptyOpts = $xeTable.computeEmptyOpts
+  const emptySlot = slots.empty
   let emptyContent: any = ''
-  const params = { $table: _vm }
-  if ($scopedSlots.empty) {
-    emptyContent = $scopedSlots.empty.call(_vm, params, h)
+  const emptyParams = { $table: $xeTable, $grid: $xeGrid }
+  if (emptySlot) {
+    emptyContent = emptySlot.call($xeTable, emptyParams)
   } else {
     const compConf = emptyOpts.name ? renderer.get(emptyOpts.name) : null
     const rtEmptyView = compConf ? (compConf.renderTableEmpty || compConf.renderTableEmptyView || compConf.renderEmpty) : null
     if (rtEmptyView) {
-      emptyContent = getSlotVNs(rtEmptyView.call(_vm, h, emptyOpts, params))
+      emptyContent = getSlotVNs(rtEmptyView.call($xeTable, h, emptyOpts, emptyParams))
     } else {
-      emptyContent = getFuncText(_vm.emptyText) || getI18n('vxe.table.emptyText')
+      emptyContent = getFuncText($xeTable.emptyText) || getI18n('vxe.table.emptyText')
     }
   }
   return emptyContent
 }
 
-const renderDragTipContents = (h: CreateElement, $xeTable: any) => {
+const renderDragTipContents = (h: CreateElement, $xeTable: VxeTableConstructor & VxeTablePrivateMethods) => {
   const props = $xeTable
-  const reactData = $xeTable
+  const reactData = $xeTable as unknown as TableReactData
 
   const { dragConfig } = props
   const { dragRow, dragCol, dragTipText } = reactData
@@ -130,8 +134,8 @@ const renderDragTipContents = (h: CreateElement, $xeTable: any) => {
   return [h('span', dragTipText)]
 }
 
-const renderDragTip = (h: CreateElement, $xeTable: any) => {
-  const reactData = $xeTable
+const renderDragTip = (h: CreateElement, $xeTable: VxeTableConstructor & VxeTablePrivateMethods) => {
+  const reactData = $xeTable as unknown as TableReactData
 
   const { dragRow, dragCol } = reactData
   const rowOpts = $xeTable.computeRowOpts
@@ -187,10 +191,10 @@ const renderDragTip = (h: CreateElement, $xeTable: any) => {
   return renderEmptyElement($xeTable)
 }
 
-function handleUpdateResize (_vm: any) {
-  const { $el } = _vm
-  if ($el && $el.clientWidth && $el.clientHeight) {
-    _vm.recalculate()
+function handleUpdateResize ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
+  const el = $xeTable.$refs.refElem as HTMLDivElement
+  if (el && el.clientWidth && el.clientHeight) {
+    $xeTable.recalculate()
   }
 }
 
@@ -672,6 +676,8 @@ export default {
       visiblwRowsFlag: 1,
 
       isRowGroupStatus: false,
+      rowGroupList: [],
+      aggHandleFields: [],
 
       rowGroupExpandedFlag: 1,
       rowExpandedFlag: 1,
@@ -729,17 +735,21 @@ export default {
       return this.computeTableId
     },
     computeTableId () {
-      const { id } = this
+      const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+      const props = $xeTable
+      const $xeGrid = $xeTable.$xeGrid
+
+      const { id } = props
       if (id) {
         if (XEUtils.isFunction(id)) {
-          return `${id({ $table: this }) || ''}`
+          return `${id({ $table: $xeTable, $grid: $xeGrid }) || ''}`
         }
         return `${id}`
       }
       return ''
     },
     computeRowField () {
-      const $xeTable = this
+      const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
       const props = $xeTable
 
       const rowOpts = $xeTable.computeRowOpts
@@ -749,7 +759,10 @@ export default {
       return this.computeValidOpts
     },
     computeValidOpts () {
-      return Object.assign({ message: 'default' }, getConfig().table.validConfig, this.validConfig)
+      const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+      const props = $xeTable
+
+      return Object.assign({}, getConfig().table.validConfig, props.validConfig)
     },
     sXOpts () {
       return this.computeVirtualXOpts
@@ -758,7 +771,7 @@ export default {
       return this.computeVirtualXOpts
     },
     computeScrollXThreshold () {
-      const $xeTable = this
+      const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
 
       const virtualXOpts = $xeTable.computeVirtualXOpts
       const { threshold } = virtualXOpts
@@ -774,37 +787,37 @@ export default {
       return this.computeVirtualYOpts
     },
     computeVirtualXOpts () {
-      const $xeTable = this
+      const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
       const props = $xeTable
 
       return Object.assign({}, getConfig().table.virtualXConfig || getConfig().table.scrollX, props.virtualXConfig || props.scrollX)
     },
     computeVirtualYOpts () {
-      const $xeTable = this
+      const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
       const props = $xeTable
 
       return Object.assign({}, getConfig().table.virtualYConfig || getConfig().table.scrollY, props.virtualYConfig || props.scrollY)
     },
     computeScrollbarOpts () {
-      const $xeTable = this
+      const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
       const props = $xeTable
 
       return Object.assign({}, getConfig().table.scrollbarConfig, props.scrollbarConfig)
     },
     computeScrollbarXToTop () {
-      const $xeTable = this
+      const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
 
       const scrollbarOpts = $xeTable.computeScrollbarOpts
       return !!(scrollbarOpts.x && scrollbarOpts.x.position === 'top')
     },
     computeScrollbarYToLeft () {
-      const $xeTable = this
+      const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
 
       const scrollbarOpts = $xeTable.computeScrollbarOpts
       return !!(scrollbarOpts.y && scrollbarOpts.y.position === 'left')
     },
     computeScrollYThreshold () {
-      const $xeTable = this
+      const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
 
       const virtualYOpts = $xeTable.computeVirtualYOpts
       const { threshold } = virtualYOpts
@@ -1176,26 +1189,18 @@ export default {
     },
     computeTableRowExpandedList () {
       const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
-      const props = $xeTable
       const reactData = $xeTable as unknown as TableReactData
       const internalData = $xeTable as unknown as TableInternalData
 
-      const { treeConfig } = props
-      const { rowExpandedFlag, expandColumn, rowGroupExpandedFlag, treeExpandedFlag, isRowGroupStatus } = reactData
+      const { rowExpandedFlag, expandColumn, rowGroupExpandedFlag, treeExpandedFlag } = reactData
       const { visibleDataRowIdData, rowExpandedMaps } = internalData
-      const treeOpts = $xeTable.computeTreeOpts
-      const { transform } = treeOpts
       const expandList: any[] = []
       if (expandColumn && rowExpandedFlag && rowGroupExpandedFlag && treeExpandedFlag) {
-        if (isRowGroupStatus || (treeConfig && transform)) {
-          XEUtils.each(rowExpandedMaps, (row, rowid) => {
-            if (visibleDataRowIdData[rowid]) {
-              expandList.push(row)
-            }
-          })
-        } else {
-          return XEUtils.values(rowExpandedMaps)
-        }
+        XEUtils.each(rowExpandedMaps, (row, rowid) => {
+          if (visibleDataRowIdData[rowid]) {
+            expandList.push(row)
+          }
+        })
       }
       return expandList
     },
@@ -1287,6 +1292,22 @@ export default {
       const aggregateOpts = $xeTable.computeAggregateOpts
       return aggregateOpts.groupFields
     },
+    computeRowGroupColumns () {
+      const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+      const reactData = $xeTable as unknown as TableReactData
+      const internalData = $xeTable as unknown as TableInternalData
+
+      const { rowGroupList } = reactData
+      const { fullColumnFieldData } = internalData
+      const rgColumns: VxeTableDefines.ColumnInfo[] = []
+      rowGroupList.forEach(aggConf => {
+        const colRest = fullColumnFieldData[aggConf.field]
+        if (colRest) {
+          rgColumns.push(colRest.column)
+        }
+      })
+      return rgColumns
+    },
     tabsResizeFlag () {
       const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
       const $xeTabs = $xeTable.$xeTabs
@@ -1391,11 +1412,13 @@ export default {
     },
 
     syncResize (value: any) {
+      const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+
       if (value) {
-        handleUpdateResize(this)
-        this.$nextTick(() => {
-          handleUpdateResize(this)
-          setTimeout(() => handleUpdateResize(this))
+        handleUpdateResize($xeTable)
+        $xeTable.$nextTick(() => {
+          handleUpdateResize($xeTable)
+          setTimeout(() => handleUpdateResize($xeTable))
         })
       }
     },
@@ -1403,12 +1426,16 @@ export default {
       this.handleGlobalResizeEvent()
     },
     mergeCells (value: any) {
-      this.clearMergeCells()
-      this.$nextTick(() => this.setMergeCells(value))
+      const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+
+      $xeTable.clearMergeCells()
+      $xeTable.$nextTick(() => $xeTable.setMergeCells(value))
     },
     mergeFooterItems (value: any) {
-      this.clearMergeFooterItems()
-      this.$nextTick(() => this.setMergeFooterItems(value))
+      const $xeTable = this as VxeTableConstructor & VxeTablePrivateMethods
+
+      $xeTable.clearMergeFooterItems()
+      $xeTable.$nextTick(() => $xeTable.setMergeFooterItems(value))
     },
 
     computeRowGroupFields (val: any) {
@@ -2022,7 +2049,7 @@ export default {
       }, [
         h('div', {
           class: 'vxe-table--empty-content'
-        }, renderEmptyBody(h, this))
+        }, renderEmptyBody(h, $xeTable))
       ]),
       /**
        * 边框线

package/packages/toolbar/src/toolbar.ts

@@ -5,7 +5,7 @@ import { VxeUI } from '../../ui'
 import { getSlotVNs } from '../../ui/src/vn'
 import { warnLog, errLog } from '../../ui/src/log'
 
-import type { ValueOf, VxeButtonComponent, VxeComponentSizeType, VxeComponentSlotType } from 'vxe-pc-ui'
+import type { ValueOf, VxeButtonComponent, VxeComponentSizeType, VxeComponentSlotType, VxeButtonDefines } from 'vxe-pc-ui'
 import type { VxeGridConstructor, GridPrivateMethods, ToolbarInternalData, VxeTableDefines, VxeToolbarEmits, VxeToolbarPropTypes, VxeTablePropTypes, ToolbarReactData, VxeTableConstructor, VxeTablePrivateMethods } from '../../../types'
 
 const { getConfig, getIcon, getI18n, renderer, commands, createEvent, globalMixins, renderEmptyElement } = VxeUI
@@ -18,11 +18,17 @@ export default /* define-vxe-component start */ defineVxeComponent({
   props: {
     loading: Boolean,
     refresh: [Boolean, Object] as PropType<VxeToolbarPropTypes.Refresh>,
+    refreshOptions: Object as PropType<VxeToolbarPropTypes.RefreshOptions>,
     import: [Boolean, Object] as PropType<VxeToolbarPropTypes.Import>,
+    importOptions: Object as PropType<VxeToolbarPropTypes.ImportOptions>,
     export: [Boolean, Object] as PropType<VxeToolbarPropTypes.Export>,
+    exportOptions: Object as PropType<VxeToolbarPropTypes.ExportOptions>,
     print: [Boolean, Object] as PropType<VxeToolbarPropTypes.Print>,
+    printOptions: Object as PropType<VxeToolbarPropTypes.PrintOptions>,
     zoom: [Boolean, Object] as PropType< VxeToolbarPropTypes.Zoom>,
+    zoomOptions: Object as PropType< VxeToolbarPropTypes.ZoomOptions>,
     custom: [Boolean, Object] as PropType<VxeToolbarPropTypes.Custom>,
+    customOptions: Object as PropType<VxeToolbarPropTypes.CustomOptions>,
     buttons: {
       type: Array as PropType<VxeToolbarPropTypes.Buttons>,
       default: () => getConfig().toolbar.buttons
@@ -71,37 +77,37 @@ export default /* define-vxe-component start */ defineVxeComponent({
       const $xeToolbar = this
       const props = $xeToolbar
 
-      return Object.assign({}, XEUtils.clone(getConfig().toolbar.refresh, true), props.refresh) as VxeToolbarPropTypes.RefreshOpts
+      return Object.assign({}, XEUtils.clone(getConfig().toolbar.refresh, true), props.refreshOptions, props.refresh) as VxeToolbarPropTypes.RefreshOptions
     },
     computeImportOpts () {
       const $xeToolbar = this
       const props = $xeToolbar
 
-      return Object.assign({}, XEUtils.clone(getConfig().toolbar.import, true), props.import) as VxeToolbarPropTypes.ImportOpts
+      return Object.assign({}, XEUtils.clone(getConfig().toolbar.import, true), props.importOptions, props.import) as VxeToolbarPropTypes.ImportOptions
     },
     computeExportOpts () {
       const $xeToolbar = this
       const props = $xeToolbar
 
-      return Object.assign({}, XEUtils.clone(getConfig().toolbar.export, true), props.export) as VxeToolbarPropTypes.ExportOpts
+      return Object.assign({}, XEUtils.clone(getConfig().toolbar.export, true), props.exportOptions, props.export) as VxeToolbarPropTypes.ExportOptions
     },
     computePrintOpts () {
       const $xeToolbar = this
       const props = $xeToolbar
 
-      return Object.assign({}, XEUtils.clone(getConfig().toolbar.print, true), props.print) as VxeToolbarPropTypes.PrintOpts
+      return Object.assign({}, XEUtils.clone(getConfig().toolbar.print, true), props.printOptions, props.print) as VxeToolbarPropTypes.PrintOptions
     },
     computeZoomOpts () {
       const $xeToolbar = this
       const props = $xeToolbar
 
-      return Object.assign({}, XEUtils.clone(getConfig().toolbar.zoom, true), props.zoom) as VxeToolbarPropTypes.ZoomOpts
+      return Object.assign({}, XEUtils.clone(getConfig().toolbar.zoom, true), props.zoomOptions, props.zoom) as VxeToolbarPropTypes.ZoomOptions
     },
     computeCustomOpts () {
       const $xeToolbar = this
       const props = $xeToolbar
 
-      return Object.assign({}, XEUtils.clone(getConfig().toolbar.custom, true), props.custom) as VxeToolbarPropTypes.CustomOpts
+      return Object.assign({}, XEUtils.clone(getConfig().toolbar.custom, true), props.customOptions, props.custom) as VxeToolbarPropTypes.CustomOptions
     },
     computeTableCustomOpts (this: any) {
       const $xeToolbar = this
@@ -230,73 +236,47 @@ export default /* define-vxe-component start */ defineVxeComponent({
 
       if ($xeGrid) {
         $xeGrid.triggerZoomEvent($event)
+      } else {
+        warnLog('vxe.error.notProp', ['zoom'])
       }
     },
-    btnEvent  (evnt: Event, item: VxeToolbarPropTypes.ButtonConfig) {
+    importEvent () {
       const $xeToolbar = this
       const internalData = $xeToolbar.internalData
-      const $xeGrid = $xeToolbar.$xeGrid
 
-      const { connectTable } = internalData
-      const $table = connectTable
-      const { code } = item
-      if (code) {
-        if ($xeGrid) {
-          $xeGrid.triggerToolbarBtnEvent(item, evnt)
-        } else {
-          const gCommandOpts = commands.get(code)
-          const params = { code, button: item, $table: $table!, $grid: $xeGrid, $event: evnt }
-          if (gCommandOpts) {
-            const tCommandMethod = gCommandOpts.tableCommandMethod || gCommandOpts.commandMethod
-            if (tCommandMethod) {
-              tCommandMethod(params)
-            } else {
-              errLog('vxe.error.notCommands', [code])
-            }
-          }
-          $xeToolbar.dispatchEvent('button-click', params, evnt)
+      if ($xeToolbar.checkTable()) {
+        const { connectTable } = internalData
+        const $table: any = connectTable
+        if ($table) {
+          $table.importData()
         }
       }
     },
-    tolEvent  (evnt: Event, item: VxeToolbarPropTypes.ButtonConfig) {
+    openImportEvent () {
       const $xeToolbar = this
       const internalData = $xeToolbar.internalData
-      const $xeGrid = $xeToolbar.$xeGrid
 
-      const { connectTable } = internalData
-      const $table = connectTable
-      const { code } = item
-      if (code) {
-        if ($xeGrid) {
-          $xeGrid.triggerToolbarTolEvent(item, evnt)
-        } else {
-          const gCommandOpts = commands.get(code)
-          const params = { code, button: null, tool: item, $table: $table!, $grid: $xeGrid, $event: evnt }
-          if (gCommandOpts) {
-            const tCommandMethod = gCommandOpts.tableCommandMethod || gCommandOpts.commandMethod
-            if (tCommandMethod) {
-              tCommandMethod(params)
-            } else {
-              errLog('vxe.error.notCommands', [code])
-            }
-          }
-          $xeToolbar.dispatchEvent('tool-click', params, evnt)
+      if ($xeToolbar.checkTable()) {
+        const { connectTable } = internalData
+        const $table: any = connectTable
+        if ($table) {
+          $table.openImport()
         }
       }
     },
-    importEvent () {
+    exportEvent () {
       const $xeToolbar = this
       const internalData = $xeToolbar.internalData
 
       if ($xeToolbar.checkTable()) {
-        const { connectTable } = internalData
-        const $table: any = connectTable
+        const { connectTable } = internalData as any
+        const $table = connectTable
         if ($table) {
-          $table.openImport()
+          $table.exportData()
         }
       }
     },
-    exportEvent () {
+    openExportEvent () {
       const $xeToolbar = this
       const internalData = $xeToolbar.internalData
 
@@ -312,6 +292,18 @@ export default /* define-vxe-component start */ defineVxeComponent({
       const $xeToolbar = this
       const internalData = $xeToolbar.internalData
 
+      if ($xeToolbar.checkTable()) {
+        const { connectTable } = internalData as any
+        const $table = connectTable
+        if ($table) {
+          $table.print()
+        }
+      }
+    },
+    openPrintEvent  () {
+      const $xeToolbar = this
+      const internalData = $xeToolbar.internalData
+
       if ($xeToolbar.checkTable()) {
         const { connectTable } = internalData as any
         const $table = connectTable
@@ -320,6 +312,100 @@ export default /* define-vxe-component start */ defineVxeComponent({
         }
       }
     },
+    handleDefaultCodeEvent (eventParams: VxeButtonDefines.ClickEventParams, item: VxeToolbarPropTypes.ButtonConfig | VxeToolbarPropTypes.ToolConfig, cb: () => void) {
+      const $xeToolbar = this
+
+      switch (item.code) {
+        case 'print':
+          $xeToolbar.printEvent()
+          break
+        case 'open_print':
+          $xeToolbar.openPrintEvent()
+          break
+        case 'custom':
+          $xeToolbar.handleClickSettingEvent(eventParams)
+          break
+        case 'export':
+          $xeToolbar.exportEvent()
+          break
+        case 'open_export':
+          $xeToolbar.openExportEvent()
+          break
+        case 'import':
+          $xeToolbar.importEvent()
+          break
+        case 'open_import':
+          $xeToolbar.openImportEvent()
+          break
+        case 'zoom':
+          $xeToolbar.zoomEvent(eventParams)
+          break
+        case 'refresh':
+          $xeToolbar.refreshEvent(eventParams)
+          break
+        default:
+          cb()
+          break
+      }
+    },
+    btnEvent  (eventParams: VxeButtonDefines.ClickEventParams, item: VxeToolbarPropTypes.ButtonConfig) {
+      const $xeToolbar = this
+      const internalData = $xeToolbar.internalData
+      const $xeGrid = $xeToolbar.$xeGrid
+
+      const { $event } = eventParams
+      const { connectTable } = internalData
+      const $table = connectTable
+      const { code } = item
+      if (code) {
+        $xeToolbar.handleDefaultCodeEvent(eventParams, item, () => {
+          if ($xeGrid) {
+            $xeGrid.triggerToolbarBtnEvent(item, $event)
+          } else {
+            const gCommandOpts = commands.get(code)
+            const params = { code, button: item, $table: $table!, $grid: $xeGrid, $event }
+            if (gCommandOpts) {
+              const tCommandMethod = gCommandOpts.tableCommandMethod || gCommandOpts.commandMethod
+              if (tCommandMethod) {
+                tCommandMethod(params)
+              } else {
+                errLog('vxe.error.notCommands', [code])
+              }
+            }
+            $xeToolbar.dispatchEvent('button-click', params, $event)
+          }
+        })
+      }
+    },
+    tolEvent (eventParams: VxeButtonDefines.ClickEventParams, item: VxeToolbarPropTypes.ToolConfig) {
+      const $xeToolbar = this
+      const internalData = $xeToolbar.internalData
+      const $xeGrid = $xeToolbar.$xeGrid
+
+      const { $event } = eventParams
+      const { connectTable } = internalData
+      const $table = connectTable
+      const { code } = item
+      if (code) {
+        $xeToolbar.handleDefaultCodeEvent(eventParams, item, () => {
+          if ($xeGrid) {
+            $xeGrid.triggerToolbarTolEvent(item, $event)
+          } else {
+            const gCommandOpts = commands.get(code)
+            const params = { code, button: null, tool: item, $table: $table!, $grid: $xeGrid, $event }
+            if (gCommandOpts) {
+              const tCommandMethod = gCommandOpts.tableCommandMethod || gCommandOpts.commandMethod
+              if (tCommandMethod) {
+                tCommandMethod(params)
+              } else {
+                errLog('vxe.error.notCommands', [code])
+              }
+            }
+            $xeToolbar.dispatchEvent('tool-click', params, $event)
+          }
+        })
+      }
+    },
 
     //
     // Render
@@ -357,7 +443,7 @@ export default /* define-vxe-component start */ defineVxeComponent({
                 suffixTooltip: child.suffixTooltip
               },
               on: {
-                click: ({ $event }: any) => isBtn ? $xeToolbar.btnEvent($event, child) : $xeToolbar.tolEvent($event, child)
+                click: (eventParams: VxeButtonDefines.ClickEventParams) => isBtn ? $xeToolbar.btnEvent(eventParams, child) : $xeToolbar.tolEvent(eventParams, child)
               }
             })
             : renderEmptyElement($xeToolbar)
@@ -424,11 +510,11 @@ export default /* define-vxe-component start */ defineVxeComponent({
                       transfer: item.transfer
                     },
                     on: {
-                      click: ({ $event }: any) => this.btnEvent($event, item)
+                      click: (eventParams: VxeButtonDefines.ClickEventParams) => $xeToolbar.btnEvent(eventParams, item)
                     },
                     scopedSlots: dropdowns && dropdowns.length
                       ? {
-                          dropdowns: () => this.renderDropdowns(h, item, true)
+                          dropdowns: () => $xeToolbar.renderDropdowns(h, item, true)
                         }
                       : {}
                   })
@@ -505,7 +591,7 @@ export default /* define-vxe-component start */ defineVxeComponent({
                       transfer: item.transfer
                     },
                     on: {
-                      click: ({ $event }: any) => $xeToolbar.tolEvent($event, item)
+                      click: (eventParams: VxeButtonDefines.ClickEventParams) => $xeToolbar.tolEvent(eventParams, item)
                     },
                     scopedSlots: dropdowns && dropdowns.length
                       ? {
@@ -540,7 +626,7 @@ export default /* define-vxe-component start */ defineVxeComponent({
             title: getI18n('vxe.toolbar.import')
           },
           on: {
-            click: $xeToolbar.importEvent
+            click: $xeToolbar.openImportEvent
           }
         })
         : renderEmptyElement($xeToolbar)
@@ -561,7 +647,7 @@ export default /* define-vxe-component start */ defineVxeComponent({
             title: getI18n('vxe.toolbar.export')
           },
           on: {
-            click: $xeToolbar.exportEvent
+            click: $xeToolbar.openExportEvent
           }
         })
         : renderEmptyElement($xeToolbar)
@@ -582,7 +668,7 @@ export default /* define-vxe-component start */ defineVxeComponent({
             title: getI18n('vxe.toolbar.print')
           },
           on: {
-            click: $xeToolbar.printEvent
+            click: $xeToolbar.openPrintEvent
           }
         })
         : renderEmptyElement($xeToolbar)
@@ -713,13 +799,32 @@ export default /* define-vxe-component start */ defineVxeComponent({
     const $xeGrid = $xeToolbar.$xeGrid
 
     $xeToolbar.$nextTick(() => {
-      const { refresh } = props
       const refreshOpts = $xeToolbar.computeRefreshOpts
-      const $xeTable = this.fintTable() as any
+      const $xeTable = $xeToolbar.fintTable() as any
       const queryMethod = refreshOpts.queryMethod || refreshOpts.query
-      if (refresh && !$xeGrid && !queryMethod) {
+      if (props.refresh && !$xeGrid && !queryMethod) {
         warnLog('vxe.error.notFunc', ['queryMethod'])
       }
+
+      if (XEUtils.isPlainObject(props.custom)) {
+        warnLog('vxe.error.delProp', ['custom={...}', 'custom=boolean & custom-options={...}'])
+      }
+      if (XEUtils.isPlainObject(props.print)) {
+        warnLog('vxe.error.delProp', ['print={...}', 'print=boolean & print-options={...}'])
+      }
+      if (XEUtils.isPlainObject(props.export)) {
+        warnLog('vxe.error.delProp', ['export={...}', 'export=boolean & export-options={...}'])
+      }
+      if (XEUtils.isPlainObject(props.import)) {
+        warnLog('vxe.error.delProp', ['import={...}', 'import=boolean & import-options={...}'])
+      }
+      if (XEUtils.isPlainObject(props.refresh)) {
+        warnLog('vxe.error.delProp', ['refresh={...}', 'refresh=boolean & refresh-options={...}'])
+      }
+      if (XEUtils.isPlainObject(props.refresh)) {
+        warnLog('vxe.error.delProp', ['zoom={...}', 'zoom=boolean & zoom-options={...}'])
+      }
+
       if ($xeTable) {
         $xeTable.connect(this)
       }

package/packages/ui/index.ts

@@ -101,6 +101,14 @@ VxeUI.setConfig({
       showFooter: true,
       placement: 'top-right',
       //  storage: false,
+      storeOptions: {
+        visible: true,
+        resizable: true,
+        sort: true,
+        fixed: true
+        // rowGroup: false,
+        // aggFunc: false
+      },
       //  checkMethod () {},
       modalOptions: {
         showMaximize: true,
@@ -309,6 +317,9 @@ VxeUI.setIcon({
   TABLE_DRAG_DISABLED: iconPrefix + 'no-drop',
   TABLE_ROW_GROUP_OPEN: iconPrefix + 'arrow-right rotate90',
   TABLE_ROW_GROUP_CLOSE: iconPrefix + 'arrow-right',
+  TABLE_AGGREGATION_GROUPING: iconPrefix + 'grouping',
+  TABLE_AGGREGATION_VALUES: iconPrefix + 'values',
+  TABLE_AGGREGATION_DELETE: iconPrefix + 'close',
 
   // toolbar
   TOOLBAR_TOOLS_REFRESH: iconPrefix + 'repeat',