vxe-table 3.8.23 → 3.9.0-rc.0

package/packages/input/src/number.js

@@ -1,12 +0,0 @@
-import XEUtils from 'xe-utils'
-
-export function handleNumber (val) {
-  return XEUtils.isString(val) ? val.replace(/,/g, '') : val
-}
-
-export function toFloatValueFixed (inputValue, digitsValue) {
-  if (/^-/.test('' + inputValue)) {
-    return XEUtils.toFixed(XEUtils.ceil(inputValue, digitsValue), digitsValue)
-  }
-  return XEUtils.toFixed(XEUtils.floor(inputValue, digitsValue), digitsValue)
-}

package/packages/keyboard/index.d.ts

@@ -1,4 +0,0 @@
-import { VxeTableKeyboardModule } from '../../types/module/keyboard'
-
-export * from '../../types/module/keyboard'
-export default VxeTableKeyboardModule

package/packages/keyboard/index.js

@@ -1,14 +0,0 @@
-import Table from '../table'
-import mixin from './src/mixin'
-import VXETable from '../v-x-e-table'
-
-export const VxeTableKeyboardModule = {
-  install () {
-    VXETable.reg('keyboard')
-    Table.mixins.push(mixin)
-  }
-}
-
-export const Keyboard = VxeTableKeyboardModule
-
-export default VxeTableKeyboardModule

package/packages/keyboard/src/mixin.js

