vxe-table 3.21.12 → 3.21.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vxe-table",
-  "version": "3.21.12",
+  "version": "3.21.14",
   "description": "A PC-end table component based on Vxe UI, supporting copy-paste, data pivot table, and high-performance virtual list table solution.",
   "scripts": {
     "update": "npm install --legacy-peer-deps",
@@ -68,7 +68,7 @@
     "vue-i18n": "^8.15.1",
     "vue-router": "^3.5.1",
     "vue-template-compiler": "2.6.14",
-    "vxe-pc-ui": "3.14.35"
+    "vxe-pc-ui": "3.14.36"
   },
   "vetur": {
     "tags": "helper/vetur/tags.json",

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

@@ -80,7 +80,7 @@ function insertTreeRow ($xeTable: VxeTableConstructor & VxeTablePrivateMethods,
       }
       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 }
+      const rest = { row: item, rowid, _seq: -1, 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 {
@@ -89,7 +89,7 @@ function insertTreeRow ($xeTable: VxeTableConstructor & VxeTablePrivateMethods,
       }
       afterFullData[funcName](item)
       tableFullTreeData[funcName](item)
-      const rest = { row: item, rowid, seq: -1, index: -1, _index: -1, $index: -1, treeIndex: -1, _tIndex: -1, items: tableFullTreeData, parent: null, level: 0, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 }
+      const rest = { row: item, rowid, _seq: -1, seq: -1, index: -1, _index: -1, $index: -1, treeIndex: -1, _tIndex: -1, items: tableFullTreeData, parent: null, level: 0, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 }
       fullDataRowIdData[rowid] = rest
       fullAllDataRowIdData[rowid] = rest
     }
@@ -144,7 +144,7 @@ function handleInsertRowAt ($xeTable: VxeTableConstructor & VxeTablePrivateMetho
     } else {
       newRecords.forEach(item => {
         const rowid = getRowid($xeTable, item)
-        const rest = { row: item, rowid, seq: -1, index: -1, _index: -1, $index: -1, treeIndex: -1, _tIndex: -1, items: afterFullData, parent: null, level: 0, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 }
+        const rest = { row: item, rowid, _seq: -1, seq: -1, index: -1, _index: -1, $index: -1, treeIndex: -1, _tIndex: -1, items: afterFullData, parent: null, level: 0, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 }
         fullDataRowIdData[rowid] = rest
         fullAllDataRowIdData[rowid] = rest
         afterFullData.unshift(item)
@@ -173,7 +173,7 @@ function handleInsertRowAt ($xeTable: VxeTableConstructor & VxeTablePrivateMetho
       } else {
         newRecords.forEach(item => {
           const rowid = getRowid($xeTable, item)
-          const rest = { row: item, rowid, seq: -1, index: -1, _index: -1, $index: -1, treeIndex: -1, _tIndex: -1, items: afterFullData, parent: null, level: 0, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 }
+          const rest = { row: item, rowid, _seq: -1, seq: -1, index: -1, _index: -1, $index: -1, treeIndex: -1, _tIndex: -1, items: afterFullData, parent: null, level: 0, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 }
           fullDataRowIdData[rowid] = rest
           fullAllDataRowIdData[rowid] = rest
           afterFullData.push(item)
@@ -211,7 +211,7 @@ function handleInsertRowAt ($xeTable: VxeTableConstructor & VxeTablePrivateMetho
           })
           XEUtils.eachTree(treeRecords, (item) => {
             const rowid = getRowid($xeTable, item)
-            const rest = { row: item, rowid, seq: -1, index: -1, _index: -1, $index: -1, treeIndex: -1, _tIndex: -1, items: parentMapChilds, parent: parentRow, level: parentLevel + 1, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 }
+            const rest = { row: item, rowid, _seq: -1, seq: -1, index: -1, _index: -1, $index: -1, treeIndex: -1, _tIndex: -1, items: parentMapChilds, parent: parentRow, level: parentLevel + 1, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 }
             if (item[childrenField]) {
               item[mapChildrenField] = item[childrenField]
             }

package/packages/table/module/menu/panel.ts

@@ -61,7 +61,7 @@ export default /* define-vxe-component start */ defineVxeComponent({
           return options.every((item) => item.visible === false)
             ? renderEmptyElement($xeTable)
             : h('ul', {
-              class: 'vxe-context-menu--option-wrapper',
+              class: 'vxe-table--context-menu-group-wrapper',
               key: gIndex
             }, options.map((item, index) => {
               const { children, loading } = item
@@ -74,7 +74,7 @@ export default /* define-vxe-component start */ defineVxeComponent({
               return item.visible === false
                 ? renderEmptyElement($xeTable)
                 : h('li', {
-                  class: [item.className, {
+                  class: ['vxe-table--context-menu--option', item.className, {
                     'link--loading': loading,
                     'link--disabled': item.disabled,
                     'link--active': item === ctxMenuStore.selected
@@ -128,12 +128,12 @@ export default /* define-vxe-component start */ defineVxeComponent({
                       suffixOpts.content ? h('span', `${suffixOpts.content}`) : renderEmptyElement($xeTable)
                     ])
                   ]),
-                  hasChildMenus && item.children
+                  hasChildMenus && children
                     ? h('ul', {
                       class: ['vxe-table--context-menu-clild-wrapper', {
                         'is--show': item === ctxMenuStore.selected && ctxMenuStore.showChild
                       }]
-                    }, item.children.map((child, cIndex) => {
+                    }, children.map((child, cIndex) => {
                       const { loading: childLoading } = child
                       const childPrefixOpts = Object.assign({}, child.prefixConfig)
                       const childPrefixIcon = childPrefixOpts.icon || child.prefixIcon
@@ -143,7 +143,7 @@ export default /* define-vxe-component start */ defineVxeComponent({
                       return child.visible === false
                         ? null
                         : h('li', {
-                          class: [child.className, {
+                          class: ['vxe-table--context-menu--option', child.className, {
                             'link--loading': childLoading,
                             'link--disabled': child.disabled,
                             'link--active': child === ctxMenuStore.selectChild

package/packages/table/src/methods.ts

@@ -453,7 +453,11 @@ function updateScrollYStatus ($xeTable: VxeTableConstructor & VxeTablePrivateMet
   const { transform } = treeOpts
   const allList = fullData || internalData.tableFullData
   // 如果gt为0，则总是启用
-  const scrollYLoad = (transform || !treeConfig) && !!virtualYOpts.enabled && virtualYOpts.gt > -1 && (virtualYOpts.gt === 0 || virtualYOpts.gt < allList.length)
+  let scrollYLoad = !!virtualYOpts.enabled && virtualYOpts.gt > -1 && (virtualYOpts.gt === 0 || virtualYOpts.gt < allList.length)
+  if (scrollYLoad && (treeConfig && !transform)) {
+    errLog('vxe.error.notSupportProp', ['[table] virtual-y-config.enabled=true', 'tree-config.transform=false', 'tree-config.transform=true'])
+    scrollYLoad = false
+  }
   reactData.scrollYLoad = scrollYLoad
   syncGanttScrollYStatus($xeTable)
   return scrollYLoad
@@ -650,28 +654,66 @@ function handleDefaultRowGroupExpand ($xeTable: VxeTableConstructor & VxeTablePr
   }
 }
 
+function updateAfterTreeIndex ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
+  const internalData = $xeTable as unknown as TableInternalData
+
+  const { fullDataRowIdData, fullAllDataRowIdData, afterFullData, afterTreeFullData } = internalData
+  const treeOpts = $xeTable.computeTreeOpts
+  const { transform, mapChildrenField } = treeOpts
+  const childrenField = treeOpts.children || treeOpts.childrenField
+  const fullMaps: Record<string, any> = {}
+  let rowNum = 0
+  const { handleGetRowId } = createHandleGetRowId($xeTable)
+  XEUtils.eachTree(afterTreeFullData, (row, index, items, path) => {
+    const rowid = handleGetRowId(row)
+    const rowRest = fullAllDataRowIdData[rowid]
+    const seq = path.map((num, i) => i % 2 === 0 ? (Number(num) + 1) : '.').join('')
+    if (rowRest) {
+      rowRest.seq = seq
+      rowRest._seq = rowNum
+      rowRest.treeIndex = index
+      rowRest._tIndex = rowNum
+    } else {
+      const rest = { row, rowid, _seq: rowNum, seq, index: -1, $index: -1, _index: -1, treeIndex: -1, _tIndex: rowNum, items: [], parent: null, level: 0, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 }
+      fullAllDataRowIdData[rowid] = rest
+      fullDataRowIdData[rowid] = rest
+    }
+    rowNum++
+    fullMaps[rowid] = row
+  }, { children: transform ? mapChildrenField : childrenField })
+  if (transform) {
+    afterFullData.forEach((row, index) => {
+      const rowid = handleGetRowId(row)
+      const rowRest = fullAllDataRowIdData[rowid]
+      if (rowRest) {
+        rowRest._index = index
+      }
+    })
+  }
+  internalData.afterFullRowMaps = fullMaps
+}
+
 function updateAfterListIndex ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
-  const props = $xeTable
   const internalData = $xeTable as unknown as TableInternalData
 
-  const { treeConfig } = props
   const { afterFullData, fullDataRowIdData, fullAllDataRowIdData } = internalData
   const { handleGetRowId } = createHandleGetRowId($xeTable)
   const fullMaps: Record<string, any> = {}
+  let rowNum = 0
   afterFullData.forEach((row, index) => {
     const rowid = handleGetRowId(row)
     const rowRest = fullAllDataRowIdData[rowid]
     const seq = index + 1
     if (rowRest) {
-      if (!treeConfig) {
-        rowRest.seq = seq
-      }
+      rowRest.seq = seq
+      rowRest._seq = rowNum
       rowRest._index = index
     } else {
-      const rest = { row, rowid, seq, index: -1, $index: -1, _index: index, treeIndex: -1, _tIndex: -1, items: [], parent: null, level: 0, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 }
+      const rest = { row, rowid, _seq: rowNum, seq, index: -1, $index: -1, _index: index, treeIndex: -1, _tIndex: -1, items: [], parent: null, level: 0, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 }
       fullAllDataRowIdData[rowid] = rest
       fullDataRowIdData[rowid] = rest
     }
+    rowNum++
     fullMaps[rowid] = row
   })
   internalData.afterFullRowMaps = fullMaps
@@ -683,47 +725,10 @@ function updateAfterListIndex ($xeTable: VxeTableConstructor & VxeTablePrivateMe
  */
 function updateAfterDataIndex ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
   const props = $xeTable
-  const internalData = $xeTable as unknown as TableInternalData
 
   const { treeConfig } = props
-  const { fullDataRowIdData, fullAllDataRowIdData, afterFullData, afterTreeFullData } = internalData
-  const treeOpts = $xeTable.computeTreeOpts
-  const { transform } = treeOpts
-  const childrenField = treeOpts.children || treeOpts.childrenField
-  const fullMaps: Record<string, any> = {}
   if (treeConfig) {
-    let _treeIndex = 0
-    const { handleGetRowId } = createHandleGetRowId($xeTable)
-    XEUtils.eachTree(afterTreeFullData, (row, index, items, path) => {
-      const rowid = handleGetRowId(row)
-      const rowRest = fullAllDataRowIdData[rowid]
-      const seq = path.map((num, i) => i % 2 === 0 ? (Number(num) + 1) : '.').join('')
-      if (rowRest) {
-        rowRest.seq = seq
-        rowRest.treeIndex = index
-        rowRest._tIndex = _treeIndex
-      } else {
-        const rest = { row, rowid, seq, index: -1, $index: -1, _index: -1, treeIndex: -1, _tIndex: _treeIndex, items: [], parent: null, level: 0, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 }
-        fullAllDataRowIdData[rowid] = rest
-        fullDataRowIdData[rowid] = rest
-      }
-      _treeIndex++
-      fullMaps[rowid] = row
-    }, { children: transform ? treeOpts.mapChildrenField : childrenField })
-    if (transform) {
-      afterFullData.forEach((row, index) => {
-        const rowid = handleGetRowId(row)
-        const rowRest = fullAllDataRowIdData[rowid]
-        const seq = index + 1
-        if (rowRest) {
-          if (!treeConfig) {
-            rowRest.seq = seq
-          }
-          rowRest._index = index
-        }
-      })
-    }
-    internalData.afterFullRowMaps = fullMaps
+    updateAfterTreeIndex($xeTable)
   } else {
     updateAfterListIndex($xeTable)
   }
@@ -3195,12 +3200,15 @@ function handleRecalculateStyle ($xeTable: VxeTableConstructor & VxeTablePrivate
   })
 }
 
-const minRunDelay = 50
+const defaultMinRunDelay = 50
 
-function handleLazyRecalculate ($xeTable: VxeTableConstructor & VxeTablePrivateMethods, reFull: boolean, reWidth: boolean, reHeight: boolean) {
+function handleLazyRecalculate ($xeTable: VxeTableConstructor & VxeTablePrivateMethods, reFull: boolean, reWidth: boolean, reHeight: boolean, options?: {
+  minRunDelay?: number // 多少毫秒内至少执行一次
+}) {
   const reactData = $xeTable as unknown as TableReactData
   const internalData = $xeTable as unknown as TableInternalData
 
+  const minRunDelay = (options ? options.minRunDelay : defaultMinRunDelay) || defaultMinRunDelay
   return new Promise<void>(resolve => {
     const { customStore } = reactData
     const { rceTimeout, rceRunTime } = internalData
@@ -3226,6 +3234,7 @@ function handleLazyRecalculate ($xeTable: VxeTableConstructor & VxeTablePrivateM
     }
     if (rceTimeout) {
       clearTimeout(rceTimeout)
+      // 多少毫秒内至少执行一次
       if (rceRunTime && rceRunTime + minRunDelay < Date.now()) {
         resolve(
           handleRecalculateStyle($xeTable, reFull, reWidth, reHeight)
@@ -3251,7 +3260,19 @@ function handleLazyRecalculate ($xeTable: VxeTableConstructor & VxeTablePrivateM
 }
 
 function handleResizeEvent ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
-  handleLazyRecalculate($xeTable, true, true, true)
+  const internalData = $xeTable as unknown as TableInternalData
+
+  if (internalData.rsePending) {
+    return
+  }
+  internalData.rsePending = true
+  handleLazyRecalculate($xeTable, true, true, true, {
+    minRunDelay: 200
+  }).then(() => {
+    internalData.rsePending = false
+  }).catch(() => {
+    internalData.rsePending = false
+  })
 }
 
 function handleUpdateAggValues ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
@@ -5122,17 +5143,19 @@ const tableMethods: any = {
 
     const idMaps: Record<string, boolean> = {}
     const { handleUpdateRowId } = createHandleUpdateRowId($xeTable)
+    let rowNum = 0
     const handleRowCache = (row: any, index: number, items: any, currIndex: number, parentRow: any, rowid: string, level: number, seq: string | number) => {
       let rowRest = fullAllDataRowIdMaps[rowid]
       if (idMaps[rowid]) {
         errLog('vxe.error.repeatKey', [currKeyField, rowid])
       }
       if (!rowRest) {
-        rowRest = { row, rowid, seq, index: -1, _index: -1, $index: -1, treeIndex: index, _tIndex: -1, items, parent: parentRow, level, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 }
+        rowRest = { row, rowid, _seq: -1, seq, index: -1, _index: -1, $index: -1, treeIndex: index, _tIndex: -1, items, parent: parentRow, level, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 }
       }
       rowRest.treeLoaded = false
       rowRest.expandLoaded = false
 
+      rowRest._seq = rowNum++
       rowRest.row = row
       rowRest.items = items
       rowRest.parent = parentRow
@@ -5160,7 +5183,7 @@ const tableMethods: any = {
       const hasChildField = treeOpts.hasChild || treeOpts.hasChildField
       XEUtils.eachTree(tableFullTreeData, (row, index, items, path, parentRow, nodes) => {
         const rowid = handleUpdateRowId(row)
-        if (treeConfig && lazy) {
+        if (lazy) {
           if (row[hasChildField] && row[childrenField] === undefined) {
             row[childrenField] = null
           }
@@ -5246,7 +5269,7 @@ const tableMethods: any = {
       XEUtils.eachTree(rows, (childRow, index, items, path, parentItem, nodes) => {
         const rowid = getRowid($xeTable, childRow)
         const parentRow = parentItem || parentRest.row
-        const rest = { row: childRow, rowid, seq: -1, index, _index: -1, $index: -1, treeIndex: -1, _tIndex: -1, items, parent: parentRow, level: parentLevel + nodes.length, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 }
+        const rest = { row: childRow, rowid, _seq: -1, seq: -1, index, _index: -1, $index: -1, treeIndex: -1, _tIndex: -1, items, parent: parentRow, level: parentLevel + nodes.length, height: 0, resizeHeight: 0, oTop: 0, expandHeight: 0 }
         fullDataRowIdData[rowid] = rest
         fullAllDataRowIdData[rowid] = rest
       }, { children: childrenField })
@@ -8743,31 +8766,162 @@ const tableMethods: any = {
     const { treeConfig } = props
     const { row } = params
     const { isRowGroupStatus } = reactData
-    const { afterFullData } = internalData
+    const { fullAllDataRowIdData, afterFullData, afterTreeFullData, afterGroupFullData } = internalData
     const checkboxOpts = $xeTable.computeCheckboxOpts
-    const { checkMethod, trigger } = checkboxOpts
+    const aggregateOpts = $xeTable.computeAggregateOpts
+    const treeOpts = $xeTable.computeTreeOpts
+    const { checkMethod, trigger, checkStrictly } = checkboxOpts
     if (trigger === 'manual') {
       return
     }
     evnt.stopPropagation()
-    if (checkboxOpts.isShiftKey && evnt.shiftKey && !(treeConfig || isRowGroupStatus)) {
+
+    if (checkboxOpts.isShiftKey && evnt.shiftKey) {
+      const { handleGetRowId } = createHandleGetRowId($xeTable)
       const checkboxRecords = $xeTable.getCheckboxRecords()
-      if (checkboxRecords.length) {
-        const firstRow = checkboxRecords[0]
-        const _rowIndex = $xeTable.getVTRowIndex(row)
-        const _firstRowIndex = $xeTable.getVTRowIndex(firstRow)
-        if (_rowIndex !== _firstRowIndex) {
+      let currSeq = -1
+      let currRow: any = null
+      const currRowid = handleGetRowId(row)
+      const rowRest = fullAllDataRowIdData[currRowid]
+      if (rowRest) {
+        currRow = rowRest.row
+        currSeq = rowRest._seq
+      }
+      if (currRow && checkboxRecords.length) {
+        let rangeRows: any[] = []
+        let firstSeq = -1
+        let firstRow: any = null
+        let firstRowid = ''
+        let lastSeq = -1
+        let lastRow: any = null
+        let lastRowid = ''
+        // 根据序号取出范围最小/最大的行
+        const selectMaps: Record<string, any> = {}
+        checkboxRecords.forEach(item => {
+          const rowid = handleGetRowId(item)
+          const rowRest = fullAllDataRowIdData[rowid]
+          if (rowRest) {
+            if (!firstRow || firstSeq > rowRest._seq) {
+              firstRowid = rowRest.rowid
+              firstRow = rowRest.row
+              firstSeq = rowRest._seq
+            }
+            if (!lastRow || lastSeq < rowRest._seq) {
+              lastRowid = rowRest.rowid
+              lastRow = rowRest.row
+              lastSeq = rowRest._seq
+            }
+          }
+          selectMaps[rowid] = item
+        })
+        // 如果已选只有一条并选择当前则跳过
+        if (firstRow && lastRow && (checkboxRecords.length > 1 || currRowid !== firstRowid) && (Math.abs(firstSeq - lastSeq) > 1 || Math.abs(currSeq - firstSeq) > 1 || Math.abs(currSeq - lastSeq) > 1)) {
+          // 树与分组
+          if (treeConfig || isRowGroupStatus) {
+            const { transform } = treeOpts
+            const childrenField = treeOpts.children || treeOpts.childrenField
+            const iteratorChildField = treeConfig ? (transform ? treeOpts.mapChildrenField : childrenField) : aggregateOpts.mapChildrenField as string
+            let isMatchFirst = false
+            let matchStartRowid = ''
+            let matchEndRowid = ''
+
+            const handleGetChildRowid = (rowid: string, isLast: 0 | 1): string => {
+              const rowRest = fullAllDataRowIdData[rowid]
+              if (rowRest) {
+                const item = rowRest.row
+                const childList = item[iteratorChildField]
+                if (childList && childList.length) {
+                  const targetRow = isLast ? XEUtils.last(childList) : XEUtils.first(childList)
+                  return handleGetChildRowid(handleGetRowId(targetRow), isLast)
+                }
+              }
+              return rowid
+            }
+
+            const handleGetSelectParentRowid = (rowid: string): string => {
+              const rowRest = fullAllDataRowIdData[rowid]
+              if (rowRest) {
+                const parentItem = rowRest.parent
+                if (parentItem) {
+                  const parentRowid = handleGetRowId(parentItem)
+                  if (selectMaps[parentRowid]) {
+                    return handleGetSelectParentRowid(parentRowid)
+                  }
+                }
+              }
+              return rowid
+            }
+
+            const handleGetRootRow = (row: string): VxeTableDefines.RowCacheItem | null => {
+              const rowid = handleGetRowId(row)
+              if (rowid) {
+                const rest = fullAllDataRowIdData[rowid]
+                if (rest) {
+                  return rest.parent ? handleGetRootRow(rest.parent) : rest
+                }
+              }
+              return null
+            }
+
+            if (currSeq < firstSeq) {
+              matchStartRowid = handleGetChildRowid(currRowid, 0)
+              matchEndRowid = handleGetChildRowid(firstRowid, 1)
+            } else {
+              if (currSeq > lastSeq) {
+                matchStartRowid = handleGetSelectParentRowid(lastRowid)
+              } else {
+                matchStartRowid = handleGetChildRowid(firstRowid, 0)
+              }
+              matchEndRowid = handleGetChildRowid(currRowid, 1)
+            }
+
+            const handleRangeRow = (item: any) => {
+              const rowid = handleGetRowId(item)
+              const childList = item[iteratorChildField]
+              if (!isMatchFirst && rowid === matchStartRowid) {
+                isMatchFirst = true
+              }
+              // 如果是父子关联，则排除父节点
+              if (isMatchFirst && (checkStrictly || !childList || !childList.length)) {
+                rangeRows.push(item)
+              }
+              // break
+              return rowid === matchEndRowid
+            }
+            if (treeConfig) {
+              const matchStartRowRest = fullAllDataRowIdData[matchStartRowid]
+              const firstRootRowRest = matchStartRowRest ? handleGetRootRow(matchStartRowRest.row) : null
+              if (firstRootRowRest) {
+                // 优化查找复杂度
+                XEUtils.findTree(afterTreeFullData.slice(firstRootRowRest.treeIndex), handleRangeRow, { children: iteratorChildField })
+              } else {
+                XEUtils.findTree(afterTreeFullData, handleRangeRow, { children: iteratorChildField })
+              }
+            } else {
+              XEUtils.findTree(afterGroupFullData, handleRangeRow, { children: iteratorChildField })
+            }
+          } else {
+            const _currRowIndex = $xeTable.getVTRowIndex(currRow)
+            const _firstRowIndex = $xeTable.getVTRowIndex(firstRow)
+            const _lastRowIndex = $xeTable.getVTRowIndex(lastRow)
+            if (_currRowIndex < _firstRowIndex) {
+              rangeRows = afterFullData.slice(_currRowIndex, _firstRowIndex + 1)
+            } else if (_currRowIndex > _lastRowIndex) {
+              rangeRows = afterFullData.slice(_lastRowIndex, _currRowIndex + 1)
+            } else {
+              rangeRows = afterFullData.slice(_firstRowIndex, _currRowIndex + 1)
+            }
+          }
           $xeTable.setAllCheckboxRow(false)
-          const rangeRows = _rowIndex < _firstRowIndex ? afterFullData.slice(_rowIndex, _firstRowIndex + 1) : afterFullData.slice(_firstRowIndex, _rowIndex + 1)
           $xeTable.$nextTick(() => {
             handleCheckedCheckboxRow($xeTable, rangeRows, true, false)
           })
           $xeTable.dispatchEvent('checkbox-range-select', Object.assign({ rangeRecords: rangeRows }, params), evnt)
-          return
         }
       }
     }
-    if (isRowGroupStatus || !checkMethod || checkMethod({ $table: $xeTable, row })) {
+
+    if (!checkMethod || checkMethod({ $table: $xeTable, row })) {
       $xeTable.handleBatchSelectRows([row], checked)
       $xeTable.checkSelectionStatus()
       $xeTable.dispatchEvent('checkbox-change', Object.assign({

package/packages/table/src/table.ts

@@ -1348,22 +1348,32 @@ export default {
       const { tableFullColumn } = internalData
       const { updateColFlag } = reactData
       const editDirtyOpts = $xeTable.computeEditDirtyOpts
-      const { includeFields, excludeFields } = editDirtyOpts
+      const { extraFields, includeFields, excludeFields } = editDirtyOpts
       const kpFields: string[] = []
       if (updateColFlag) {
         if (includeFields && includeFields.length) {
           return includeFields
         }
-        const exfMaps: Record<string, number> = {}
+        const excludeFdMaps: Record<string, number> = {}
         if (excludeFields && excludeFields.length) {
           excludeFields.forEach(field => {
-            exfMaps[field] = 1
+            excludeFdMaps[field] = 1
+          })
+        }
+        const addFdMaps: Record<string, number> = {}
+        if (extraFields && extraFields.length) {
+          extraFields.forEach(field => {
+            if (!addFdMaps[field]) {
+              addFdMaps[field] = 1
+              kpFields.push(field)
+            }
           })
         }
         for (let i = 0; i < tableFullColumn.length; i++) {
           const column = tableFullColumn[i]
           const { field, type, editRender, cellRender } = column
-          if (field && !type && (editRender || cellRender) && !exfMaps[field]) {
+          if (field && !type && (editRender || cellRender) && !addFdMaps[field] && !excludeFdMaps[field]) {
+            addFdMaps[field] = 1
             kpFields.push(field)
           }
         }
@@ -1862,9 +1872,6 @@ export default {
     if (props.editConfig && editOpts.activeMethod) {
       warnLog('vxe.error.delProp', ['table.edit-config.activeMethod', 'table.edit-config.beforeEditMethod'])
     }
-    if (props.treeConfig && checkboxOpts.isShiftKey) {
-      errLog('vxe.error.errConflicts', ['tree-config', 'checkbox-config.isShiftKey'])
-    }
     if (checkboxOpts.halfField) {
       warnLog('vxe.error.delProp', ['checkbox-config.halfField', 'checkbox-config.indeterminateField'])
     }

package/styles/components/table-module/menu.scss

@@ -18,13 +18,16 @@
   font-family: var(--vxe-ui-font-family);
   background-color: var(--vxe-ui-layout-background-color);
 }
+.vxe-context-menu--option {
+  color: var(--vxe-ui-font-color);
+}
 .vxe-context-menu--link {
   display: flex;
   flex-direction: row;
   width: var(--vxe-ui-table-menu-item-width);
   line-height: 26px;
   padding: 0 0.8em;
-  color: var(--vxe-ui-font-color);
+  color: inherit;
   cursor: pointer;
   .vxe-context-menu--link-prefix,
   .vxe-context-menu--link-suffix {
@@ -41,7 +44,7 @@
     white-space: nowrap;
   }
 }
-.vxe-context-menu--option-wrapper,
+.vxe-table--context-menu-group-wrapper,
 .vxe-table--context-menu-clild-wrapper {
   margin: 0;
   padding: 0;