vxe-table 4.17.3 → 4.17.5

package/packages/table/module/edit/hook.ts

@@ -78,17 +78,17 @@ hooks.add('tableEditModule', {
           const { item: parentRow } = matchObj
           const parentRest = fullAllDataRowIdData[getRowid($xeTable, parentRow)]
           const parentLevel = parentRest ? parentRest.level : 0
-          let parentChilds = parentRow[childrenField]
-          let mapChilds = parentRow[mapChildrenField]
-          if (!XEUtils.isArray(parentChilds)) {
-            parentChilds = parentRow[childrenField] = []
+          let pChilds = parentRow[childrenField]
+          let pMapChilds = parentRow[mapChildrenField]
+          if (!XEUtils.isArray(pChilds)) {
+            pChilds = parentRow[childrenField] = []
           }
-          if (!XEUtils.isArray(mapChilds)) {
-            mapChilds = parentRow[childrenField] = []
+          if (!XEUtils.isArray(pMapChilds)) {
+            pMapChilds = parentRow[mapChildrenField] = []
           }
-          parentChilds[funcName](item)
-          mapChilds[funcName](item)
-          const rest = { row: item, rowid, seq: -1, index: -1, _index: -1, $index: -1, treeIndex: -1, _tIndex: -1, items: parentChilds, parent: parentRow, level: parentLevel + 1, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 }
+          pChilds[funcName](item)
+          pMapChilds[funcName](item)
+          const rest = { row: item, rowid, seq: -1, index: -1, _index: -1, $index: -1, treeIndex: -1, _tIndex: -1, items: pChilds, parent: parentRow, level: parentLevel + 1, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 }
           fullDataRowIdData[rowid] = rest
           fullAllDataRowIdData[rowid] = rest
         } else {
@@ -185,13 +185,15 @@ hooks.add('tableEditModule', {
               treeRecords.forEach((row, i) => {
                 if (parentRow) {
                   if (row[parentField] !== parentRow[rowField]) {
-                    row[parentField] = parentRow[rowField]
                     errLog('vxe.error.errProp', [`${parentField}=${row[parentField]}`, `${parentField}=${parentRow[rowField]}`])
+                    row[parentField] = parentRow[rowField]
                   }
                 } else {
                   if (row[parentField] !== null) {
+                    if (!XEUtils.eqNull(row[parentField])) {
+                      errLog('vxe.error.errProp', [`${parentField}=${row[parentField]}`, 'null'])
+                    }
                     row[parentField] = null
-                    errLog('vxe.error.errProp', [`${parentField}=${row[parentField]}`, 'null'])
                   }
                 }
                 let targetIndex = matchMapObj.index + i

package/packages/table/src/body.ts

@@ -2,7 +2,7 @@ import { h, ref, Ref, PropType, inject, nextTick, onMounted, onUnmounted } from
 import { defineVxeComponent } from '../../ui/src/comp'
 import XEUtils from 'xe-utils'
 import { VxeUI } from '../../ui'
-import { getOffsetSize, calcTreeLine, getRowid, createHandleGetRowId, getCellRestHeight } from './util'
+import { getRowid, createHandleGetRowId, getCellRestHeight } from './util'
 import { updateCellTitle, getPropClass } from '../../ui/src/dom'
 import { isEnableConf } from '../../ui/src/utils'
 import { getSlotVNs } from '../../ui/src/vn'
@@ -49,22 +49,37 @@ export default defineVxeComponent({
 
     const renderLine = (rowid: string, params: VxeTableDefines.CellRenderBodyParams, cellHeight: number): VxeComponentSlotType[] => {
       const { column } = params
-      const { afterFullData } = tableInternalData
       const { treeConfig } = tableProps
+      const cellOpts = computeCellOpts.value
+      const rowOpts = computeRowOpts.value
+      const defaultRowHeight = computeDefaultRowHeight.value
       const treeOpts = computeTreeOpts.value
       const { slots, treeNode } = column
       const { fullAllDataRowIdData } = tableInternalData
-      if (slots && (slots as any).line) {
-        return $xeTable.callSlot((slots as any).line, params)
-      }
-      const rowRest = fullAllDataRowIdData[rowid]
-      let rLevel = 0
-      let prevRow = null
-      if (rowRest) {
-        rLevel = rowRest.level
-        prevRow = rowRest.items[rowRest.treeIndex - 1]
-      }
       if (treeConfig && treeNode && (treeOpts.showLine || treeOpts.line)) {
+        if (slots && (slots as any).line) {
+          return $xeTable.callSlot((slots as any).line, params)
+        }
+        const rowRest = fullAllDataRowIdData[rowid]
+        let rLevel = 0
+        let prevRow = null
+        let parentRow = null
+        let lineHeight = ''
+        if (rowRest) {
+          rLevel = rowRest.level
+          prevRow = rowRest.items[rowRest.treeIndex - 1]
+          parentRow = rowRest.parent
+        }
+        if (!rLevel && !treeOpts.showRootLine) {
+          return []
+        }
+        if (prevRow) {
+          const prevRowRest = fullAllDataRowIdData[getRowid($xeTable, prevRow)] || {}
+          lineHeight = `${prevRowRest.lineHeight || 0}px`
+        } else if (rLevel && parentRow) {
+          const parentRowRest = fullAllDataRowIdData[getRowid($xeTable, parentRow)] || {}
+          lineHeight = `calc(-1em + ${Math.floor(cellHeight / 2 + getCellRestHeight(parentRowRest, cellOpts, rowOpts, defaultRowHeight) / 2)}px)`
+        }
         return [
           h('div', {
             key: 'tl',
@@ -73,9 +88,9 @@ export default defineVxeComponent({
             h('div', {
               class: 'vxe-tree--line',
               style: {
-                height: `${getRowid($xeTable, afterFullData[0]) === rowid ? 1 : calcTreeLine(params, prevRow)}px`,
+                height: lineHeight,
                 bottom: `-${Math.floor(cellHeight / 2)}px`,
-                left: `${(rLevel * treeOpts.indent) + (rLevel ? 2 - getOffsetSize($xeTable) : 0) + 16}px`
+                left: `calc(${(rLevel * treeOpts.indent)}px + 1em)`
               }
             })
           ])

package/packages/table/src/table.ts

@@ -1,7 +1,7 @@
 import { h, ComponentPublicInstance, reactive, ref, Ref, provide, inject, nextTick, Teleport, onActivated, onDeactivated, onBeforeUnmount, onUnmounted, watch, computed, onMounted } from 'vue'
 import { defineVxeComponent } from '../../ui/src/comp'
 import XEUtils from 'xe-utils'
-import { initTpImg, getTpImg, isPx, isScale, hasClass, addClass, removeClass, getEventTargetNode, getPaddingTopBottomSize, setScrollTop, setScrollLeft, toCssUnit, hasControlKey } from '../../ui/src/dom'
+import { initTpImg, getTpImg, isPx, isScale, hasClass, addClass, removeClass, getEventTargetNode, getPaddingTopBottomSize, setScrollTop, setScrollLeft, toCssUnit, hasControlKey, checkTargetElement } from '../../ui/src/dom'
 import { getLastZIndex, nextZIndex, hasChildrenList, getFuncText, isEnableConf, formatText, eqEmptyValue } from '../../ui/src/utils'
 import { VxeUI } from '../../ui'
 import { createInternalData, getRowUniqueId, clearTableAllStatus, getColumnList, toFilters, hasDeepKey, getRowkey, getRowid, rowToVisible, colToVisible, getCellValue, setCellValue, handleRowidOrRow, handleFieldOrColumn, toTreePathSeq, restoreScrollLocation, getRootColumn, getRefElem, getColReMinWidth, createHandleUpdateRowId, createHandleGetRowId, getCalcHeight, getCellRestHeight, getLastChildColumn } from './util'
@@ -62,6 +62,7 @@ export default defineVxeComponent({
     const VxeUITooltipComponent = VxeUI.getComponent('VxeTooltip')
 
     const $xeTabs = inject<(VxeTabsConstructor & VxeTabsPrivateMethods) | null>('$xeTabs', null)
+    const $xeParentTable = inject<(VxeTableConstructor & VxeTablePrivateMethods) | null>('$xeTable', null)
     const $xeGrid = inject<(VxeGridConstructor & VxeGridPrivateMethods) | null>('$xeGrid', null)
     const $xeGantt = inject<(VxeGanttConstructor & VxeGanttPrivateMethods) | null>('$xeGantt', null)
     const $xeGGWrapper = $xeGrid || $xeGantt
@@ -1907,6 +1908,9 @@ export default defineVxeComponent({
       }
     }
 
+    /**
+     * 计算自适应列宽
+     */
     const calcColumnAutoWidth = (column: VxeTableDefines.ColumnInfo, wrapperEl: HTMLDivElement) => {
       const columnOpts = computeColumnOpts.value
       const { autoOptions } = columnOpts
@@ -1936,6 +1940,9 @@ export default defineVxeComponent({
       return colWidth + leftRightPadding
     }
 
+    /**
+     * 自适应列宽
+     */
     const calcCellWidth = () => {
       const autoWidthColumnList = computeAutoWidthColumnList.value
       const { fullColumnIdData } = internalData
@@ -2069,6 +2076,9 @@ export default defineVxeComponent({
       updateHeight()
     }
 
+    /**
+     * 计算自适应行高
+     */
     const calcCellAutoHeight = (rowRest: VxeTableDefines.RowCacheItem, wrapperEl: HTMLDivElement) => {
       const cellElemList = wrapperEl.querySelectorAll(`.vxe-cell--wrapper[rowid="${rowRest.rowid}"]`)
       let colHeight = rowRest.height
@@ -2087,12 +2097,17 @@ export default defineVxeComponent({
       return colHeight
     }
 
+    /**
+     * 自适应行高
+     */
     const calcCellHeight = () => {
+      const { treeConfig } = props
       const { tableData, isAllOverflow, scrollYLoad, scrollXLoad } = reactData
       const { fullAllDataRowIdData } = internalData
+      const treeOpts = computeTreeOpts.value
       const defaultRowHeight = computeDefaultRowHeight.value
       const el = refElem.value
-      if (!isAllOverflow && (scrollYLoad || scrollXLoad) && el) {
+      if (!isAllOverflow && (scrollYLoad || scrollXLoad || (treeConfig && treeOpts.showLine)) && el) {
         const { handleGetRowId } = createHandleGetRowId($xeTable)
         el.setAttribute('data-calc-row', 'Y')
         tableData.forEach(row => {
@@ -3779,6 +3794,7 @@ export default defineVxeComponent({
               }
               reactData.isRowLoading = false
               handleRecalculateStyle(false, false, false)
+              updateTreeLineStyle()
               // 如果是自动行高，特殊情况需调用 recalculate 手动刷新
               if (!props.showOverflow) {
                 setTimeout(() => {
@@ -3792,6 +3808,7 @@ export default defineVxeComponent({
                   .then(() => {
                     handleRecalculateStyle(false, true, true)
                     updateRowOffsetTop()
+                    updateTreeLineStyle()
                     resolve()
                   })
               } else {
@@ -3800,6 +3817,7 @@ export default defineVxeComponent({
                     .then(() => {
                       handleRecalculateStyle(false, true, true)
                       updateRowOffsetTop()
+                      updateTreeLineStyle()
                       resolve()
                     })
                 })
@@ -4617,32 +4635,92 @@ export default defineVxeComponent({
      * 更新树连接线样式
      */
     const updateTreeLineStyle = () => {
-      // const { tableData } = reactData
-      // const { rowExpandedMaps } = internalData
-      // const treeOpts = computeTreeOpts.value
-      // const { transform, mapChildrenField } = treeOpts
-      // const childrenField = treeOpts.children || treeOpts.childrenField
-      // const { handleGetRowId } = createHandleGetRowId($xeTable)
-      // // 待优化
-      // if (transform) {
-      //   // x
-      // } else {
-      //   // x
-      // }
-      // const handleNodeRow = (row: any, parentRow: any) => {
-      //   const childList: any[] = row[transform ? mapChildrenField : childrenField]
-      //   if (childList && childList.length) {
-      //     childList.forEach(childRow => {
-      //       const childRowid = handleGetRowId(childRow)
-      //       if (rowExpandedMaps[childRowid]) {
-      //         handleNodeRow(childRow, row)
-      //       }
-      //     })
-      //   }
-      // }
-      // tableData.forEach(row => {
-      //   handleNodeRow(row, null)
-      // })
+      const { treeConfig } = props
+      if (!treeConfig) {
+        return
+      }
+      const { tableData } = reactData
+      const { fullAllDataRowIdData, treeExpandedMaps } = internalData
+      const cellOpts = computeCellOpts.value
+      const rowOpts = computeRowOpts.value
+      const defaultRowHeight = computeDefaultRowHeight.value
+      const treeOpts = computeTreeOpts.value
+      const { transform, mapChildrenField } = treeOpts
+      const childrenField = treeOpts.children || treeOpts.childrenField
+      const { handleGetRowId } = createHandleGetRowId($xeTable)
+      const expParentList: {
+        row: any
+        prevRow: any
+        nextRow: any
+      }[] = []
+
+      const handleNodeRow = (row: any, rIndex: number, rows: any[]) => {
+        const rowid = handleGetRowId(row)
+        const rowRest = fullAllDataRowIdData[rowid] || {}
+        const childList: any[] = row[transform ? mapChildrenField : childrenField]
+        const prevRow = rows[rIndex - 1] || null
+        const nextRow = rows[rIndex + 1] || null
+        if (childList && childList.length && treeExpandedMaps[rowid]) {
+          expParentList.push({ row, prevRow, nextRow })
+          childList.forEach((childRow, crIndex) => {
+            const childRowid = handleGetRowId(childRow)
+            if (treeExpandedMaps[childRowid]) {
+              handleNodeRow(childRow, crIndex, childList)
+            }
+          })
+        } else {
+          if (nextRow) {
+            const nextRowid = handleGetRowId(nextRow)
+            const nextRowRest = fullAllDataRowIdData[nextRowid] || {}
+            const currCellHeight = getCellRestHeight(rowRest, cellOpts, rowOpts, defaultRowHeight)
+            const nextCellHeight = getCellRestHeight(nextRowRest, cellOpts, rowOpts, defaultRowHeight)
+            rowRest.oHeight = currCellHeight
+            rowRest.lineHeight = Math.floor(currCellHeight / 2 + nextCellHeight / 2)
+          } else {
+            rowRest.oHeight = 0
+            rowRest.lineHeight = 0
+          }
+        }
+      }
+      tableData.forEach((row, rIndex) => {
+        handleNodeRow(row, rIndex, tableData)
+      })
+
+      XEUtils.lastArrayEach(expParentList, ({ row, nextRow }) => {
+        const rowid = handleGetRowId(row)
+        const childList: any[] = row[transform ? mapChildrenField : childrenField]
+        const rowRest = fullAllDataRowIdData[rowid]
+        if (rowRest) {
+          const currCellHeight = getCellRestHeight(rowRest, cellOpts, rowOpts, defaultRowHeight)
+          let countOffsetHeight = currCellHeight
+          let countLineHeight = 0
+          childList.forEach((childRow) => {
+            const childRowid = handleGetRowId(childRow)
+            const childRowRest = fullAllDataRowIdData[childRowid] || {}
+            const childList: any[] = childRow[transform ? mapChildrenField : childrenField]
+            if (treeExpandedMaps[childRowid] && childList && childList.length) {
+              countOffsetHeight += (childRowRest.oHeight || 0)
+              countLineHeight += (childRowRest.oHeight || 0)
+            } else {
+              const cellHeight = getCellRestHeight(childRowRest, cellOpts, rowOpts, defaultRowHeight)
+              childRowRest.oHeight = cellHeight
+              childRowRest.lineHeight = cellHeight
+              countOffsetHeight += cellHeight
+              countLineHeight += cellHeight
+            }
+          })
+          if (nextRow) {
+            const nextRowid = handleGetRowId(nextRow)
+            const nextRowRest = fullAllDataRowIdData[nextRowid] || {}
+            const currCellHeight = getCellRestHeight(rowRest, cellOpts, rowOpts, defaultRowHeight)
+            const nextCellHeight = getCellRestHeight(nextRowRest, cellOpts, rowOpts, defaultRowHeight)
+            countOffsetHeight += currCellHeight
+            countLineHeight += Math.floor(currCellHeight / 2 + nextCellHeight / 2)
+          }
+          rowRest.lineHeight = countLineHeight
+          rowRest.oHeight = countOffsetHeight
+        }
+      })
     }
 
     const handleRowExpandScroll = () => {
@@ -11517,6 +11595,22 @@ export default defineVxeComponent({
           }
         }
 
+        // 展开行处理，如果展开行嵌入表格中
+        if ($xeParentTable) {
+          if (isRollY) {
+            if (checkTargetElement(evnt.target, [leftScrollElem, bodyScrollElem, rightScrollElem], evnt.currentTarget)) {
+              evnt.stopPropagation()
+              return
+            }
+          }
+          if (isRollX) {
+            if (checkTargetElement(evnt.target, [headerScrollElem, bodyScrollElem, footerScrollElem], evnt.currentTarget)) {
+              evnt.stopPropagation()
+              return
+            }
+          }
+        }
+
         if (!(leftFixedWidth || rightFixedWidth || expandColumn)) {
           return
         }
@@ -12773,7 +12867,7 @@ export default defineVxeComponent({
     watch(dataFlag, () => {
       const { initStatus } = internalData
       const value = props.data || []
-      if (value && value.length >= 50000) {
+      if (value && value.length >= 20000) {
         warnLog('vxe.error.errLargeData', ['loadData(data), reloadData(data)'])
       }
       loadTableData(value, true).then(() => {
@@ -13021,7 +13115,7 @@ export default defineVxeComponent({
       handleUpdateRowGroup(groupFields)
 
       nextTick(() => {
-        const { data, exportConfig, importConfig, treeConfig, showOverflow, highlightCurrentRow, highlightCurrentColumn } = props
+        const { data, exportConfig, importConfig, treeConfig, highlightCurrentRow, highlightCurrentColumn } = props
         const { scrollXStore, scrollYStore } = internalData
         const editOpts = computeEditOpts.value
         const treeOpts = computeTreeOpts.value
@@ -13054,9 +13148,9 @@ export default defineVxeComponent({
         if (props.editConfig && (editOpts.showStatus || editOpts.showUpdateStatus || editOpts.showInsertStatus) && !props.keepSource) {
           warnLog('vxe.error.reqProp', ['keep-source'])
         }
-        if (treeConfig && (treeOpts.showLine || treeOpts.line) && !showOverflow) {
-          warnLog('vxe.error.reqProp', ['show-overflow'])
-        }
+        // if (treeConfig && (treeOpts.showLine || treeOpts.line) && !showOverflow) {
+        //   warnLog('vxe.error.reqProp', ['show-overflow'])
+        // }
         if (treeConfig && !treeOpts.transform && props.stripe) {
           warnLog('vxe.error.noTree', ['stripe'])
         }

package/packages/table/src/util.ts

@@ -631,75 +631,6 @@ export function getLastChildColumn (column: VxeTableDefines.ColumnInfo): VxeTabl
   return column
 }
 
-const lineOffsetSizes = {
-  mini: 3,
-  small: 2,
-  medium: 1,
-  large: 0
-}
-
-function countTreeExpandSize (prevRow: any, params: VxeTableDefines.CellRenderBodyParams) {
-  let count = 1
-  if (!prevRow) {
-    return count
-  }
-  const { $table } = params
-  const reactData = $table.reactData
-  const { treeExpandedFlag } = reactData
-  const internalData = $table.internalData
-  const { treeExpandedMaps } = internalData
-  const { computeTreeOpts } = $table.getComputeMaps()
-  const treeOpts = computeTreeOpts.value
-  const { transform, mapChildrenField } = treeOpts
-  const childrenField = treeOpts.children || treeOpts.childrenField
-  const rowChildren = prevRow[transform ? mapChildrenField : childrenField]
-  if (rowChildren && treeExpandedFlag && treeExpandedMaps[getRowid($table, prevRow)]) {
-    for (let index = 0; index < rowChildren.length; index++) {
-      count += countTreeExpandSize(rowChildren[index], params)
-    }
-  }
-  return count
-}
-
-export function getOffsetSize ($xeTable: VxeTableConstructor) {
-  const { computeSize } = $xeTable.getComputeMaps()
-  const vSize = computeSize.value
-  if (vSize) {
-    return lineOffsetSizes[vSize] || 0
-  }
-  return 0
-}
-
-export function calcTreeLine (params: VxeTableDefines.CellRenderBodyParams, prevRow: any) {
-  const { $table, row } = params
-  const tableProps = $table.props
-  const tableReactData = $table.reactData
-  const tableInternalData = $table.internalData
-
-  const { showOverflow } = tableProps
-  const { scrollYLoad } = tableReactData
-  const { fullAllDataRowIdData } = tableInternalData
-  const { computeRowOpts, computeCellOpts, computeDefaultRowHeight } = $table.getComputeMaps()
-  const rowOpts = computeRowOpts.value
-  const cellOpts = computeCellOpts.value
-  const defaultRowHeight = computeDefaultRowHeight.value
-  const rowid = getRowid($table, row)
-  const rowRest = fullAllDataRowIdData[rowid]
-  const currCellHeight = rowRest.resizeHeight || cellOpts.height || rowOpts.height || rowRest.height || defaultRowHeight
-  let expandSize = 1
-  if (prevRow) {
-    expandSize = countTreeExpandSize(prevRow, params)
-  }
-  let cellHeight = currCellHeight
-  const vnHeight = rowRest.height
-  if (scrollYLoad) {
-    if (!showOverflow) {
-      cellHeight = vnHeight || currCellHeight
-    }
-  }
-  return cellHeight * expandSize - (prevRow ? 1 : (12 - getOffsetSize($table)))
-}
-
 export function clearTableDefaultStatus ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
   const { props, internalData } = $xeTable
 

package/packages/ui/index.ts

@@ -178,7 +178,8 @@ VxeUI.setConfig({
       hasChildField: 'hasChild',
       mapChildrenField: '_X_ROW_CHILD',
       indent: 20,
-      showIcon: true
+      showIcon: true,
+      showRootLine: true
     },
     expandConfig: {
       // trigger: 'default',

package/packages/ui/src/dom.ts

@@ -140,6 +140,24 @@ export function updateCellTitle (overflowElem: any, column: any) {
   }
 }
 
+export function checkTargetElement (target: HTMLElement | EventTarget | null, exEls: (HTMLElement | null)[], endEl?: HTMLElement | EventTarget | null) {
+  let targetEl = target
+  if (!exEls || !exEls.length) {
+    return false
+  }
+  const [exEl1, exEl2, exEl3] = exEls
+  while (targetEl) {
+    if (exEl1 === targetEl || (exEl2 && targetEl === exEl2) || (exEl3 && targetEl === exEl3)) {
+      return true
+    }
+    if (endEl && targetEl === endEl) {
+      return false
+    }
+    targetEl = (targetEl as HTMLElement).parentElement
+  }
+  return false
+}
+
 /**
  * 检查触发源是否属于目标节点
  */

package/styles/components/table.scss

@@ -2223,16 +2223,28 @@ $btnThemeList: (
       left: 50%;
       font-size: 12px;
       line-height: 1em;
-      transform: translate(-50%, -50%);
+      transform: translate(-50%, -2px);
       text-align: left;
       z-index: 4;
       padding: 0 var(--vxe-ui-table-cell-padding-default);
       pointer-events: none;
     }
     .vxe-cell--valid-error-wrapper {
+      position: relative;
       display: inline-block;
       border-radius: var(--vxe-ui-border-radius);
       pointer-events: auto;
+      // &::before {
+      //   content: "";
+      //   position: absolute;
+      //   top: -0.75em;
+      //   left: 50%;
+      //   bottom: auto;
+      //   transform: translateX(-50%);
+      //   border-width: 0.5em;
+      //   border-style: solid;
+      //   border-color: transparent transparent var(--vxe-ui-table-validate-error-color) transparent;
+      // }
     }
     .vxe-cell--valid-error-theme-beautify {
       padding: 0.2em 0.6em 0.25em 0.6em;
@@ -2267,12 +2279,26 @@ $btnThemeList: (
       &:last-child {
         .vxe-cell--valid-error-tip {
           bottom: calc(100%);
-          transform: translate(-50%, 50%);
+          transform: translate(-50%, 0);
+          // .vxe-cell--valid-error-wrapper {
+          //   &::before {
+          //     bottom: -0.75em;
+          //     top: auto;
+          //     border-color: var(--vxe-ui-table-validate-error-color) transparent transparent transparent;
+          //   }
+          // }
         }
         &:first-child {
           .vxe-cell--valid-error-tip {
             bottom: auto;
-            transform: translate(-50%, -50%);
+            transform: translate(-50%, -2px);
+            // .vxe-cell--valid-error-wrapper {
+            //   &::before {
+            //     top: -0.75em;
+            //     bottom: auto;
+            //     border-color: transparent transparent var(--vxe-ui-table-validate-error-color) transparent;
+            //   }
+            // }
           }
         }
       }
@@ -2308,6 +2334,11 @@ $btnThemeList: (
             background-color: #f56c6c;
             pointer-events: auto;
           }
+          // .vxe-cell--valid-error-wrapper {
+          //   &::before {
+          //     display: none;
+          //   }
+          // }
         }
       }
     }