@@ -1,355 +0,0 @@
-import XEUtils from 'xe-utils'
-import DomTools, { browse } from '../../tools/dom'
-
-function getTargetOffset (target, container) {
-  let offsetTop = 0
-  let offsetLeft = 0
-  const triggerCheckboxLabel = !browse.firefox && DomTools.hasClass(target, 'vxe-checkbox--label')
-  if (triggerCheckboxLabel) {
-    const checkboxLabelStyle = getComputedStyle(target)
-    offsetTop -= XEUtils.toNumber(checkboxLabelStyle.paddingTop)
-    offsetLeft -= XEUtils.toNumber(checkboxLabelStyle.paddingLeft)
-  }
-  while (target && target !== container) {
-    offsetTop += target.offsetTop
-    offsetLeft += target.offsetLeft
-    target = target.offsetParent
-    if (triggerCheckboxLabel) {
-      const checkboxStyle = getComputedStyle(target)
-      offsetTop -= XEUtils.toNumber(checkboxStyle.paddingTop)
-      offsetLeft -= XEUtils.toNumber(checkboxStyle.paddingLeft)
-    }
-  }
-  return { offsetTop, offsetLeft }
-}
-
-function getCheckboxRangeRows (_vm, params, targetTrElem, moveRange) {
-  let countHeight = 0
-  let rangeRows = []
-  const isDown = moveRange > 0
-  const moveSize = moveRange > 0 ? moveRange : (Math.abs(moveRange) + targetTrElem.offsetHeight)
-  const { afterFullData, scrollYStore, scrollYLoad } = _vm
-  if (scrollYLoad) {
-    const _rowIndex = _vm.getVTRowIndex(params.row)
-    if (isDown) {
-      rangeRows = afterFullData.slice(_rowIndex, _rowIndex + Math.ceil(moveSize / scrollYStore.rowHeight))
-    } else {
-      rangeRows = afterFullData.slice(_rowIndex - Math.floor(moveSize / scrollYStore.rowHeight) + 1, _rowIndex + 1)
-    }
-  } else {
-    const siblingProp = isDown ? 'next' : 'previous'
-    while (targetTrElem && countHeight < moveSize) {
-      rangeRows.push(_vm.getRowNode(targetTrElem).item)
-      countHeight += targetTrElem.offsetHeight
-      targetTrElem = targetTrElem[`${siblingProp}ElementSibling`]
-    }
-  }
-  return rangeRows
-}
-
-export default {
-  methods: {
-    // 处理 Tab 键移动
-    moveTabSelected (args, isLeft, evnt) {
-      const { afterFullData, visibleColumn, editConfig, editOpts } = this
-      let targetRow
-      let targetRowIndex
-      let targetColumnIndex
-      const params = Object.assign({}, args)
-      const _rowIndex = this.getVTRowIndex(params.row)
-      const _columnIndex = this.getVTColumnIndex(params.column)
-      evnt.preventDefault()
-      if (isLeft) {
-        // 向左
-        if (_columnIndex <= 0) {
-          // 如果已经是第一列，则移动到上一行
-          if (_rowIndex > 0) {
-            targetRowIndex = _rowIndex - 1
-            targetRow = afterFullData[targetRowIndex]
-            targetColumnIndex = visibleColumn.length - 1
-          }
-        } else {
-          targetColumnIndex = _columnIndex - 1
-        }
-      } else {
-        if (_columnIndex >= visibleColumn.length - 1) {
-          // 如果已经是第一列，则移动到上一行
-          if (_rowIndex < afterFullData.length - 1) {
-            targetRowIndex = _rowIndex + 1
-            targetRow = afterFullData[targetRowIndex]
-            targetColumnIndex = 0
-          }
-        } else {
-          targetColumnIndex = _columnIndex + 1
-        }
-      }
-      const targetColumn = visibleColumn[targetColumnIndex]
-      if (targetColumn) {
-        if (targetRow) {
-          params.rowIndex = targetRowIndex
-          params.row = targetRow
-        } else {
-          params.rowIndex = _rowIndex
-        }
-        params.columnIndex = targetColumnIndex
-        params.column = targetColumn
-        params.cell = this.getCellElement(params.row, params.column)
-        if (editConfig) {
-          if (editOpts.trigger === 'click' || editOpts.trigger === 'dblclick') {
-            if (editOpts.mode === 'row') {
-              this.handleActived(params, evnt)
-            } else {
-              this.scrollToRow(params.row, params.column)
-                .then(() => this.handleSelected(params, evnt))
-            }
-          }
-        } else {
-          this.scrollToRow(params.row, params.column)
-            .then(() => this.handleSelected(params, evnt))
-        }
-      }
-    },
-    // 处理当前行方向键移动
-    moveCurrentRow (isUpArrow, isDwArrow, evnt) {
-      const { currentRow, treeConfig, treeOpts, afterFullData } = this
-      const childrenField = treeOpts.children || treeOpts.childrenField
-      let targetRow
-      evnt.preventDefault()
-      if (currentRow) {
-        if (treeConfig) {
-          const { index, items } = XEUtils.findTree(afterFullData, item => item === currentRow, { children: childrenField })
-          if (isUpArrow && index > 0) {
-            targetRow = items[index - 1]
-          } else if (isDwArrow && index < items.length - 1) {
-            targetRow = items[index + 1]
-          }
-        } else {
-          const _rowIndex = this.getVTRowIndex(currentRow)
-          if (isUpArrow && _rowIndex > 0) {
-            targetRow = afterFullData[_rowIndex - 1]
-          } else if (isDwArrow && _rowIndex < afterFullData.length - 1) {
-            targetRow = afterFullData[_rowIndex + 1]
-          }
-        }
-      } else {
-        targetRow = afterFullData[0]
-      }
-      if (targetRow) {
-        const params = { $table: this, row: targetRow }
-        this.scrollToRow(targetRow)
-          .then(() => this.triggerCurrentRowEvent(evnt, params))
-      }
-    },
-    // 处理可编辑方向键移动
-    moveSelected (args, isLeftArrow, isUpArrow, isRightArrow, isDwArrow, evnt) {
-      const { afterFullData, visibleColumn } = this
-      const params = Object.assign({}, args)
-      const _rowIndex = this.getVTRowIndex(params.row)
-      const _columnIndex = this.getVTColumnIndex(params.column)
-      evnt.preventDefault()
-      if (isUpArrow && _rowIndex > 0) {
-        // 移动到上一行
-        params.rowIndex = _rowIndex - 1
-        params.row = afterFullData[params.rowIndex]
-      } else if (isDwArrow && _rowIndex < afterFullData.length - 1) {
-        // 移动到下一行
-        params.rowIndex = _rowIndex + 1
-        params.row = afterFullData[params.rowIndex]
-      } else if (isLeftArrow && _columnIndex) {
-        // 移动到左侧单元格
-        params.columnIndex = _columnIndex - 1
-        params.column = visibleColumn[params.columnIndex]
-      } else if (isRightArrow && _columnIndex < visibleColumn.length - 1) {
-        // 移动到右侧单元格
-        params.columnIndex = _columnIndex + 1
-        params.column = visibleColumn[params.columnIndex]
-      }
-      this.scrollToRow(params.row, params.column).then(() => {
-        params.cell = this.getCellElement(params.row, params.column)
-        this.handleSelected(params, evnt)
-      })
-    },
-    /**
-     * 表头单元格按下事件
-     */
-    triggerHeaderCellMousedownEvent (evnt, params) {
-      const { mouseConfig, mouseOpts } = this
-      if (mouseConfig && mouseOpts.area && this.handleHeaderCellAreaEvent) {
-        const cell = evnt.currentTarget
-        const triggerSort = DomTools.getEventTargetNode(evnt, cell, 'vxe-cell--sort').flag
-        const triggerFilter = DomTools.getEventTargetNode(evnt, cell, 'vxe-cell--filter').flag
-        this.handleHeaderCellAreaEvent(evnt, Object.assign({ cell, triggerSort, triggerFilter }, params))
-      }
-      this.focus()
-      this.closeMenu()
-    },
-    /**
-     * 单元格按下事件
-     */
-    triggerCellMousedownEvent (evnt, params) {
-      const cell = evnt.currentTarget
-      params.cell = cell
-      this.handleCellMousedownEvent(evnt, params)
-      this.focus()
-      this.closeFilter()
-      this.closeMenu()
-    },
-    handleCellMousedownEvent (evnt, params) {
-      const { editConfig, editOpts, handleSelected, checkboxConfig, checkboxOpts, mouseConfig, mouseOpts } = this
-      if (mouseConfig && mouseOpts.area && this.handleCellAreaEvent) {
-        return this.handleCellAreaEvent(evnt, params)
-      } else {
-        if (checkboxConfig && checkboxOpts.range) {
-          this.handleCheckboxRangeEvent(evnt, params)
-        }
-        if (mouseConfig && mouseOpts.selected) {
-          if (!editConfig || editOpts.mode === 'cell') {
-            handleSelected(params, evnt)
-          }
-        }
-      }
-    },
-    handleCheckboxRangeEvent (evnt, params) {
-      const { column, cell } = params
-      if (column.type === 'checkbox') {
-        const { $el, elemStore } = this
-        const disX = evnt.clientX
-        const disY = evnt.clientY
-        const bodyWrapperElem = elemStore[`${column.fixed || 'main'}-body-wrapper`] || elemStore['main-body-wrapper']
-        const checkboxRangeElem = bodyWrapperElem.querySelector('.vxe-table--checkbox-range')
-        const domMousemove = document.onmousemove
-        const domMouseup = document.onmouseup
-        const trElem = cell.parentNode
-        const selectRecords = this.getCheckboxRecords()
-        let lastRangeRows = []
-        const marginSize = 1
-        const offsetRest = getTargetOffset(evnt.target, bodyWrapperElem)
-        const startTop = offsetRest.offsetTop + evnt.offsetY
-        const startLeft = offsetRest.offsetLeft + evnt.offsetX
-        const startScrollTop = bodyWrapperElem.scrollTop
-        const rowHeight = trElem.offsetHeight
-        let mouseScrollTimeout = null
-        let isMouseScrollDown = false
-        let mouseScrollSpaceSize = 1
-        const triggerEvent = (type, evnt) => {
-          this.emitEvent(`checkbox-range-${type}`, { records: this.getCheckboxRecords(), reserves: this.getCheckboxReserveRecords() }, evnt)
-        }
-        const handleChecked = (evnt) => {
-          const { clientX, clientY } = evnt
-          const offsetLeft = clientX - disX
-          const offsetTop = clientY - disY + (bodyWrapperElem.scrollTop - startScrollTop)
-          let rangeHeight = Math.abs(offsetTop)
-          let rangeWidth = Math.abs(offsetLeft)
-          let rangeTop = startTop
-          let rangeLeft = startLeft
-          if (offsetTop < marginSize) {
-            // 向上
-            rangeTop += offsetTop
-            if (rangeTop < marginSize) {
-              rangeTop = marginSize
-              rangeHeight = startTop
-            }
-          } else {
-            // 向下
-            rangeHeight = Math.min(rangeHeight, bodyWrapperElem.scrollHeight - startTop - marginSize)
-          }
-          if (offsetLeft < marginSize) {
-            // 向左
-            rangeLeft += offsetLeft
-            if (rangeWidth > startLeft) {
-              rangeLeft = marginSize
-              rangeWidth = startLeft
-            }
-          } else {
-            // 向右
-            rangeWidth = Math.min(rangeWidth, bodyWrapperElem.clientWidth - startLeft - marginSize)
-          }
-          checkboxRangeElem.style.height = `${rangeHeight}px`
-          checkboxRangeElem.style.width = `${rangeWidth}px`
-          checkboxRangeElem.style.left = `${rangeLeft}px`
-          checkboxRangeElem.style.top = `${rangeTop}px`
-          checkboxRangeElem.style.display = 'block'
-          const rangeRows = getCheckboxRangeRows(this, params, trElem, offsetTop < marginSize ? -rangeHeight : rangeHeight)
-          // 至少滑动 10px 才能有效匹配
-          if (rangeHeight > 10 && rangeRows.length !== lastRangeRows.length) {
-            lastRangeRows = rangeRows
-            if (evnt.ctrlKey) {
-              rangeRows.forEach(row => {
-                this.handleSelectRow({ row }, selectRecords.indexOf(row) === -1)
-              })
-            } else {
-              this.setAllCheckboxRow(false)
-              this.handleCheckedCheckboxRow(rangeRows, true, false)
-            }
-            triggerEvent('change', evnt)
-          }
-        }
-        // 停止鼠标滚动
-        const stopMouseScroll = () => {
-          clearTimeout(mouseScrollTimeout)
-          mouseScrollTimeout = null
-        }
-        // 开始鼠标滚动
-        const startMouseScroll = (evnt) => {
-          stopMouseScroll()
-          mouseScrollTimeout = setTimeout(() => {
-            if (mouseScrollTimeout) {
-              const { scrollLeft, scrollTop, clientHeight, scrollHeight } = bodyWrapperElem
-              const topSize = Math.ceil(mouseScrollSpaceSize * 50 / rowHeight)
-              if (isMouseScrollDown) {
-                if (scrollTop + clientHeight < scrollHeight) {
-                  this.scrollTo(scrollLeft, scrollTop + topSize)
-                  startMouseScroll(evnt)
-                  handleChecked(evnt)
-                } else {
-                  stopMouseScroll()
-                }
-              } else {
-                if (scrollTop) {
-                  this.scrollTo(scrollLeft, scrollTop - topSize)
-                  startMouseScroll(evnt)
-                  handleChecked(evnt)
-                } else {
-                  stopMouseScroll()
-                }
-              }
-            }
-          }, 50)
-        }
-        DomTools.addClass($el, 'drag--range')
-        document.onmousemove = evnt => {
-          evnt.preventDefault()
-          evnt.stopPropagation()
-          const { clientY } = evnt
-          const { boundingTop } = DomTools.getAbsolutePos(bodyWrapperElem)
-          // 如果超过可视区，触发滚动
-          if (clientY < boundingTop) {
-            isMouseScrollDown = false
-            mouseScrollSpaceSize = boundingTop - clientY
-            if (!mouseScrollTimeout) {
-              startMouseScroll(evnt)
-            }
-          } else if (clientY > boundingTop + bodyWrapperElem.clientHeight) {
-            isMouseScrollDown = true
-            mouseScrollSpaceSize = clientY - boundingTop - bodyWrapperElem.clientHeight
-            if (!mouseScrollTimeout) {
-              startMouseScroll(evnt)
-            }
-          } else if (mouseScrollTimeout) {
-            stopMouseScroll()
-          }
-          handleChecked(evnt)
-        }
-        document.onmouseup = (evnt) => {
-          stopMouseScroll()
-          DomTools.removeClass($el, 'drag--range')
-          checkboxRangeElem.removeAttribute('style')
-          document.onmousemove = domMousemove
-          document.onmouseup = domMouseup
-          triggerEvent('end', evnt)
-        }
-        triggerEvent('start', evnt)
-      }
-    }
-  }
-}

