@fecp/mobile 1.1.45 → 1.1.46

package/lib/node_modules/.pnpm/vxe-table@4.17.0_vue@3.5.13_typescript@5.7.3_/node_modules/vxe-table/es/table/src/body.js

@@ -0,0 +1,800 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const comp = require("../../ui/src/comp.js");
+const index = require("../../../../../../../../_virtual/index.js");
+require("../../ui/index.js");
+const util = require("./util.js");
+const dom = require("../../ui/src/dom.js");
+const utils = require("../../ui/src/utils.js");
+const vn = require("../../ui/src/vn.js");
+const index_esm = require("../../../../../../@vxe-ui_core@4.2.12_vue@3.5.13_typescript@5.7.3_/node_modules/@vxe-ui/core/es/index.esm.js");
+const { getI18n, renderer, renderEmptyElement } = index_esm.VxeUI;
+const sourceType = "table";
+const renderType = "body";
+const TableBodyComponent = comp.defineVxeComponent({
+  name: "VxeTableBody",
+  props: {
+    tableData: Array,
+    tableColumn: Array,
+    fixedColumn: Array,
+    fixedType: {
+      type: String,
+      default: ""
+    }
+  },
+  setup(props) {
+    const $xeTable = vue.inject("$xeTable", {});
+    const { xID, props: tableProps, context: tableContext, reactData: tableReactData, internalData: tableInternalData } = $xeTable;
+    const { computeEditOpts, computeMouseOpts, computeCellOffsetWidth, computeAreaOpts, computeDefaultRowHeight, computeEmptyOpts, computeTooltipOpts, computeRadioOpts, computeExpandOpts, computeTreeOpts, computeCheckboxOpts, computeCellOpts, computeValidOpts, computeRowOpts, computeColumnOpts, computeRowDragOpts, computeResizableOpts, computeVirtualXOpts, computeVirtualYOpts } = $xeTable.getComputeMaps();
+    const refElem = vue.ref();
+    const refBodyScroll = vue.ref();
+    const refBodyTable = vue.ref();
+    const refBodyColgroup = vue.ref();
+    const refBodyTBody = vue.ref();
+    const refBodyXSpace = vue.ref();
+    const refBodyYSpace = vue.ref();
+    const refBodyEmptyBlock = vue.ref();
+    const isVMScrollProcess = () => {
+      const { delayHover } = tableProps;
+      const { lastScrollTime, isDragResize } = tableReactData;
+      return !!(isDragResize || lastScrollTime && Date.now() < lastScrollTime + delayHover);
+    };
+    const renderLine = (rowid, params, cellHeight) => {
+      const { column } = params;
+      const { afterFullData } = tableInternalData;
+      const { treeConfig } = tableProps;
+      const treeOpts = computeTreeOpts.value;
+      const { slots, treeNode } = column;
+      const { fullAllDataRowIdData } = tableInternalData;
+      if (slots && slots.line) {
+        return $xeTable.callSlot(slots.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)) {
+        return [
+          vue.h("div", {
+            key: "tl",
+            class: "vxe-tree--line-wrapper"
+          }, [
+            vue.h("div", {
+              class: "vxe-tree--line",
+              style: {
+                height: `${util.getRowid($xeTable, afterFullData[0]) === rowid ? 1 : util.calcTreeLine(params, prevRow)}px`,
+                bottom: `-${Math.floor(cellHeight / 2)}px`,
+                left: `${rLevel * treeOpts.indent + (rLevel ? 2 - util.getOffsetSize($xeTable) : 0) + 16}px`
+              }
+            })
+          ])
+        ];
+      }
+      return [];
+    };
+    const renderTdColumn = (seq, rowid, fixedType, isOptimizeMode, rowLevel, row, rowIndex, $rowIndex, _rowIndex, column, $columnIndex, columns, items) => {
+      const $xeGrid = $xeTable.xeGrid;
+      const $xeGantt = $xeTable.xeGantt;
+      const { columnKey, resizable: allResizable, showOverflow: allShowOverflow, border, height, treeConfig, cellClassName: allCellClassName, cellStyle, align: allAlign, spanMethod, mouseConfig, editConfig, editRules, tooltipConfig, padding: allPadding } = tableProps;
+      const { tableData, tableColumn, dragRow, overflowX, overflowY, currentColumn, scrollXLoad, scrollYLoad, mergeBodyFlag, calcCellHeightFlag, resizeHeightFlag, resizeWidthFlag, editStore, isAllOverflow, validErrorMaps } = tableReactData;
+      const { fullAllDataRowIdData, fullColumnIdData, mergeBodyCellMaps, visibleColumn, afterFullData, mergeBodyList, scrollXStore, scrollYStore } = tableInternalData;
+      const cellOpts = computeCellOpts.value;
+      const validOpts = computeValidOpts.value;
+      const checkboxOpts = computeCheckboxOpts.value;
+      const editOpts = computeEditOpts.value;
+      const tooltipOpts = computeTooltipOpts.value;
+      const resizableOpts = computeResizableOpts.value;
+      const virtualXOpts = computeVirtualXOpts.value;
+      const virtualYOpts = computeVirtualYOpts.value;
+      const { isAllColumnDrag, isAllRowDrag } = resizableOpts;
+      const rowOpts = computeRowOpts.value;
+      const rowDragOpts = computeRowDragOpts.value;
+      const defaultRowHeight = computeDefaultRowHeight.value;
+      const customCellHeight = calcCellHeightFlag ? cellOpts.height || rowOpts.height : 0;
+      const { disabledMethod: dragDisabledMethod, isCrossDrag, isPeerDrag } = rowDragOpts;
+      const columnOpts = computeColumnOpts.value;
+      const mouseOpts = computeMouseOpts.value;
+      const areaOpts = computeAreaOpts.value;
+      const cellOffsetWidth = computeCellOffsetWidth.value;
+      const { selectCellToRow } = areaOpts;
+      const { type, cellRender, editRender, align, showOverflow, className, treeNode, rowResize, padding, verticalAlign, slots } = column;
+      const { verticalAlign: allVerticalAlign } = cellOpts;
+      const { actived } = editStore;
+      const rowRest = fullAllDataRowIdData[rowid] || {};
+      const colid = column.id;
+      const colRest = fullColumnIdData[colid] || {};
+      const renderOpts = editRender || cellRender;
+      const compConf = renderOpts ? renderer.get(renderOpts.name) : null;
+      const compCellClassName = compConf ? compConf.tableCellClassName || compConf.cellClassName : null;
+      const compCellStyle = compConf ? compConf.tableCellStyle || compConf.cellStyle : "";
+      const showAllTip = tooltipOpts.showAll;
+      const columnIndex = colRest.index;
+      const _columnIndex = colRest._index;
+      const isEdit = utils.isEnableConf(editRender);
+      const resizeHeight = resizeHeightFlag ? rowRest.resizeHeight : 0;
+      let fixedHiddenColumn = overflowX && (fixedType ? column.fixed !== fixedType : !!column.fixed);
+      const isCellPadding = index.default.eqNull(padding) ? allPadding === null ? cellOpts.padding : allPadding : padding;
+      const cellOverflow = index.default.eqNull(showOverflow) ? allShowOverflow : showOverflow;
+      const showEllipsis = cellOverflow === "ellipsis";
+      const showTitle = cellOverflow === "title";
+      const showTooltip = cellOverflow === true || cellOverflow === "tooltip";
+      const hasEllipsis = isAllOverflow || showTitle || showTooltip || showEllipsis;
+      const showResizable = index.default.isBoolean(column.resizable) ? column.resizable : columnOpts.resizable || allResizable;
+      const isCsHeight = !!customCellHeight;
+      const isRsHeight = resizeHeight > 0;
+      let isDirty;
+      const tdOns = {};
+      const cellAlign = align || (compConf ? compConf.tableCellAlign : "") || allAlign;
+      const cellVerticalAlign = index.default.eqNull(verticalAlign) ? allVerticalAlign : verticalAlign;
+      const errorValidItem = validErrorMaps[`${rowid}:${colid}`];
+      const showValidTip = editRules && validOpts.showMessage && (validOpts.message === "default" ? height || tableData.length > 1 : validOpts.message === "inline");
+      const tdAttrs = { colid };
+      const cellParams = {
+        $table: $xeTable,
+        $grid: $xeGrid,
+        $gantt: $xeGantt,
+        isEdit: false,
+        seq,
+        rowid,
+        row,
+        rowIndex,
+        $rowIndex,
+        _rowIndex,
+        column,
+        columnIndex,
+        $columnIndex,
+        _columnIndex,
+        fixed: fixedType,
+        source: sourceType,
+        type: renderType,
+        isHidden: !!fixedHiddenColumn,
+        level: rowLevel,
+        visibleData: afterFullData,
+        data: tableData,
+        items
+      };
+      let isRowDragCell = false;
+      let isDisabledDrag = false;
+      if (rowOpts.drag) {
+        isRowDragCell = rowDragOpts.trigger === "row" || column.dragSort && rowDragOpts.trigger === "cell";
+      }
+      if (isRowDragCell) {
+        isDisabledDrag = !!(dragDisabledMethod && dragDisabledMethod(cellParams));
+      }
+      if (showTitle || showTooltip || showAllTip || tooltipConfig) {
+        tdOns.onMouseover = (evnt) => {
+          if (!isVMScrollProcess()) {
+            if (showTitle) {
+              dom.updateCellTitle(evnt.currentTarget, column);
+            } else if (showTooltip || showAllTip) {
+              $xeTable.triggerBodyTooltipEvent(evnt, cellParams);
+            }
+          }
+          $xeTable.dispatchEvent("cell-mouseenter", Object.assign({ cell: evnt.currentTarget }, cellParams), evnt);
+        };
+      }
+      if (showTooltip || showAllTip || tooltipConfig) {
+        tdOns.onMouseleave = (evnt) => {
+          if (!isVMScrollProcess()) {
+            if (showTooltip || showAllTip) {
+              $xeTable.handleTargetLeaveEvent(evnt);
+            }
+          }
+          $xeTable.dispatchEvent("cell-mouseleave", Object.assign({ cell: evnt.currentTarget }, cellParams), evnt);
+        };
+      }
+      if (isRowDragCell || checkboxOpts.range || mouseConfig) {
+        tdOns.onMousedown = (evnt) => {
+          $xeTable.triggerCellMousedownEvent(evnt, cellParams);
+        };
+      }
+      if (isRowDragCell) {
+        tdOns.onMouseup = $xeTable.triggerCellMouseupEvent;
+      }
+      tdOns.onClick = (evnt) => {
+        $xeTable.triggerCellClickEvent(evnt, cellParams);
+      };
+      tdOns.onDblclick = (evnt) => {
+        $xeTable.triggerCellDblclickEvent(evnt, cellParams);
+      };
+      let isMergeCell = false;
+      let mergeColspan = 1;
+      let mergeRowspan = 1;
+      if (mergeBodyFlag && mergeBodyList.length) {
+        const spanRest = mergeBodyCellMaps[`${_rowIndex}:${_columnIndex}`];
+        if (spanRest) {
+          const { rowspan, colspan } = spanRest;
+          if (!rowspan || !colspan) {
+            return renderEmptyElement($xeTable);
+          }
+          if (rowspan > 1) {
+            isMergeCell = true;
+            mergeRowspan = rowspan;
+            tdAttrs.rowspan = rowspan;
+          }
+          if (colspan > 1) {
+            isMergeCell = true;
+            mergeColspan = colspan;
+            tdAttrs.colspan = colspan;
+          }
+        }
+      } else if (spanMethod) {
+        const { rowspan = 1, colspan = 1 } = spanMethod(cellParams) || {};
+        if (!rowspan || !colspan) {
+          return renderEmptyElement($xeTable);
+        }
+        if (rowspan > 1) {
+          isMergeCell = true;
+          mergeRowspan = rowspan;
+          tdAttrs.rowspan = rowspan;
+        }
+        if (colspan > 1) {
+          isMergeCell = true;
+          mergeColspan = colspan;
+          tdAttrs.colspan = colspan;
+        }
+      }
+      if (fixedHiddenColumn && isMergeCell) {
+        if (tdAttrs.colspan > 1 || tdAttrs.rowspan > 1) {
+          fixedHiddenColumn = false;
+        }
+      }
+      if (!fixedHiddenColumn && editConfig && (editRender || cellRender) && (editOpts.showStatus || editOpts.showUpdateStatus)) {
+        isDirty = $xeTable.isUpdateByRow(row, column.field);
+      }
+      const isVNAutoHeight = !hasEllipsis && (scrollYLoad || scrollXLoad);
+      let cellHeight = util.getCellRestHeight(rowRest, cellOpts, rowOpts, defaultRowHeight);
+      const isLastColumn = $columnIndex === columns.length - 1;
+      const isAutoCellWidth = !column.resizeWidth && (column.minWidth === "auto" || column.width === "auto");
+      let isVNPreEmptyStatus = false;
+      if (!isMergeCell) {
+        if (!dragRow || util.getRowid($xeTable, dragRow) !== rowid) {
+          if (overflowY && scrollYLoad && tableData.length > 16 && !treeConfig && !virtualYOpts.immediate && (_rowIndex < scrollYStore.visibleStartIndex - scrollYStore.preloadSize || _rowIndex > scrollYStore.visibleEndIndex + scrollYStore.preloadSize)) {
+            isVNPreEmptyStatus = true;
+          } else if (overflowX && scrollXLoad && tableColumn.length > 10 && !virtualXOpts.immediate && !column.fixed && (_columnIndex < scrollXStore.visibleStartIndex - scrollXStore.preloadSize || _columnIndex > scrollXStore.visibleEndIndex + scrollXStore.preloadSize)) {
+            isVNPreEmptyStatus = true;
+          }
+        }
+      }
+      if (mergeRowspan > 1) {
+        const mEndRow = afterFullData[_rowIndex + mergeRowspan - 1];
+        if (mEndRow) {
+          const meRowRest = fullAllDataRowIdData[util.getRowid($xeTable, mEndRow)];
+          if (meRowRest) {
+            cellHeight += meRowRest.oTop + util.getCellRestHeight(meRowRest, cellOpts, rowOpts, defaultRowHeight) - rowRest.oTop - util.getCellRestHeight(rowRest, cellOpts, rowOpts, defaultRowHeight);
+          }
+        }
+      }
+      const tcStyle = {};
+      if (hasEllipsis && resizeWidthFlag) {
+        let mergeColWidth = 0;
+        if (mergeColspan > 1) {
+          for (let index2 = 1; index2 < mergeColspan; index2++) {
+            const nextColumn = visibleColumn[columnIndex + index2];
+            if (nextColumn) {
+              mergeColWidth += nextColumn.renderWidth;
+            }
+          }
+        }
+        tcStyle.width = `${column.renderWidth + mergeColWidth - cellOffsetWidth}px`;
+      }
+      if (scrollYLoad || scrollXLoad || hasEllipsis || isCsHeight || isRsHeight) {
+        tcStyle.height = `${cellHeight}px`;
+      } else {
+        tcStyle.minHeight = `${cellHeight}px`;
+      }
+      const tdVNs = [];
+      if (fixedHiddenColumn && isAllOverflow) {
+        tdVNs.push(vue.h("div", {
+          key: "tc",
+          class: ["vxe-cell", {
+            "c--title": showTitle,
+            "c--tooltip": showTooltip,
+            "c--ellipsis": showEllipsis
+          }],
+          style: tcStyle
+        }));
+      } else {
+        if (treeConfig) {
+          tdVNs.push(...renderLine(rowid, cellParams, cellHeight));
+        }
+        tdVNs.push(vue.h("div", {
+          key: "tc",
+          class: ["vxe-cell", {
+            "c--title": showTitle,
+            "c--tooltip": showTooltip,
+            "c--ellipsis": showEllipsis
+          }],
+          style: tcStyle,
+          title: showTitle ? $xeTable.getCellLabel(row, column) : null
+        }, isVNPreEmptyStatus ? [] : [
+          vue.h("div", {
+            colid,
+            rowid,
+            class: "vxe-cell--wrapper vxe-body-cell--wrapper"
+          }, column.renderCell(cellParams))
+        ]));
+        if (showValidTip && errorValidItem) {
+          const errRule = errorValidItem.rule;
+          const validSlot = slots ? slots.valid : null;
+          const validParams = Object.assign(Object.assign(Object.assign({}, cellParams), errorValidItem), { rule: errorValidItem });
+          tdVNs.push(vue.h("div", {
+            key: "tcv",
+            class: ["vxe-cell--valid-error-tip", dom.getPropClass(validOpts.className, validParams)],
+            style: errRule && errRule.maxWidth ? {
+              width: `${errRule.maxWidth}px`
+            } : null
+          }, [
+            vue.h("div", {
+              class: `vxe-cell--valid-error-wrapper vxe-cell--valid-error-theme-${validOpts.theme || "normal"}`
+            }, [
+              validSlot ? $xeTable.callSlot(validSlot, validParams) : [
+                vue.h("span", {
+                  class: "vxe-cell--valid-error-msg"
+                }, errorValidItem.content)
+              ]
+            ])
+          ]));
+        }
+      }
+      let showAreaRowStatus = false;
+      if (mouseConfig && mouseOpts.area && !_columnIndex && selectCellToRow) {
+        showAreaRowStatus = true;
+      }
+      if (!fixedHiddenColumn && showResizable && isAllColumnDrag) {
+        tdVNs.push(vue.h("div", {
+          key: "tcc",
+          class: ["vxe-cell--col-resizable", {
+            "is--line": !border || border === "none"
+          }],
+          onMousedown: (evnt) => $xeTable.handleColResizeMousedownEvent(evnt, fixedType, cellParams),
+          onDblclick: (evnt) => $xeTable.handleColResizeDblclickEvent(evnt, cellParams)
+        }));
+      }
+      if ((rowResize || isAllRowDrag) && rowOpts.resizable) {
+        tdVNs.push(vue.h("div", {
+          key: "tcr",
+          class: "vxe-cell--row-resizable",
+          onMousedown: (evnt) => $xeTable.handleRowResizeMousedownEvent(evnt, cellParams),
+          onDblclick: (evnt) => $xeTable.handleRowResizeDblclickEvent(evnt, cellParams)
+        }));
+      }
+      return vue.h("td", Object.assign(Object.assign(Object.assign({ class: [
+        "vxe-table--column vxe-body--column",
+        colid,
+        cellVerticalAlign ? `col--vertical-${cellVerticalAlign}` : "",
+        cellAlign ? `col--${cellAlign}` : "",
+        type ? `col--${type}` : "",
+        {
+          "col--last": isLastColumn,
+          "col--tree-node": treeNode,
+          "col--edit": isEdit,
+          "col--ellipsis": hasEllipsis,
+          "col--cs-height": isCsHeight,
+          "col--rs-height": isRsHeight,
+          "col--to-row": showAreaRowStatus,
+          "col--auto-height": isVNAutoHeight,
+          "fixed--width": !isAutoCellWidth,
+          "fixed--hidden": fixedHiddenColumn,
+          "is--padding": isCellPadding,
+          "is--progress": fixedHiddenColumn && isAllOverflow || isVNPreEmptyStatus,
+          "is--drag-cell": isRowDragCell && (isCrossDrag || isPeerDrag || !rowLevel),
+          "is--drag-disabled": isDisabledDrag,
+          "col--dirty": isDirty,
+          "col--active": editConfig && isEdit && (actived.row === row && (actived.column === column || editOpts.mode === "row")),
+          "col--valid-error": !!errorValidItem,
+          "col--current": currentColumn === column
+        },
+        dom.getPropClass(compCellClassName, cellParams),
+        dom.getPropClass(className, cellParams),
+        dom.getPropClass(allCellClassName, cellParams)
+      ], key: columnKey || scrollXLoad || scrollYLoad || columnOpts.useKey || rowOpts.useKey || columnOpts.drag ? colid : $columnIndex }, tdAttrs), { style: Object.assign({}, index.default.isFunction(compCellStyle) ? compCellStyle(cellParams) : compCellStyle, index.default.isFunction(cellStyle) ? cellStyle(cellParams) : cellStyle) }), tdOns), isOptimizeMode && fixedHiddenColumn ? [] : tdVNs);
+    };
+    const renderRows = (fixedType, isOptimizeMode, tableData, tableColumn) => {
+      const $xeGrid = $xeTable.xeGrid;
+      const $xeGantt = $xeTable.xeGantt;
+      const { stripe, rowKey, highlightHoverRow, rowClassName, rowStyle, editConfig, treeConfig } = tableProps;
+      const { hasFixedColumn, treeExpandedFlag, scrollXLoad, scrollYLoad, isAllOverflow, rowExpandedFlag, expandColumn, selectRadioRow, pendingRowFlag, rowExpandHeightFlag, isRowGroupStatus } = tableReactData;
+      const { fullAllDataRowIdData, fullColumnIdData, treeExpandedMaps, pendingRowMaps, rowExpandedMaps } = tableInternalData;
+      const checkboxOpts = computeCheckboxOpts.value;
+      const radioOpts = computeRadioOpts.value;
+      const treeOpts = computeTreeOpts.value;
+      const editOpts = computeEditOpts.value;
+      const rowOpts = computeRowOpts.value;
+      const columnOpts = computeColumnOpts.value;
+      const { transform, seqMode } = treeOpts;
+      const childrenField = treeOpts.children || treeOpts.childrenField;
+      const rows = [];
+      const { handleGetRowId } = util.createHandleGetRowId($xeTable);
+      const isDeepRow = treeConfig || isRowGroupStatus;
+      tableData.forEach((row, $rowIndex) => {
+        const rowid = handleGetRowId(row);
+        const rowRest = fullAllDataRowIdData[rowid] || {};
+        let rowIndex = $rowIndex;
+        let rowLevel = 0;
+        let seq = -1;
+        let _rowIndex = -1;
+        const hasRowGroupAggregate = isRowGroupStatus && row.isAggregate;
+        const trOn = {};
+        if (rowOpts.isHover || highlightHoverRow) {
+          trOn.onMouseover = (evnt) => {
+            if (isVMScrollProcess()) {
+              return;
+            }
+            $xeTable.triggerHoverEvent(evnt, { row, rowIndex });
+          };
+          trOn.onMouseleave = () => {
+            if (isVMScrollProcess()) {
+              return;
+            }
+            $xeTable.clearHoverRow();
+          };
+        }
+        if (rowRest) {
+          rowIndex = rowRest.index;
+          _rowIndex = rowRest._index;
+          rowLevel = rowRest.level;
+          seq = rowRest.seq;
+          if (hasRowGroupAggregate || treeConfig && transform && seqMode === "increasing") {
+            seq = rowRest._index + 1;
+          } else if (treeConfig && seqMode === "fixed") {
+            seq = rowRest._tIndex + 1;
+          }
+        }
+        const params = {
+          $table: $xeTable,
+          seq,
+          rowid,
+          fixed: fixedType,
+          type: renderType,
+          level: rowLevel,
+          row,
+          rowIndex,
+          $rowIndex,
+          _rowIndex
+        };
+        const isExpandRow = expandColumn && !!rowExpandedFlag && !!rowExpandedMaps[rowid];
+        let isExpandTree = false;
+        let rowChildren = [];
+        let isNewRow = false;
+        if (editConfig) {
+          isNewRow = $xeTable.isInsertByRow(row);
+        }
+        if (treeConfig && !scrollYLoad && !transform) {
+          rowChildren = row[childrenField];
+          isExpandTree = !!treeExpandedFlag && rowChildren && rowChildren.length > 0 && !!treeExpandedMaps[rowid];
+        }
+        if (rowOpts.drag && !isRowGroupStatus && (!treeConfig || transform)) {
+          trOn.onDragstart = $xeTable.handleRowDragDragstartEvent;
+          trOn.onDragend = $xeTable.handleRowDragDragendEvent;
+          trOn.onDragover = $xeTable.handleRowDragDragoverEvent;
+        }
+        const trClass = [
+          "vxe-body--row",
+          isDeepRow ? `row--level-${rowLevel}` : "",
+          {
+            "row--stripe": stripe && (_rowIndex + 1) % 2 === 0,
+            "is--new": isNewRow,
+            "is--expand-row": isExpandRow,
+            "is--expand-tree": isExpandTree,
+            "row--new": isNewRow && (editOpts.showStatus || editOpts.showInsertStatus),
+            "row--radio": radioOpts.highlight && $xeTable.eqRow(selectRadioRow, row),
+            "row--checked": checkboxOpts.highlight && $xeTable.isCheckedByCheckboxRow(row),
+            "row--pending": !!pendingRowFlag && !!pendingRowMaps[rowid],
+            "row--group": hasRowGroupAggregate
+          },
+          dom.getPropClass(rowClassName, params)
+        ];
+        const tdVNs = tableColumn.map((column, $columnIndex) => {
+          return renderTdColumn(seq, rowid, fixedType, isOptimizeMode, rowLevel, row, rowIndex, $rowIndex, _rowIndex, column, $columnIndex, tableColumn, tableData);
+        });
+        rows.push(vue.h("tr", Object.assign({ class: trClass, rowid, style: rowStyle ? index.default.isFunction(rowStyle) ? rowStyle(params) : rowStyle : null, key: rowKey || scrollXLoad || scrollYLoad || rowOpts.useKey || rowOpts.drag || columnOpts.drag || isRowGroupStatus || treeConfig ? rowid : $rowIndex }, trOn), tdVNs));
+        if (isExpandRow) {
+          const expandOpts = computeExpandOpts.value;
+          const { height: expandHeight, padding, mode: expandMode } = expandOpts;
+          if (expandMode === "fixed") {
+            rows.push(vue.h("tr", {
+              class: "vxe-body--row-expanded-place",
+              key: `expand_${rowid}`,
+              rowid
+            }, [
+              vue.h("td", {
+                class: "vxe-body--row-expanded-place-column",
+                colspan: tableColumn.length,
+                style: {
+                  height: `${rowExpandHeightFlag ? rowRest.expandHeight || expandHeight : 0}px`
+                }
+              })
+            ]));
+          } else {
+            const cellStyle = {};
+            if (expandHeight) {
+              cellStyle.height = `${expandHeight}px`;
+            }
+            if (treeConfig) {
+              cellStyle.paddingLeft = `${rowLevel * treeOpts.indent + 30}px`;
+            }
+            const { showOverflow } = expandColumn || {};
+            const colid = expandColumn.id;
+            const colRest = fullColumnIdData[colid] || {};
+            const hasEllipsis = index.default.eqNull(showOverflow) ? isAllOverflow : showOverflow;
+            let columnIndex = -1;
+            let $columnIndex = -1;
+            let _columnIndex = -1;
+            if (colRest) {
+              columnIndex = colRest.index;
+              $columnIndex = colRest.$index;
+              _columnIndex = colRest._index;
+            }
+            const expandParams = {
+              $table: $xeTable,
+              $grid: $xeGrid,
+              $gantt: $xeGantt,
+              seq,
+              column: expandColumn,
+              columnIndex,
+              $columnIndex,
+              _columnIndex,
+              fixed: fixedType,
+              source: sourceType,
+              type: renderType,
+              level: rowLevel,
+              row,
+              rowid,
+              rowIndex,
+              $rowIndex,
+              _rowIndex,
+              isHidden: false,
+              isEdit: false,
+              visibleData: [],
+              data: [],
+              items: []
+            };
+            rows.push(vue.h("tr", {
+              class: ["vxe-body--expanded-row", {
+                "is--padding": padding
+              }],
+              key: `expand_${rowid}`
+            }, [
+              vue.h("td", {
+                class: ["vxe-body--expanded-column", {
+                  "fixed--hidden": fixedType && !hasFixedColumn,
+                  "col--ellipsis": hasEllipsis
+                }],
+                colspan: tableColumn.length
+              }, [
+                vue.h("div", {
+                  class: ["vxe-body--expanded-cell", {
+                    "is--ellipsis": expandHeight
+                  }],
+                  style: cellStyle
+                }, [
+                  expandColumn.renderData(expandParams)
+                ])
+              ])
+            ]));
+          }
+        }
+        if (isExpandTree) {
+          rows.push(...renderRows(fixedType, isOptimizeMode, rowChildren, tableColumn));
+        }
+      });
+      return rows;
+    };
+    vue.onMounted(() => {
+      vue.nextTick(() => {
+        const { fixedType } = props;
+        const { elemStore } = tableInternalData;
+        const prefix = `${fixedType || "main"}-body-`;
+        elemStore[`${prefix}wrapper`] = refElem;
+        elemStore[`${prefix}scroll`] = refBodyScroll;
+        elemStore[`${prefix}table`] = refBodyTable;
+        elemStore[`${prefix}colgroup`] = refBodyColgroup;
+        elemStore[`${prefix}list`] = refBodyTBody;
+        elemStore[`${prefix}xSpace`] = refBodyXSpace;
+        elemStore[`${prefix}ySpace`] = refBodyYSpace;
+        elemStore[`${prefix}emptyBlock`] = refBodyEmptyBlock;
+      });
+    });
+    vue.onUnmounted(() => {
+      const { fixedType } = props;
+      const { elemStore } = tableInternalData;
+      const prefix = `${fixedType || "main"}-body-`;
+      elemStore[`${prefix}wrapper`] = null;
+      elemStore[`${prefix}scroll`] = null;
+      elemStore[`${prefix}table`] = null;
+      elemStore[`${prefix}colgroup`] = null;
+      elemStore[`${prefix}list`] = null;
+      elemStore[`${prefix}xSpace`] = null;
+      elemStore[`${prefix}ySpace`] = null;
+      elemStore[`${prefix}emptyBlock`] = null;
+    });
+    const renderVN = () => {
+      const { slots } = tableContext;
+      const $xeGrid = $xeTable.xeGrid;
+      const $xeGantt = $xeTable.xeGantt;
+      const { fixedColumn, fixedType, tableColumn } = props;
+      const { spanMethod, footerSpanMethod, mouseConfig } = tableProps;
+      const { isGroup, tableData, isColLoading, overflowX, scrollXLoad, scrollYLoad, isAllOverflow, expandColumn, dragRow, dragCol } = tableReactData;
+      const { visibleColumn, fullAllDataRowIdData, fullColumnIdData } = tableInternalData;
+      const emptyOpts = computeEmptyOpts.value;
+      const mouseOpts = computeMouseOpts.value;
+      const expandOpts = computeExpandOpts.value;
+      let renderDataList = tableData;
+      let renderColumnList = tableColumn;
+      let isOptimizeMode = false;
+      if (scrollXLoad || scrollYLoad || isAllOverflow) {
+        if (expandColumn && expandOpts.mode !== "fixed" || spanMethod || footerSpanMethod) ;
+        else {
+          isOptimizeMode = true;
+        }
+      }
+      if (!isColLoading && (fixedType || !overflowX)) {
+        renderColumnList = visibleColumn;
+      }
+      if (fixedType) {
+        if (isOptimizeMode) {
+          renderColumnList = fixedColumn || [];
+        }
+      }
+      if (scrollYLoad && dragRow) {
+        if (renderDataList.length > 2) {
+          const dRowRest = fullAllDataRowIdData[util.getRowid($xeTable, dragRow)];
+          if (dRowRest) {
+            const drIndex = dRowRest._index;
+            const firstRow = renderDataList[0];
+            const lastRow = renderDataList[renderDataList.length - 1];
+            const firstRowRest = fullAllDataRowIdData[util.getRowid($xeTable, firstRow)];
+            const lastRowRest = fullAllDataRowIdData[util.getRowid($xeTable, lastRow)];
+            if (firstRowRest && lastRowRest) {
+              const frIndex = firstRowRest._index;
+              const lrIndex = lastRowRest._index;
+              if (drIndex < frIndex) {
+                renderDataList = [dragRow].concat(renderDataList);
+              } else if (drIndex > lrIndex) {
+                renderDataList = renderDataList.concat([dragRow]);
+              }
+            }
+          }
+        }
+      }
+      if (!fixedType && !isGroup) {
+        if (scrollXLoad && dragCol) {
+          if (renderColumnList.length > 2) {
+            const dCowRest = fullColumnIdData[dragCol.id];
+            if (dCowRest) {
+              const dcIndex = dCowRest._index;
+              const firstCol = renderColumnList[0];
+              const lastCol = renderColumnList[renderColumnList.length - 1];
+              const firstColRest = fullColumnIdData[firstCol.id];
+              const lastColRest = fullColumnIdData[lastCol.id];
+              if (firstColRest && lastColRest) {
+                const fcIndex = firstColRest._index;
+                const lcIndex = lastColRest._index;
+                if (dcIndex < fcIndex) {
+                  renderColumnList = [dragCol].concat(renderColumnList);
+                } else if (dcIndex > lcIndex) {
+                  renderColumnList = renderColumnList.concat([dragCol]);
+                }
+              }
+            }
+          }
+        }
+      }
+      let emptyContent;
+      const emptySlot = slots ? slots.empty : null;
+      const emptyParams = { $table: $xeTable, $grid: $xeGrid, $gantt: $xeGantt };
+      if (emptySlot) {
+        emptyContent = $xeTable.callSlot(emptySlot, emptyParams);
+      } else {
+        const compConf = emptyOpts.name ? renderer.get(emptyOpts.name) : null;
+        const rtEmptyView = compConf ? compConf.renderTableEmpty || compConf.renderTableEmptyView || compConf.renderEmpty : null;
+        if (rtEmptyView) {
+          emptyContent = vn.getSlotVNs(rtEmptyView(emptyOpts, emptyParams));
+        } else {
+          emptyContent = tableProps.emptyText || getI18n("vxe.table.emptyText");
+        }
+      }
+      const ons = {
+        onScroll(evnt) {
+          $xeTable.triggerBodyScrollEvent(evnt, fixedType);
+        }
+      };
+      return vue.h("div", {
+        ref: refElem,
+        class: ["vxe-table--body-wrapper", fixedType ? `fixed-${fixedType}--wrapper` : "body--wrapper"],
+        xid: xID
+      }, [
+        vue.h("div", Object.assign({ ref: refBodyScroll, class: "vxe-table--body-inner-wrapper" }, ons), [
+          fixedType ? renderEmptyElement($xeTable) : vue.h("div", {
+            ref: refBodyXSpace,
+            class: "vxe-body--x-space"
+          }),
+          vue.h("div", {
+            ref: refBodyYSpace,
+            class: "vxe-body--y-space"
+          }),
+          vue.h("table", {
+            ref: refBodyTable,
+            class: "vxe-table--body",
+            xid: xID,
+            cellspacing: 0,
+            cellpadding: 0,
+            border: 0,
+            xvm: isOptimizeMode ? "1" : null
+          }, [
+            /**
+             * 列宽
+             */
+            vue.h("colgroup", {
+              ref: refBodyColgroup
+            }, renderColumnList.map((column, $columnIndex) => {
+              return vue.h("col", {
+                name: column.id,
+                key: $columnIndex,
+                style: {
+                  width: `${column.renderWidth}px`
+                }
+              });
+            })),
+            /**
+             * 内容
+             */
+            vue.h("tbody", {
+              ref: refBodyTBody
+            }, renderRows(fixedType, isOptimizeMode, renderDataList, renderColumnList))
+          ]),
+          vue.h("div", {
+            class: "vxe-table--checkbox-range"
+          }),
+          mouseConfig && mouseOpts.area ? vue.h("div", {
+            class: "vxe-table--cell-area",
+            xid: xID
+          }, [
+            vue.h("span", {
+              class: "vxe-table--cell-main-area"
+            }, mouseOpts.extension ? [
+              vue.h("span", {
+                class: "vxe-table--cell-main-area-btn",
+                onMousedown(evnt) {
+                  if ($xeTable.triggerCellAreaExtendMousedownEvent) {
+                    $xeTable.triggerCellAreaExtendMousedownEvent(evnt, { $table: $xeTable, fixed: fixedType, type: renderType });
+                  }
+                }
+              })
+            ] : []),
+            vue.h("span", {
+              class: "vxe-table--cell-clip-area"
+            }),
+            vue.h("span", {
+              class: "vxe-table--cell-extend-area"
+            }),
+            vue.h("span", {
+              class: "vxe-table--cell-multi-area"
+            }),
+            vue.h("span", {
+              class: "vxe-table--cell-active-area"
+            }),
+            vue.h("span", {
+              class: "vxe-table--cell-row-status-area"
+            })
+          ]) : renderEmptyElement($xeTable),
+          !fixedType ? vue.h("div", {
+            class: "vxe-table--empty-block",
+            ref: refBodyEmptyBlock
+          }, [
+            vue.h("div", {
+              class: "vxe-table--empty-content"
+            }, emptyContent)
+          ]) : renderEmptyElement($xeTable)
+        ])
+      ]);
+    };
+    return renderVN;
+  }
+});
+exports.default = TableBodyComponent;