doway-coms 1.1.55 → 1.1.56

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

@@ -1,282 +0,0 @@
-import VXETable from '../../v-x-e-table'
-import XEUtils from 'xe-utils'
-import { ColumnInfo } from './columnInfo'
-import DomTools from '../../tools/dom'
-
-const lineOffsetSizes = {
-  mini: 3,
-  small: 2,
-  medium: 1
-}
-
-export function restoreScrollLocation (_vm, scrollLeft, scrollTop) {
-  return _vm.clearScroll().then(() => {
-    if (scrollLeft || scrollTop) {
-      // 重置最后滚动状态
-      _vm.lastScrollLeft = 0
-      _vm.lastScrollTop = 0
-      // 还原滚动状态
-      return _vm.scrollTo(scrollLeft, scrollTop)
-    }
-  })
-}
-
-export function toTreePathSeq (path) {
-  return path.map((num, i) => i % 2 === 0 ? (Number(num) + 1) : '.').join('')
-}
-
-export function removeScrollListener (scrollElem) {
-  if (scrollElem && scrollElem._onscroll) {
-    scrollElem.onscroll = null
-  }
-}
-
-export function restoreScrollListener (scrollElem) {
-  if (scrollElem && scrollElem._onscroll) {
-    scrollElem.onscroll = scrollElem._onscroll
-  }
-}
-
-// 行主键 key
-export function getRowkey ($xetable) {
-  return $xetable.rowOpts.keyField || $xetable.rowId || '_X_ROW_KEY'
-}
-
-// 行主键 value
-export function getRowid ($xetable, row) {
-  const rowid = XEUtils.get(row, getRowkey($xetable))
-  return XEUtils.eqNull(rowid) ? '' : encodeURIComponent(rowid)
-}
-
-function getPaddingLeftRightSize (elem) {
-  if (elem) {
-    const computedStyle = getComputedStyle(elem)
-    const paddingLeft = XEUtils.toNumber(computedStyle.paddingLeft)
-    const paddingRight = XEUtils.toNumber(computedStyle.paddingRight)
-    return paddingLeft + paddingRight
-  }
-  return 0
-}
-
-function getElemenMarginWidth (elem) {
-  if (elem) {
-    const computedStyle = getComputedStyle(elem)
-    const marginLeft = XEUtils.toNumber(computedStyle.marginLeft)
-    const marginRight = XEUtils.toNumber(computedStyle.marginRight)
-    return elem.offsetWidth + marginLeft + marginRight
-  }
-  return 0
-}
-
-export function handleFieldOrColumn (_vm, fieldOrColumn) {
-  if (fieldOrColumn) {
-    return XEUtils.isString(fieldOrColumn) ? _vm.getColumnByField(fieldOrColumn) : fieldOrColumn
-  }
-  return null
-}
-
-function queryCellElement (cell, selector) {
-  return cell.querySelector('.vxe-cell' + selector)
-}
-
-export function toFilters (filters) {
-  if (filters && XEUtils.isArray(filters)) {
-    return filters.map(({ label, value, data, resetValue, checked }) => {
-      return { label, value, data, resetValue, checked: !!checked, _checked: !!checked }
-    })
-  }
-  return filters
-}
-
-export function getColMinWidth (params) {
-  const { $table, column, cell } = params
-  const { showHeaderOverflow: allColumnHeaderOverflow, resizableOpts } = $table
-  const { minWidth } = resizableOpts
-  // 如果自定义调整宽度逻辑
-  if (minWidth) {
-    const customMinWidth = XEUtils.isFunction(minWidth) ? minWidth(params) : minWidth
-    if (customMinWidth !== 'auto') {
-      return Math.max(1, XEUtils.toNumber(customMinWidth))
-    }
-  }
-  const { showHeaderOverflow, minWidth: colMinWidth } = column
-  const headOverflow = XEUtils.isUndefined(showHeaderOverflow) || XEUtils.isNull(showHeaderOverflow) ? allColumnHeaderOverflow : showHeaderOverflow
-  const showEllipsis = headOverflow === 'ellipsis'
-  const showTitle = headOverflow === 'title'
-  const showTooltip = headOverflow === true || headOverflow === 'tooltip'
-  const hasEllipsis = showTitle || showTooltip || showEllipsis
-  const minTitleWidth = XEUtils.floor((XEUtils.toNumber(getComputedStyle(cell).fontSize) || 14) * 1.6)
-  const paddingLeftRight = getPaddingLeftRightSize(cell) + getPaddingLeftRightSize(queryCellElement(cell, ''))
-  let mWidth = minTitleWidth + paddingLeftRight
-  // 默认最小宽处理
-  if (hasEllipsis) {
-    const checkboxIconWidth = getPaddingLeftRightSize(queryCellElement(cell, '--title>.vxe-cell--checkbox'))
-    const requiredIconWidth = getElemenMarginWidth(queryCellElement(cell, '>.vxe-cell--required-icon'))
-    const editIconWidth = getElemenMarginWidth(queryCellElement(cell, '>.vxe-cell--edit-icon'))
-    const helpIconWidth = getElemenMarginWidth(queryCellElement(cell, '>.vxe-cell-help-icon'))
-    const sortIconWidth = getElemenMarginWidth(queryCellElement(cell, '>.vxe-cell--sort'))
-    const filterIconWidth = getElemenMarginWidth(queryCellElement(cell, '>.vxe-cell--filter'))
-    mWidth += checkboxIconWidth + requiredIconWidth + editIconWidth + helpIconWidth + filterIconWidth + sortIconWidth
-  }
-  // 如果设置最小宽
-  if (colMinWidth) {
-    const { tableBody } = $table.$refs
-    const bodyElem = tableBody ? tableBody.$el : null
-    if (bodyElem) {
-      if (DomTools.isScale(colMinWidth)) {
-        const bodyWidth = bodyElem.clientWidth - 1
-        const meanWidth = bodyWidth / 100
-        return Math.max(mWidth, Math.floor(XEUtils.toInteger(colMinWidth) * meanWidth))
-      } else if (DomTools.isPx(colMinWidth)) {
-        return Math.max(mWidth, XEUtils.toInteger(colMinWidth))
-      }
-    }
-  }
-  return mWidth
-}
-
-function countTreeExpand (prevRow, params) {
-  let count = 1
-  if (!prevRow) {
-    return count
-  }
-  const { $table } = params
-  const rowChildren = prevRow[$table.treeOpts.children]
-  if ($table.isTreeExpandByRow(prevRow)) {
-    for (let index = 0; index < rowChildren.length; index++) {
-      count += countTreeExpand(rowChildren[index], params)
-    }
-  }
-  return count
-}
-
-export function getOffsetSize ($xetable) {
-  return lineOffsetSizes[$xetable.vSize] || 0
-}
-
-export function calcTreeLine (params, items, rIndex) {
-  const { $table } = params
-  let expandSize = 1
-  if (rIndex) {
-    expandSize = countTreeExpand(items[rIndex - 1], params)
-  }
-  return $table.rowHeight * expandSize - (rIndex ? 1 : (12 - getOffsetSize($table)))
-}
-
-export function mergeBodyMethod (mergeList, _rowIndex, _columnIndex) {
-  for (let mIndex = 0; mIndex < mergeList.length; mIndex++) {
-    const { row: mergeRowIndex, col: mergeColIndex, rowspan: mergeRowspan, colspan: mergeColspan } = mergeList[mIndex]
-    if (mergeColIndex > -1 && mergeRowIndex > -1 && mergeRowspan && mergeColspan) {
-      if (mergeRowIndex === _rowIndex && mergeColIndex === _columnIndex) {
-        return { rowspan: mergeRowspan, colspan: mergeColspan }
-      }
-      if (_rowIndex >= mergeRowIndex && _rowIndex < mergeRowIndex + mergeRowspan && _columnIndex >= mergeColIndex && _columnIndex < mergeColIndex + mergeColspan) {
-        return { rowspan: 0, colspan: 0 }
-      }
-    }
-  }
-}
-
-export function clearTableDefaultStatus (_vm) {
-  _vm.initStatus = false
-  _vm.clearSort()
-  _vm.clearCurrentRow()
-  _vm.clearCurrentColumn()
-  _vm.clearRadioRow()
-  _vm.clearRadioReserve()
-  _vm.clearCheckboxRow()
-  _vm.clearCheckboxReserve()
-  _vm.clearRowExpand()
-  _vm.clearTreeExpand()
-  _vm.clearTreeExpandReserve()
-  if (_vm.clearActived && VXETable._edit) {
-    _vm.clearActived()
-  }
-  if (_vm.clearSelected && (_vm.keyboardConfig || _vm.mouseConfig)) {
-    _vm.clearSelected()
-  }
-  if (_vm.clearCellAreas && _vm.mouseConfig) {
-    _vm.clearCellAreas()
-    _vm.clearCopyCellArea()
-  }
-  return _vm.clearScroll()
-}
-
-export function clearTableAllStatus (_vm) {
-  if (_vm.clearFilter && VXETable._filter) {
-    _vm.clearFilter()
-  }
-  return clearTableDefaultStatus(_vm)
-}
-
-export function isColumnInfo (column) {
-  return column instanceof ColumnInfo
-}
-
-export function getColumnConfig ($xetable, _vm, options) {
-  return isColumnInfo(_vm) ? _vm : new ColumnInfo($xetable, _vm, options)
-}
-
-export function rowToVisible ($xetable, row) {
-  const { tableBody } = $xetable.$refs
-  const bodyElem = tableBody ? tableBody.$el : null
-  if (bodyElem) {
-    const trElem = bodyElem.querySelector(`[rowid="${getRowid($xetable, row)}"]`)
-    if (trElem) {
-      const bodyHeight = bodyElem.clientHeight
-      const bodySrcollTop = bodyElem.scrollTop
-      const trOffsetTop = trElem.offsetTop + (trElem.offsetParent ? trElem.offsetParent.offsetTop : 0)
-      const trHeight = trElem.clientHeight
-      // 检测行是否在可视区中
-      if (trOffsetTop < bodySrcollTop || trOffsetTop > bodySrcollTop + bodyHeight) {
-        // 向上定位
-        return $xetable.scrollTo(null, trOffsetTop)
-      } else if (trOffsetTop + trHeight >= bodyHeight + bodySrcollTop) {
-        // 向下定位
-        return $xetable.scrollTo(null, bodySrcollTop + trHeight)
-      }
-    } else {
-      // 如果是虚拟渲染跨行滚动
-      if ($xetable.scrollYLoad) {
-        return $xetable.scrollTo(null, ($xetable.afterFullData.indexOf(row) - 1) * $xetable.scrollYStore.rowHeight)
-      }
-    }
-  }
-  return Promise.resolve()
-}
-
-export function colToVisible ($xetable, column) {
-  const { tableBody } = $xetable.$refs
-  const bodyElem = tableBody ? tableBody.$el : null
-  if (bodyElem) {
-    const tdElem = bodyElem.querySelector(`.${column.id}`)
-    if (tdElem) {
-      const bodyWidth = bodyElem.clientWidth
-      const bodySrcollLeft = bodyElem.scrollLeft
-      const tdOffsetLeft = tdElem.offsetLeft + (tdElem.offsetParent ? tdElem.offsetParent.offsetLeft : 0)
-      const tdWidth = tdElem.clientWidth
-      // 检测行是否在可视区中
-      if (tdOffsetLeft < bodySrcollLeft || tdOffsetLeft > bodySrcollLeft + bodyWidth) {
-        // 向左定位
-        return $xetable.scrollTo(tdOffsetLeft)
-      } else if (tdOffsetLeft + tdWidth >= bodyWidth + bodySrcollLeft) {
-        // 向右定位
-        return $xetable.scrollTo(bodySrcollLeft + tdWidth)
-      }
-    } else {
-      // 如果是虚拟渲染跨行滚动
-      if ($xetable.scrollXLoad) {
-        const visibleColumn = $xetable.visibleColumn
-        let scrollLeft = 0
-        for (let index = 0; index < visibleColumn.length; index++) {
-          if (visibleColumn[index] === column) {
-            break
-          }
-          scrollLeft += visibleColumn[index].renderWidth
-        }
-        return $xetable.scrollTo(scrollLeft)
-      }
-    }
-  }
-  return Promise.resolve()
-}