package/packages/list/index.d.ts

@@ -1,4 +0,0 @@
-import { VxeList } from '../../types/list'
-
-export * from '../../types/list'
-export default VxeList

package/packages/list/index.js

@@ -1,13 +0,0 @@
-import VxeListComponent from './src/list'
-import VxeUI from '../v-x-e-table'
-
-export const VxeList = Object.assign(VxeListComponent, {
-  install (Vue) {
-    Vue.component(VxeListComponent.name, VxeListComponent)
-  }
-})
-VxeUI.component(VxeListComponent)
-
-export const List = VxeList
-
-export default VxeList

package/packages/list/src/list.js

@@ -1,294 +0,0 @@
-import XEUtils from 'xe-utils'
-import GlobalConfig from '../../v-x-e-table/src/conf'
-import vSize from '../../mixins/size'
-import { createResizeEvent } from '../../tools/resize'
-import { GlobalEvent } from '../../tools/event'
-import { browse } from '../../tools/dom'
-import VxeLoading from '../../loading/index'
-
-export default {
-  name: 'VxeList',
-  mixins: [vSize],
-  props: {
-    data: Array,
-    height: [Number, String],
-    maxHeight: [Number, String],
-    loading: Boolean,
-    className: [String, Function],
-    size: { type: String, default: () => GlobalConfig.list.size || GlobalConfig.size },
-    autoResize: { type: Boolean, default: () => GlobalConfig.list.autoResize },
-    syncResize: [Boolean, String, Number],
-    scrollY: Object
-  },
-  data () {
-    return {
-      scrollYLoad: false,
-      bodyHeight: 0,
-      topSpaceHeight: 0,
-      items: []
-    }
-  },
-  computed: {
-    sYOpts () {
-      return Object.assign({}, GlobalConfig.list.scrollY, this.scrollY)
-    },
-    styles () {
-      const { height, maxHeight } = this
-      const style = {}
-      if (height) {
-        style.height = isNaN(height) ? height : `${height}px`
-      } else if (maxHeight) {
-        style.height = 'auto'
-        style.maxHeight = isNaN(maxHeight) ? maxHeight : `${maxHeight}px`
-      }
-      return style
-    }
-  },
-  watch: {
-    data (value) {
-      this.loadData(value)
-    },
-    syncResize (value) {
-      if (value) {
-        this.recalculate()
-        this.$nextTick(() => setTimeout(() => this.recalculate()))
-      }
-    }
-  },
-  created () {
-    Object.assign(this, {
-      fullData: [],
-      lastScrollLeft: 0,
-      lastScrollTop: 0,
-      scrollYStore: {
-        startIndex: 0,
-        endIndex: 0,
-        visibleSize: 0
-      }
-    })
-    this.loadData(this.data)
-    GlobalEvent.on(this, 'resize', this.handleGlobalResizeEvent)
-  },
-  mounted () {
-    if (this.autoResize) {
-      const resizeObserver = createResizeEvent(() => this.recalculate())
-      resizeObserver.observe(this.$el)
-      this.$resize = resizeObserver
-    }
-  },
-  activated () {
-    this.recalculate().then(() => this.refreshScroll())
-  },
-  beforeDestroy () {
-    if (this.$resize) {
-      this.$resize.disconnect()
-    }
-  },
-  destroyed () {
-    GlobalEvent.off(this, 'resize')
-  },
-  render (h) {
-    const { $scopedSlots, styles, bodyHeight, topSpaceHeight, items, className, loading } = this
-    return h('div', {
-      class: ['vxe-list', className ? (XEUtils.isFunction(className) ? className({ $list: this }) : className) : '', {
-        'is--loading': loading
-      }]
-    }, [
-      h('div', {
-        ref: 'virtualWrapper',
-        class: 'vxe-list--virtual-wrapper',
-        style: styles,
-        on: {
-          scroll: this.scrollEvent
-        }
-      }, [
-        h('div', {
-          ref: 'ySpace',
-          class: 'vxe-list--y-space',
-          style: {
-            height: bodyHeight ? `${bodyHeight}px` : ''
-          }
-        }),
-        h('div', {
-          ref: 'virtualBody',
-          class: 'vxe-list--body',
-          style: {
-            marginTop: topSpaceHeight ? `${topSpaceHeight}px` : ''
-          }
-        }, $scopedSlots.default ? $scopedSlots.default.call(this, { items, $list: this }, h) : [])
-      ]),
-      /**
-       * 加载中
-       */
-      h(VxeLoading, {
-        class: 'vxe-list--loading',
-        props: {
-          value: loading
-        }
-      })
-    ])
-  },
-  methods: {
-    getParentElem () {
-      return this.$el.parentNode
-    },
-    /**
-     * 加载数据
-     * @param {Array} datas 数据
-     */
-    loadData (datas) {
-      const { sYOpts, scrollYStore } = this
-      const fullData = datas || []
-      Object.assign(scrollYStore, {
-        startIndex: 0,
-        endIndex: 1,
-        visibleSize: 0
-      })
-      this.fullData = fullData
-      // 如果gt为0，则总是启用
-      this.scrollYLoad = sYOpts.enabled && sYOpts.gt > -1 && (sYOpts.gt === 0 || sYOpts.gt <= fullData.length)
-      this.handleData()
-      return this.computeScrollLoad().then(() => {
-        this.refreshScroll()
-      })
-    },
-    /**
-     * 重新加载数据
-     * @param {Array} datas 数据
-     */
-    reloadData (datas) {
-      this.clearScroll()
-      return this.loadData(datas)
-    },
-    handleData () {
-      const { fullData, scrollYLoad, scrollYStore } = this
-      this.items = scrollYLoad ? fullData.slice(scrollYStore.startIndex, scrollYStore.endIndex) : fullData.slice(0)
-      return this.$nextTick()
-    },
-    /**
-     * 重新计算列表
-     */
-    recalculate () {
-      const { $el } = this
-      if ($el.clientWidth && $el.clientHeight) {
-        return this.computeScrollLoad()
-      }
-      return Promise.resolve()
-    },
-    /**
-     * 清除滚动条
-     */
-    clearScroll () {
-      const scrollBodyElem = this.$refs.virtualWrapper
-      if (scrollBodyElem) {
-        scrollBodyElem.scrollTop = 0
-      }
-      return this.$nextTick()
-    },
-    /**
-     * 刷新滚动条
-     */
-    refreshScroll () {
-      const { lastScrollLeft, lastScrollTop } = this
-      return this.clearScroll().then(() => {
-        if (lastScrollLeft || lastScrollTop) {
-          this.lastScrollLeft = 0
-          this.lastScrollTop = 0
-          return this.scrollTo(lastScrollLeft, lastScrollTop)
-        }
-      })
-    },
-    /**
-     * 如果有滚动条，则滚动到对应的位置
-     * @param {Number} scrollLeft 左距离
-     * @param {Number} scrollTop 上距离
-     */
-    scrollTo (scrollLeft, scrollTop) {
-      const scrollBodyElem = this.$refs.virtualWrapper
-      if (XEUtils.isNumber(scrollLeft)) {
-        scrollBodyElem.scrollLeft = scrollLeft
-      }
-      if (XEUtils.isNumber(scrollTop)) {
-        scrollBodyElem.scrollTop = scrollTop
-      }
-      if (this.scrollYLoad) {
-        return new Promise(resolve => setTimeout(() => resolve(this.$nextTick()), 50))
-      }
-      return this.$nextTick()
-    },
-    computeScrollLoad () {
-      return this.$nextTick().then(() => {
-        const { $refs, sYOpts, scrollYLoad, scrollYStore } = this
-        const { virtualWrapper: virtualWrapperElem, virtualBody: virtualBodyElem } = $refs
-        let rowHeight = 0
-        let firstItemElem
-        if (virtualBodyElem) {
-          if (sYOpts.sItem) {
-            firstItemElem = virtualBodyElem.querySelector(sYOpts.sItem)
-          }
-          if (!firstItemElem) {
-            firstItemElem = virtualBodyElem.children[0]
-          }
-        }
-        if (firstItemElem) {
-          rowHeight = firstItemElem.offsetHeight
-        }
-        rowHeight = Math.max(20, rowHeight)
-        scrollYStore.rowHeight = rowHeight
-        // 计算 Y 逻辑
-        if (scrollYLoad) {
-          const visibleYSize = Math.max(8, Math.ceil(virtualWrapperElem.clientHeight / rowHeight))
-          const offsetYSize = sYOpts.oSize ? XEUtils.toNumber(sYOpts.oSize) : browse.msie ? 20 : (browse.edge ? 10 : 0)
-          scrollYStore.offsetSize = offsetYSize
-          scrollYStore.visibleSize = visibleYSize
-          scrollYStore.endIndex = Math.max(scrollYStore.startIndex, visibleYSize + offsetYSize, scrollYStore.endIndex)
-          this.updateYData()
-        } else {
-          this.updateYSpace()
-        }
-        this.rowHeight = rowHeight
-      })
-    },
-    scrollEvent (evnt) {
-      const scrollBodyElem = evnt.target
-      const scrollTop = scrollBodyElem.scrollTop
-      const scrollLeft = scrollBodyElem.scrollLeft
-      const isX = scrollLeft !== this.lastScrollLeft
-      const isY = scrollTop !== this.lastScrollTop
-      this.lastScrollTop = scrollTop
-      this.lastScrollLeft = scrollLeft
-      if (this.scrollYLoad) {
-        this.loadYData(evnt)
-      }
-      this.$emit('scroll', { scrollLeft, scrollTop, isX, isY, $event: evnt })
-    },
-    loadYData (evnt) {
-      const { scrollYStore } = this
-      const { startIndex, endIndex, visibleSize, offsetSize, rowHeight } = scrollYStore
-      const scrollBodyElem = evnt.target
-      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
-          this.updateYData()
-        }
-      }
-    },
-    updateYData () {
-      this.handleData()
-      this.updateYSpace()
-    },
-    updateYSpace () {
-      const { scrollYStore, scrollYLoad, fullData } = this
-      this.bodyHeight = scrollYLoad ? fullData.length * scrollYStore.rowHeight : 0
-      this.topSpaceHeight = scrollYLoad ? Math.max(scrollYStore.startIndex * scrollYStore.rowHeight, 0) : 0
-    },
-    handleGlobalResizeEvent () {
-      this.recalculate()
-    }
-  }
-}