doway-coms 1.1.55 → 1.1.56

package/node_modules/vxe-table/packages/grid/src/grid.js

@@ -1,950 +0,0 @@
-import Table from '../../table'
-import XEUtils from 'xe-utils'
-import GlobalConfig from '../../v-x-e-table/src/conf'
-import vSize from '../../mixins/size'
-import VXETable from '../../v-x-e-table'
-import UtilTools, { isEnableConf } from '../../tools/utils'
-import DomTools, { getOffsetHeight, getPaddingTopBottomSize } from '../../tools/dom'
-import { GlobalEvent } from '../../tools/event'
-import { warnLog, errLog } from '../../tools/log'
-
-const methods = {}
-const propKeys = Object.keys(Table.props)
-
-function renderDefaultForm (h, _vm) {
-  const { $scopedSlots, proxyConfig, proxyOpts, formData, formConfig, formOpts } = _vm
-  if (isEnableConf(formConfig) && formOpts.items && formOpts.items.length) {
-    const formSlots = {}
-    if (!formOpts.inited) {
-      formOpts.inited = true
-      const beforeItem = proxyOpts.beforeItem
-      if (proxyOpts && beforeItem) {
-        formOpts.items.forEach(item => {
-          beforeItem.call(_vm, { $grid: _vm, item })
-        })
-      }
-    }
-    // 处理插槽
-    formOpts.items.forEach((item) => {
-      XEUtils.each(item.slots, (func) => {
-        if (!XEUtils.isFunction(func)) {
-          if ($scopedSlots[func]) {
-            formSlots[func] = $scopedSlots[func]
-          }
-        }
-      })
-    })
-    return [
-      h('vxe-form', {
-        props: Object.assign({}, formOpts, {
-          data: proxyConfig && proxyOpts.form ? formData : formOpts.data
-        }),
-        on: {
-          submit: _vm.submitEvent,
-          reset: _vm.resetEvent,
-          collapse: _vm.collapseEvent,
-          'submit-invalid': _vm.submitInvalidEvent
-        },
-        scopedSlots: formSlots
-      })
-    ]
-  }
-  return []
-}
-
-function getFuncSlot (_vm, optSlots, slotKey) {
-  const { $scopedSlots } = _vm
-  const funcSlot = optSlots[slotKey]
-  if (funcSlot) {
-    if (XEUtils.isString(funcSlot)) {
-      if ($scopedSlots[funcSlot]) {
-        return $scopedSlots[funcSlot]
-      } else {
-        if (process.env.VUE_APP_VXE_TABLE_ENV === 'development') {
-          errLog('vxe.error.notSlot', [funcSlot])
-        }
-      }
-    } else {
-      return funcSlot
-    }
-  }
-  return null
-}
-
-function getToolbarSlots (_vm) {
-  const { $scopedSlots, toolbarOpts } = _vm
-  const toolbarOptSlots = toolbarOpts.slots
-  let buttonsSlot
-  let toolsSlot
-  const slots = {}
-  if (process.env.VUE_APP_VXE_TABLE_ENV === 'development') {
-    if ($scopedSlots.buttons && (!toolbarOptSlots || toolbarOptSlots.buttons !== 'buttons')) {
-      warnLog('vxe.error.reqProp', ['toolbar-config.slots.buttons'])
-    }
-    if ($scopedSlots.tools && (!toolbarOptSlots || toolbarOptSlots.tools !== 'tools')) {
-      warnLog('vxe.error.reqProp', ['toolbar-config.slots.tools'])
-    }
-  }
-  if (toolbarOptSlots) {
-    buttonsSlot = getFuncSlot(_vm, toolbarOptSlots, 'buttons')
-    toolsSlot = getFuncSlot(_vm, toolbarOptSlots, 'tools')
-    if (buttonsSlot) {
-      slots.buttons = buttonsSlot
-    }
-    if (toolsSlot) {
-      slots.tools = toolsSlot
-    }
-  }
-  return slots
-}
-
-function getPagerSlots (_vm) {
-  const { pagerOpts } = _vm
-  const pagerOptSlots = pagerOpts.slots
-  const slots = {}
-  let leftSlot
-  let rightSlot
-  if (pagerOptSlots) {
-    leftSlot = getFuncSlot(_vm, pagerOptSlots, 'left')
-    rightSlot = getFuncSlot(_vm, pagerOptSlots, 'right')
-    if (leftSlot) {
-      slots.left = leftSlot
-    }
-    if (rightSlot) {
-      slots.right = rightSlot
-    }
-  }
-  return slots
-}
-
-function getTableOns (_vm) {
-  const { $listeners, proxyConfig, proxyOpts } = _vm
-  const ons = {}
-  XEUtils.each($listeners, (cb, type) => {
-    ons[type] = (...args) => {
-      _vm.$emit(type, ...args)
-    }
-  })
-  if (proxyConfig) {
-    if (proxyOpts.sort) {
-      ons['sort-change'] = _vm.sortChangeEvent
-    }
-    if (proxyOpts.filter) {
-      ons['filter-change'] = _vm.filterChangeEvent
-    }
-  }
-  return ons
-}
-
-Object.keys(Table.methods).forEach(name => {
-  methods[name] = function (...args) {
-    return this.$refs.xTable && this.$refs.xTable[name](...args)
-  }
-})
-
-export default {
-  name: 'VxeGrid',
-  mixins: [vSize],
-  props: {
-    ...Table.props,
-    columns: Array,
-    pagerConfig: [Boolean, Object],
-    proxyConfig: Object,
-    toolbar: [Boolean, Object],
-    toolbarConfig: [Boolean, Object],
-    formConfig: [Boolean, Object],
-    zoomConfig: Object,
-    size: { type: String, default: () => GlobalConfig.grid.size || GlobalConfig.size }
-  },
-  provide () {
-    return {
-      $xegrid: this
-    }
-  },
-  data () {
-    return {
-      tableLoading: false,
-      isZMax: false,
-      tableData: [],
-      pendingRecords: [],
-      filterData: [],
-      formData: {},
-      sortData: [],
-      tZindex: 0,
-      tablePage: {
-        total: 0,
-        pageSize: 10,
-        currentPage: 1
-      }
-    }
-  },
-  computed: {
-    isMsg () {
-      return this.proxyOpts.message !== false
-    },
-    proxyOpts () {
-      return Object.assign({}, GlobalConfig.grid.proxyConfig, this.proxyConfig)
-    },
-    pagerOpts () {
-      return Object.assign({}, GlobalConfig.grid.pagerConfig, this.pagerConfig)
-    },
-    formOpts () {
-      return Object.assign({}, GlobalConfig.grid.formConfig, this.formConfig)
-    },
-    toolbarOpts () {
-      return Object.assign({}, GlobalConfig.grid.toolbarConfig, this.toolbarConfig || this.toolbar)
-    },
-    zoomOpts () {
-      return Object.assign({}, GlobalConfig.grid.zoomConfig, this.zoomConfig)
-    },
-    renderStyle () {
-      return this.isZMax ? { zIndex: this.tZindex } : null
-    },
-    tableExtendProps () {
-      const rest = {}
-      propKeys.forEach(key => {
-        rest[key] = this[key]
-      })
-      return rest
-    },
-    tableProps () {
-      const { isZMax, seqConfig, pagerConfig, loading, editConfig, proxyConfig, proxyOpts, tableExtendProps, tableLoading, tablePage, tableData } = this
-      const tableProps = Object.assign({}, tableExtendProps)
-      if (isZMax) {
-        if (tableExtendProps.maxHeight) {
-          tableProps.maxHeight = 'auto'
-        } else {
-          tableProps.height = 'auto'
-        }
-      }
-      if (proxyConfig) {
-        tableProps.loading = loading || tableLoading
-        tableProps.data = tableData
-        tableProps.rowClassName = this.handleRowClassName
-        if (proxyOpts.seq && isEnableConf(pagerConfig)) {
-          tableProps.seqConfig = Object.assign({}, seqConfig, { startIndex: (tablePage.currentPage - 1) * tablePage.pageSize })
-        }
-      }
-      if (editConfig) {
-        tableProps.editConfig = Object.assign({}, editConfig, { activeMethod: this.handleActiveMethod })
-      }
-      return tableProps
-    }
-  },
-  watch: {
-    columns (value) {
-      this.$nextTick(() => this.loadColumn(value))
-    },
-    toolbar (value) {
-      if (value) {
-        this.initToolbar()
-      }
-    },
-    toolbarConfig (value) {
-      if (value) {
-        this.initToolbar()
-      }
-    },
-    proxyConfig () {
-      this.initProxy()
-    },
-    pagerConfig () {
-      this.initPages()
-    }
-  },
-  created () {
-    const { data, formOpts, proxyOpts, proxyConfig } = this
-    if (proxyConfig && (data || (proxyOpts.form && formOpts.data))) {
-      errLog('vxe.error.errConflicts', ['grid.data', 'grid.proxy-config'])
-    }
-
-    if (process.env.VUE_APP_VXE_TABLE_ENV === 'development') {
-      if (this.toolbar) {
-        warnLog('vxe.error.delProp', ['grid.toolbar', 'grid.toolbar-config'])
-      }
-      if (this.toolbarConfig && !XEUtils.isObject(this.toolbarConfig)) {
-        warnLog('vxe.error.errProp', [`grid.toolbar-config=${this.toolbarConfig}`, 'grid.toolbar-config={}'])
-      }
-    }
-
-    GlobalEvent.on(this, 'keydown', this.handleGlobalKeydownEvent)
-  },
-  mounted () {
-    if (this.columns && this.columns.length) {
-      this.loadColumn(this.columns)
-    }
-    this.initToolbar()
-    this.initPages()
-    this.initProxy()
-  },
-  destroyed () {
-    GlobalEvent.off(this, 'keydown')
-  },
-  render (h) {
-    const { $scopedSlots, vSize, isZMax } = this
-    const hasForm = !!($scopedSlots.form || isEnableConf(this.formConfig))
-    const hasToolbar = !!($scopedSlots.toolbar || isEnableConf(this.toolbarConfig) || this.toolbar)
-    const hasPager = !!($scopedSlots.pager || isEnableConf(this.pagerConfig))
-    return h('div', {
-      class: ['vxe-grid', {
-        [`size--${vSize}`]: vSize,
-        'is--animat': !!this.animat,
-        'is--round': this.round,
-        'is--maximize': isZMax,
-        'is--loading': this.loading || this.tableLoading
-      }],
-      style: this.renderStyle
-    }, [
-      /**
-       * 渲染表单
-       */
-      hasForm ? h('div', {
-        ref: 'formWrapper',
-        class: 'vxe-grid--form-wrapper'
-      }, $scopedSlots.form
-        ? $scopedSlots.form.call(this, { $grid: this }, h)
-        : renderDefaultForm(h, this)
-      ) : null,
-      /**
-       * 渲染工具栏
-       */
-      hasToolbar ? h('div', {
-        ref: 'toolbarWrapper',
-        class: 'vxe-grid--toolbar-wrapper'
-      }, $scopedSlots.toolbar
-        ? $scopedSlots.toolbar.call(this, { $grid: this }, h)
-        : [
-          h('vxe-toolbar', {
-            props: this.toolbarOpts,
-            ref: 'xToolbar',
-            scopedSlots: getToolbarSlots(this)
-          })
-        ]
-      ) : null,
-      /**
-       * 渲染表格顶部区域
-       */
-      $scopedSlots.top ? h('div', {
-        ref: 'topWrapper',
-        class: 'vxe-grid--top-wrapper'
-      }, $scopedSlots.top.call(this, { $grid: this }, h)) : null,
-      /**
-       * 渲染表格
-       */
-      h('vxe-table', {
-        props: this.tableProps,
-        on: getTableOns(this),
-        scopedSlots: $scopedSlots,
-        ref: 'xTable'
-      }),
-      /**
-       * 渲染表格底部区域
-       */
-      $scopedSlots.bottom ? h('div', {
-        ref: 'bottomWrapper',
-        class: 'vxe-grid--bottom-wrapper'
-      }, $scopedSlots.bottom.call(this, { $grid: this }, h)) : null,
-      /**
-       * 渲染分页
-       */
-      hasPager ? h('div', {
-        ref: 'pagerWrapper',
-        class: 'vxe-grid--pager-wrapper'
-      }, $scopedSlots.pager
-        ? $scopedSlots.pager.call(this, { $grid: this }, h)
-        : [
-          h('vxe-pager', {
-            props: { ...this.pagerOpts, ...(this.proxyConfig ? this.tablePage : {}) },
-            on: {
-              'page-change': this.pageChangeEvent
-            },
-            scopedSlots: getPagerSlots(this)
-          })
-        ]
-      ) : null
-    ])
-  },
-  methods: {
-    ...methods,
-    callSlot (slotFunc, params, h, vNodes) {
-      if (slotFunc) {
-        const { $scopedSlots } = this
-        if (XEUtils.isString(slotFunc)) {
-          slotFunc = $scopedSlots[slotFunc] || null
-        }
-        if (XEUtils.isFunction(slotFunc)) {
-          return slotFunc.call(this, params, h, vNodes)
-        }
-      }
-      return []
-    },
-    getParentHeight () {
-      const { $el, isZMax } = this
-      return (isZMax ? DomTools.getDomNode().visibleHeight : XEUtils.toNumber(getComputedStyle($el.parentNode).height)) - this.getExcludeHeight()
-    },
-    /**
-     * 获取需要排除的高度
-     */
-    getExcludeHeight () {
-      const { $refs, $el, isZMax, height } = this
-      const { formWrapper, toolbarWrapper, topWrapper, bottomWrapper, pagerWrapper } = $refs
-      const parentPaddingSize = isZMax || height !== 'auto' ? 0 : getPaddingTopBottomSize($el.parentNode)
-      return parentPaddingSize + getPaddingTopBottomSize($el) + getOffsetHeight(formWrapper) + getOffsetHeight(toolbarWrapper) + getOffsetHeight(topWrapper) + getOffsetHeight(bottomWrapper) + getOffsetHeight(pagerWrapper)
-    },
-    handleRowClassName (params) {
-      const rowClassName = this.rowClassName
-      const clss = []
-      if (this.pendingRecords.some(item => item === params.row)) {
-        clss.push('row--pending')
-      }
-      clss.push(rowClassName ? (XEUtils.isFunction(rowClassName) ? rowClassName(params) : rowClassName) : '')
-      return clss
-    },
-    handleActiveMethod (params) {
-      const { editConfig } = this
-      const activeMethod = editConfig ? editConfig.activeMethod : null
-      return this.pendingRecords.indexOf(params.row) === -1 && (!activeMethod || activeMethod({ ...params, $grid: this }))
-    },
-    initToolbar () {
-      this.$nextTick(() => {
-        const { xTable, xToolbar } = this.$refs
-        if (xTable && xToolbar) {
-          xTable.connect(xToolbar)
-        }
-      })
-    },
-    initPages () {
-      const { tablePage, pagerConfig, pagerOpts } = this
-      const { currentPage, pageSize } = pagerOpts
-      if (pagerConfig) {
-        if (currentPage) {
-          tablePage.currentPage = currentPage
-        }
-        if (pageSize) {
-          tablePage.pageSize = pageSize
-        }
-      }
-    },
-    initProxy () {
-      const { proxyInited, proxyConfig, proxyOpts, formConfig, formOpts } = this
-      if (proxyConfig) {
-        if (isEnableConf(formConfig) && proxyOpts.form && formOpts.items) {
-          const formData = {}
-          formOpts.items.forEach(item => {
-            const { field, itemRender } = item
-            if (field) {
-              let itemValue = null
-              if (itemRender) {
-                const { defaultValue } = itemRender
-                if (XEUtils.isFunction(defaultValue)) {
-                  itemValue = defaultValue({ item })
-                } else if (!XEUtils.isUndefined(defaultValue)) {
-                  itemValue = defaultValue
-                }
-              }
-              formData[field] = itemValue
-            }
-          })
-          this.formData = formData
-        }
-        if (!proxyInited && proxyOpts.autoLoad !== false) {
-          this.proxyInited = true
-          this.$nextTick(() => this.commitProxy('_init'))
-        }
-      }
-    },
-    handleGlobalKeydownEvent (evnt) {
-      const isEsc = evnt.keyCode === 27
-      if (isEsc && this.isZMax && this.zoomOpts.escRestore !== false) {
-        this.triggerZoomEvent(evnt)
-      }
-    },
-    /**
-     * 提交指令，支持 code 或 button
-     * @param {String/Object} code 字符串或对象
-     */
-    commitProxy (proxyTarget, ...args) {
-      const { $refs, toolbar, toolbarConfig, toolbarOpts, proxyOpts, tablePage, pagerConfig, editRules, formData, isMsg } = this
-      const { beforeQuery, afterQuery, beforeDelete, afterDelete, beforeSave, afterSave, ajax = {}, props: proxyProps = {} } = proxyOpts
-      const $xetable = $refs.xTable
-      let button
-      let code
-      if (XEUtils.isString(proxyTarget)) {
-        const matchObj = toolbarConfig || toolbar ? XEUtils.findTree(toolbarOpts.buttons, item => item.code === proxyTarget, { children: 'dropdowns' }) : null
-        code = proxyTarget
-        button = matchObj ? matchObj.item : null
-      } else {
-        button = proxyTarget
-        code = button.code
-      }
-      const btnParams = button ? button.params : null
-      switch (code) {
-        case 'insert':
-          this.insert()
-          break
-        case 'insert_actived':
-          this.insert().then(({ row }) => this.setActiveRow(row))
-          break
-        case 'mark_cancel':
-          this.triggerPendingEvent(code)
-          break
-        case 'remove':
-          return this.handleDeleteRow(code, 'vxe.grid.removeSelectRecord', () => this.removeCheckboxRow())
-        case 'import':
-          this.importData(btnParams)
-          break
-        case 'open_import':
-          this.openImport(btnParams)
-          break
-        case 'export':
-          this.exportData(btnParams)
-          break
-        case 'open_export':
-          this.openExport(btnParams)
-          break
-        case 'reset_custom':
-          this.resetColumn(true)
-          break
-        case '_init':
-        case 'reload':
-        case 'query': {
-          const ajaxMethods = ajax.query
-          if (ajaxMethods) {
-            const isInited = code === '_init'
-            const isReload = code === 'reload'
-            let sortList = []
-            let filterList = []
-            let pageParams = {}
-            if (pagerConfig) {
-              if (isInited || isReload) {
-                tablePage.currentPage = 1
-              }
-              if (isEnableConf(pagerConfig)) {
-                pageParams = { ...tablePage }
-              }
-            }
-            if (isInited) {
-              const { sortOpts } = $xetable
-              let defaultSort = sortOpts.defaultSort
-              // 如果使用默认排序
-              if (defaultSort) {
-                if (!XEUtils.isArray(defaultSort)) {
-                  defaultSort = [defaultSort]
-                }
-                sortList = defaultSort.map((item) => {
-                  return {
-                    field: item.field,
-                    property: item.field,
-                    order: item.order
-                  }
-                })
-              }
-              filterList = $xetable.getCheckedFilters()
-            } else {
-              if (isReload) {
-                this.pendingRecords = []
-                $xetable.clearAll()
-              } else {
-                sortList = $xetable.getSortColumns()
-                filterList = $xetable.getCheckedFilters()
-              }
-            }
-            const params = {
-              code,
-              button,
-              $grid: this,
-              page: pageParams,
-              sort: sortList.length ? sortList[0] : {},
-              sorts: sortList,
-              filters: filterList,
-              form: formData,
-              options: ajaxMethods
-            }
-            this.sortData = sortList
-            this.filterData = filterList
-            this.tableLoading = true
-            const applyArgs = [params].concat(args)
-            return Promise.resolve((beforeQuery || ajaxMethods)(...applyArgs))
-              .catch(e => e)
-              .then(rest => {
-                this.tableLoading = false
-                if (rest) {
-                  if (isEnableConf(pagerConfig)) {
-                    const total = XEUtils.get(rest, proxyProps.total || 'page.total') || 0
-                    tablePage.total = XEUtils.toNumber(total)
-                    this.tableData = XEUtils.get(rest, proxyProps.result || 'result') || []
-                    // 检验当前页码，不能超出当前最大页数
-                    const pageCount = Math.max(Math.ceil(total / tablePage.pageSize), 1)
-                    if (tablePage.currentPage > pageCount) {
-                      tablePage.currentPage = pageCount
-                    }
-                  } else {
-                    this.tableData = (proxyProps.list ? XEUtils.get(rest, proxyProps.list) : rest) || []
-                  }
-                } else {
-                  this.tableData = []
-                }
-                if (afterQuery) {
-                  afterQuery(...applyArgs)
-                }
-              })
-          } else {
-            if (process.env.VUE_APP_VXE_TABLE_ENV === 'development') {
-              errLog('vxe.error.notFunc', ['proxy-config.ajax.query'])
-            }
-          }
-          break
-        }
-        case 'delete': {
-          const ajaxMethods = ajax.delete
-          if (ajaxMethods) {
-            const selectRecords = $xetable.getCheckboxRecords()
-            const removeRecords = selectRecords.filter(row => !$xetable.isInsertByRow(row))
-            const body = { removeRecords }
-            const applyArgs = [{ $grid: this, code, button, body, options: ajaxMethods }].concat(args)
-            if (selectRecords.length) {
-              return this.handleDeleteRow(code, 'vxe.grid.deleteSelectRecord', () => {
-                if (!removeRecords.length) {
-                  return $xetable.remove(selectRecords)
-                }
-                this.tableLoading = true
-                return Promise.resolve((beforeDelete || ajaxMethods)(...applyArgs))
-                  .then(rest => {
-                    this.tableLoading = false
-                    this.pendingRecords = this.pendingRecords.filter(row => removeRecords.indexOf(row) === -1)
-                    if (isMsg) {
-                      // 检测弹窗模块
-                      if (process.env.VUE_APP_VXE_TABLE_ENV === 'development') {
-                        if (!VXETable.modal) {
-                          errLog('vxe.error.reqModule', ['Modal'])
-                        }
-                      }
-                      VXETable.modal.message({ content: this.getRespMsg(rest, 'vxe.grid.delSuccess'), status: 'success' })
-                    }
-                    if (afterDelete) {
-                      afterDelete(...applyArgs)
-                    } else {
-                      this.commitProxy('query')
-                    }
-                  })
-                  .catch(rest => {
-                    this.tableLoading = false
-                    if (isMsg) {
-                      // 检测弹窗模块
-                      if (process.env.VUE_APP_VXE_TABLE_ENV === 'development') {
-                        if (!VXETable.modal) {
-                          errLog('vxe.error.reqModule', ['Modal'])
-                        }
-                      }
-                      VXETable.modal.message({ id: code, content: this.getRespMsg(rest, 'vxe.grid.operError'), status: 'error' })
-                    }
-                  })
-              })
-            } else {
-              if (isMsg) {
-                // 检测弹窗模块
-                if (process.env.VUE_APP_VXE_TABLE_ENV === 'development') {
-                  if (!VXETable.modal) {
-                    errLog('vxe.error.reqModule', ['Modal'])
-                  }
-                }
-                VXETable.modal.message({ id: code, content: GlobalConfig.i18n('vxe.grid.selectOneRecord'), status: 'warning' })
-              }
-            }
-          } else {
-            if (process.env.VUE_APP_VXE_TABLE_ENV === 'development') {
-              errLog('vxe.error.notFunc', ['proxy-config.ajax.delete'])
-            }
-          }
-          break
-        }
-        case 'save': {
-          const ajaxMethods = ajax.save
-          if (ajaxMethods) {
-            const body = Object.assign({ pendingRecords: this.pendingRecords }, this.getRecordset())
-            const { insertRecords, removeRecords, updateRecords, pendingRecords } = body
-            const applyArgs = [{ $grid: this, code, button, body, options: ajaxMethods }].concat(args)
-            // 排除掉新增且标记为删除的数据
-            if (insertRecords.length) {
-              body.pendingRecords = pendingRecords.filter(row => insertRecords.indexOf(row) === -1)
-            }
-            // 排除已标记为删除的数据
-            if (pendingRecords.length) {
-              body.insertRecords = insertRecords.filter(row => pendingRecords.indexOf(row) === -1)
-            }
-            let restPromise = Promise.resolve()
-            if (editRules) {
-              // 只校验新增和修改的数据
-              restPromise = this.validate(body.insertRecords.concat(updateRecords))
-            }
-            return restPromise.then((errMap) => {
-              if (errMap) {
-                // 如果校验不通过
-                return
-              }
-              if (body.insertRecords.length || removeRecords.length || updateRecords.length || body.pendingRecords.length) {
-                this.tableLoading = true
-                return Promise.resolve((beforeSave || ajaxMethods)(...applyArgs))
-                  .then(rest => {
-                    this.tableLoading = false
-                    this.pendingRecords = []
-                    if (isMsg) {
-                      // 检测弹窗模块
-                      if (process.env.VUE_APP_VXE_TABLE_ENV === 'development') {
-                        if (!VXETable.modal) {
-                          errLog('vxe.error.reqModule', ['Modal'])
-                        }
-                      }
-                      VXETable.modal.message({ content: this.getRespMsg(rest, 'vxe.grid.saveSuccess'), status: 'success' })
-                    }
-                    if (afterSave) {
-                      afterSave(...applyArgs)
-                    } else {
-                      this.commitProxy('query')
-                    }
-                  })
-                  .catch(rest => {
-                    this.tableLoading = false
-                    if (isMsg) {
-                      // 检测弹窗模块
-                      if (process.env.VUE_APP_VXE_TABLE_ENV === 'development') {
-                        if (!VXETable.modal) {
-                          errLog('vxe.error.reqModule', ['Modal'])
-                        }
-                      }
-                      VXETable.modal.message({ id: code, content: this.getRespMsg(rest, 'vxe.grid.operError'), status: 'error' })
-                    }
-                  })
-              } else {
-                if (isMsg) {
-                  // 检测弹窗模块
-                  if (process.env.VUE_APP_VXE_TABLE_ENV === 'development') {
-                    if (!VXETable.modal) {
-                      errLog('vxe.error.reqModule', ['Modal'])
-                    }
-                  }
-                  VXETable.modal.message({ id: code, content: GlobalConfig.i18n('vxe.grid.dataUnchanged'), status: 'info' })
-                }
-              }
-            })
-          } else {
-            if (process.env.VUE_APP_VXE_TABLE_ENV === 'development') {
-              errLog('vxe.error.notFunc', ['proxy-config.ajax.save'])
-            }
-          }
-          break
-        }
-        default: {
-          const btnMethod = VXETable.commands.get(code)
-          if (btnMethod) {
-            btnMethod({ code, button, $grid: this, $table: $xetable }, ...args)
-          }
-        }
-      }
-      return this.$nextTick()
-    },
-    getRespMsg (rest, defaultMsg) {
-      const { props: proxyProps = {} } = this.proxyOpts
-      let msg
-      if (rest && proxyProps.message) {
-        msg = XEUtils.get(rest, proxyProps.message)
-      }
-      return msg || GlobalConfig.i18n(defaultMsg)
-    },
-    handleDeleteRow (code, alertKey, callback) {
-      const selectRecords = this.getCheckboxRecords()
-      if (this.isMsg) {
-        if (selectRecords.length) {
-          return VXETable.modal.confirm({ id: `cfm_${code}`, content: GlobalConfig.i18n(alertKey), escClosable: true }).then(type => {
-            if (type === 'confirm') {
-              callback()
-            }
-          })
-        } else {
-          // 检测弹窗模块
-          if (process.env.VUE_APP_VXE_TABLE_ENV === 'development') {
-            if (!VXETable.modal) {
-              errLog('vxe.error.reqModule', ['Modal'])
-            }
-          }
-          VXETable.modal.message({ id: `msg_${code}`, content: GlobalConfig.i18n('vxe.grid.selectOneRecord'), status: 'warning' })
-        }
-      } else {
-        if (selectRecords.length) {
-          callback()
-        }
-      }
-      return Promise.resolve()
-    },
-    getFormItems (itemIndex) {
-      const { formConfig, formOpts } = this
-      const itemList = []
-      XEUtils.eachTree(isEnableConf(formConfig) && formOpts.items ? formOpts.items : [], item => {
-        itemList.push(item)
-      }, { children: 'children' })
-      return XEUtils.isUndefined(itemIndex) ? itemList : itemList[itemIndex]
-    },
-    getPendingRecords () {
-      return this.pendingRecords
-    },
-    triggerToolbarBtnEvent (button, evnt) {
-      this.commitProxy(button, evnt)
-      this.$emit('toolbar-button-click', { code: button.code, button, $grid: this, $event: evnt })
-    },
-    triggerToolbarTolEvent (tool, evnt) {
-      this.commitProxy(tool, evnt)
-      this.$emit('toolbar-tool-click', { code: tool.code, tool, $grid: this, $event: evnt })
-    },
-    triggerPendingEvent (code) {
-      const { pendingRecords, isMsg } = this
-      const selectRecords = this.getCheckboxRecords()
-      if (selectRecords.length) {
-        const plus = []
-        const minus = []
-        selectRecords.forEach(data => {
-          if (pendingRecords.some(item => data === item)) {
-            minus.push(data)
-          } else {
-            plus.push(data)
-          }
-        })
-        if (minus.length) {
-          this.pendingRecords = pendingRecords.filter(item => minus.indexOf(item) === -1).concat(plus)
-        } else if (plus.length) {
-          this.pendingRecords = pendingRecords.concat(plus)
-        }
-        this.clearCheckboxRow()
-      } else {
-        if (isMsg) {
-          // 检测弹窗模块
-          if (process.env.VUE_APP_VXE_TABLE_ENV === 'development') {
-            if (!VXETable.modal) {
-              errLog('vxe.error.reqModule', ['Modal'])
-            }
-          }
-          VXETable.modal.message({ id: code, content: GlobalConfig.i18n('vxe.grid.selectOneRecord'), status: 'warning' })
-        }
-      }
-    },
-    pageChangeEvent (params) {
-      const { proxyConfig, tablePage } = this
-      const { currentPage, pageSize } = params
-      tablePage.currentPage = currentPage
-      tablePage.pageSize = pageSize
-      this.$emit('page-change', Object.assign({ $grid: this }, params))
-      if (proxyConfig) {
-        this.commitProxy('query')
-      }
-    },
-    sortChangeEvent (params) {
-      const { $table, column, sortList } = params
-      const isRemote = XEUtils.isBoolean(column.remoteSort) ? column.remoteSort : $table.sortOpts.remote
-      // 如果是服务端排序
-      if (isRemote) {
-        this.sortData = sortList
-        if (this.proxyConfig) {
-          this.tablePage.currentPage = 1
-          this.commitProxy('query')
-        }
-      }
-      this.$emit('sort-change', Object.assign({ $grid: this }, params))
-    },
-    filterChangeEvent (params) {
-      const { $table, filterList } = params
-      // 如果是服务端过滤
-      if ($table.filterOpts.remote) {
-        this.filterData = filterList
-        if (this.proxyConfig) {
-          this.tablePage.currentPage = 1
-          this.commitProxy('query')
-        }
-      }
-      this.$emit('filter-change', Object.assign({ $grid: this }, params))
-    },
-    submitEvent (params) {
-      const { proxyConfig } = this
-      if (proxyConfig) {
-        this.commitProxy('reload')
-      }
-      this.$emit('form-submit', Object.assign({ $grid: this }, params))
-    },
-    resetEvent (params) {
-      const { proxyConfig } = this
-      if (proxyConfig) {
-        this.commitProxy('reload')
-      }
-      this.$emit('form-reset', Object.assign({ $grid: this }, params))
-    },
-    submitInvalidEvent (params) {
-      this.$emit('form-submit-invalid', Object.assign({ $grid: this }, params))
-    },
-    collapseEvent (params) {
-      this.$nextTick(() => this.recalculate(true))
-      this.$emit('form-toggle-collapse', Object.assign({ $grid: this }, params))
-      this.$emit('form-collapse', Object.assign({ $grid: this }, params))
-    },
-    triggerZoomEvent (evnt) {
-      this.zoom()
-      this.$emit('zoom', { $grid: this, type: this.isZMax ? 'max' : 'revert', $event: evnt })
-    },
-    zoom () {
-      return this[this.isZMax ? 'revert' : 'maximize']()
-    },
-    isMaximized () {
-      return this.isZMax
-    },
-    maximize () {
-      return this.handleZoom(true)
-    },
-    revert () {
-      return this.handleZoom()
-    },
-    handleZoom (isMax) {
-      const { isZMax } = this
-      if (isMax ? !isZMax : isZMax) {
-        this.isZMax = !isZMax
-        if (this.tZindex < UtilTools.getLastZIndex()) {
-          this.tZindex = UtilTools.nextZIndex()
-        }
-      }
-      return this.$nextTick().then(() => this.recalculate(true)).then(() => this.isZMax)
-    },
-    getProxyInfo () {
-      const { sortData, proxyConfig } = this
-      if (proxyConfig) {
-        return {
-          data: this.tableData,
-          filter: this.filterData,
-          form: this.formData,
-          sort: sortData.length ? sortData[0] : {},
-          sorts: sortData,
-          pager: this.tablePage,
-          pendingRecords: this.pendingRecords
-        }
-      }
-      return null
-    },
-    // 检查插槽
-    ...(process.env.VUE_APP_VXE_TABLE_ENV === 'development' ? {
-      loadColumn (columns) {
-        const { $scopedSlots } = this
-        XEUtils.eachTree(columns, column => {
-          if (column.slots) {
-            XEUtils.each(column.slots, (func) => {
-              if (!XEUtils.isFunction(func)) {
-                if (!$scopedSlots[func]) {
-                  errLog('vxe.error.notSlot', [func])
-                }
-              }
-            })
-          }
-        })
-        return this.$refs.xTable.loadColumn(columns)
-      },
-      reloadColumn (columns) {
-        this.clearAll()
-        return this.loadColumn(columns)
-      }
-    } : null)
-  }
-}