package/node_modules/vxe-table/packages/textarea/index.d.ts

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

package/node_modules/vxe-table/packages/textarea/index.js

@@ -1,9 +0,0 @@
-import VxeTextarea from './src/textarea'
-
-export const Textarea = Object.assign(VxeTextarea, {
-  install (Vue) {
-    Vue.component(VxeTextarea.name, VxeTextarea)
-  }
-})
-
-export default Textarea

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

@@ -1,206 +0,0 @@
-import XEUtils from 'xe-utils'
-import GlobalConfig from '../../v-x-e-table/src/conf'
-import vSize from '../../mixins/size'
-import { getFuncText } from '../../tools/utils'
-
-let autoTxtElem
-
-export default {
-  name: 'VxeTextarea',
-  mixins: [vSize],
-  model: {
-    prop: 'value',
-    event: 'modelValue'
-  },
-  props: {
-    value: [String, Number],
-    immediate: { type: Boolean, default: true },
-    name: String,
-    readonly: Boolean,
-    disabled: Boolean,
-    placeholder: String,
-    maxlength: [String, Number],
-    rows: { type: [String, Number], default: 2 },
-    cols: { type: [String, Number], default: null },
-    showWordCount: Boolean,
-    countMethod: Function,
-    autosize: [Boolean, Object],
-    form: String,
-    resize: { type: String, default: () => GlobalConfig.textarea.resize },
-    className: String,
-    size: { type: String, default: () => GlobalConfig.textarea.size || GlobalConfig.size }
-  },
-  data () {
-    return {
-      inputValue: this.value
-    }
-  },
-  computed: {
-    inputCount () {
-      return XEUtils.getSize(this.inputValue)
-    },
-    isCountError () {
-      return this.maxlength && this.inputCount > XEUtils.toNumber(this.maxlength)
-    },
-    defaultEvents () {
-      const evnts = {}
-      XEUtils.each(this.$listeners, (cb, name) => {
-        if (['input', 'change', 'blur'].indexOf(name) === -1) {
-          evnts[name] = this.triggerEvent
-        }
-      })
-      evnts.input = this.inputEvent
-      evnts.change = this.changeEvent
-      evnts.blur = this.blurEvent
-      return evnts
-    },
-    sizeOpts () {
-      return Object.assign({ minRows: 1, maxRows: 10 }, GlobalConfig.textarea.autosize, this.autosize)
-    }
-  },
-  watch: {
-    value (val) {
-      this.inputValue = val
-      this.updateAutoTxt()
-    }
-  },
-  mounted () {
-    const { autosize } = this
-    if (autosize) {
-      this.updateAutoTxt()
-      this.handleResize()
-    }
-  },
-  render (h) {
-    const { className, defaultEvents, inputValue, vSize, name, form, resize, placeholder, readonly, disabled, maxlength, autosize, showWordCount, countMethod, rows, cols } = this
-    const attrs = {
-      name,
-      form,
-      placeholder,
-      maxlength,
-      readonly,
-      disabled,
-      rows,
-      cols
-    }
-    if (placeholder) {
-      attrs.placeholder = getFuncText(placeholder)
-    }
-    return h('div', {
-      class: ['vxe-textarea', className, {
-        [`size--${vSize}`]: vSize,
-        'is--autosize': autosize,
-        'is--disabled': disabled,
-        'def--rows': !XEUtils.eqNull(rows),
-        'def--cols': !XEUtils.eqNull(cols)
-      }]
-    }, [
-      h('textarea', {
-        ref: 'textarea',
-        class: 'vxe-textarea--inner',
-        domProps: {
-          value: inputValue
-        },
-        attrs,
-        style: resize ? {
-          resize
-        } : null,
-        on: defaultEvents
-      }),
-      showWordCount ? h('span', {
-        class: ['vxe-textarea--count', {
-          'is--error': this.isCountError
-        }]
-      }, countMethod ? `${countMethod({ value: inputValue })}` : `${this.inputCount}${maxlength ? `/${maxlength}` : ''}`) : null
-    ])
-  },
-  methods: {
-    focus () {
-      this.$refs.textarea.focus()
-      return this.$nextTick()
-    },
-    blur () {
-      this.$refs.textarea.blur()
-      return this.$nextTick()
-    },
-    triggerEvent (evnt) {
-      const { inputValue } = this
-      this.$emit(evnt.type, { value: inputValue, $event: evnt })
-    },
-    emitUpdate (value, evnt) {
-      this.inputValue = value
-      this.$emit('modelValue', value)
-      if (this.value !== value) {
-        this.$emit('change', { value, $event: evnt })
-      }
-    },
-    inputEvent (evnt) {
-      const { immediate } = this
-      const value = evnt.target.value
-      this.inputValue = value
-      if (immediate) {
-        this.emitUpdate(value, evnt)
-      }
-      this.handleResize()
-      this.triggerEvent(evnt)
-    },
-    changeEvent (evnt) {
-      const { immediate } = this
-      if (immediate) {
-        this.triggerEvent(evnt)
-      } else {
-        this.emitUpdate(this.inputValue, evnt)
-      }
-    },
-    blurEvent (evnt) {
-      const { inputValue, immediate } = this
-      if (!immediate) {
-        this.emitUpdate(inputValue, evnt)
-      }
-      this.$emit('blur', { value: inputValue, $event: evnt })
-    },
-    updateAutoTxt () {
-      const { $refs, inputValue, size, autosize } = this
-      if (autosize) {
-        if (!autoTxtElem) {
-          autoTxtElem = document.createElement('div')
-        }
-        if (!autoTxtElem.parentNode) {
-          document.body.appendChild(autoTxtElem)
-        }
-        const textElem = $refs.textarea
-        const textStyle = getComputedStyle(textElem)
-        autoTxtElem.className = ['vxe-textarea--autosize', size ? `size--${size}` : ''].join(' ')
-        autoTxtElem.style.width = `${textElem.clientWidth}px`
-        autoTxtElem.style.padding = textStyle.padding
-        autoTxtElem.innerHTML = ('' + (inputValue || '　')).replace(/\n$/, '\n　')
-      }
-    },
-    handleResize () {
-      if (this.autosize) {
-        this.$nextTick(() => {
-          const { $refs, sizeOpts } = this
-          const { minRows, maxRows } = sizeOpts
-          const textElem = $refs.textarea
-          const sizeHeight = autoTxtElem.clientHeight
-          const textStyle = getComputedStyle(textElem)
-          const lineHeight = XEUtils.toNumber(textStyle.lineHeight)
-          const paddingTop = XEUtils.toNumber(textStyle.paddingTop)
-          const paddingBottom = XEUtils.toNumber(textStyle.paddingBottom)
-          const borderTopWidth = XEUtils.toNumber(textStyle.borderTopWidth)
-          const borderBottomWidth = XEUtils.toNumber(textStyle.borderBottomWidth)
-          const intervalHeight = paddingTop + paddingBottom + borderTopWidth + borderBottomWidth
-          const rowNum = (sizeHeight - intervalHeight) / lineHeight
-          const textRows = rowNum && /[0-9]/.test(rowNum) ? rowNum : Math.floor(rowNum) + 1
-          let vaildRows = textRows
-          if (textRows < minRows) {
-            vaildRows = minRows
-          } else if (textRows > maxRows) {
-            vaildRows = maxRows
-          }
-          textElem.style.height = `${(vaildRows * lineHeight) + intervalHeight}px`
-        })
-      }
-    }
-  }
-}

package/node_modules/vxe-table/packages/toolbar/index.d.ts

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

package/node_modules/vxe-table/packages/toolbar/index.js

@@ -1,9 +0,0 @@
-import VxeToolbar from './src/toolbar'
-
-export const Toolbar = Object.assign(VxeToolbar, {
-  install (Vue) {
-    Vue.component(VxeToolbar.name, VxeToolbar)
-  }
-})
-
-export default Toolbar