es-grid-template 1.8.64 → 1.8.65

package/es/table-virtuoso/body/TableBody.js

@@ -0,0 +1,84 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import TableBodyRow from "./TableBodyRow";
+// import type { Virtualizer } from "@tanstack/react-virtual";
+import { useVirtualizer } from "@tanstack/react-virtual";
+// import type { Dispatch, SetStateAction } from "react";
+import React, { Fragment } from "react";
+import { TableContext } from "../useContext";
+import { Empty } from "rc-master-ui";
+const TableBody = ({
+  columnVirtualizer,
+  table,
+  tableContainerRef,
+  virtualPaddingLeft,
+  virtualPaddingRight,
+  fixedLeftColumns,
+  fixedRightColumns,
+  tableId,
+  showEmptyText,
+  ...rest
+}) => {
+  const {
+    rows
+  } = table.getRowModel();
+  const {
+    editingKey,
+    prefix,
+    locale
+  } = React.useContext(TableContext);
+
+  //dynamic row height virtualization - alternatively you could use a simpler fixed row height strategy without the need for `measureElement`
+  const rowVirtualizer = useVirtualizer({
+    count: rows.length,
+    estimateSize: () => 36,
+    //estimate row height for accurate scrollbar dragging
+    getScrollElement: () => tableContainerRef.current,
+    //measure dynamic row height, except in firefox because it measures table border height incorrectly
+    measureElement: typeof window !== 'undefined' && navigator.userAgent.indexOf('Firefox') === -1 ? element => element?.getBoundingClientRect().height : undefined,
+    overscan: 1
+  });
+  const virtualRows = rowVirtualizer.getVirtualItems();
+  return /*#__PURE__*/React.createElement("div", {
+    className: `${prefix}-grid-tbody`,
+    style: {
+      display: 'grid',
+      // height: `${rowVirtualizer.getTotalSize()}px`, //tells scrollbar how big the table is
+      height: showEmptyText && rows.length === 0 ? `140px` : `${rowVirtualizer.getTotalSize()}px`,
+      //tells scrollbar how big the table is
+      position: 'relative' //needed for absolute positioning of rows
+    }
+  }, showEmptyText && rows.length === 0 ? /*#__PURE__*/React.createElement("tr", {
+    style: {
+      // transform: `translateY(${virtualRow.start}px)`, //this should always be a `style` as it changes on scroll
+    }
+  }, /*#__PURE__*/React.createElement("td", {
+    // colSpan={30}
+    style: {
+      position: "sticky",
+      left: 0,
+      width: tableContainerRef.current?.clientWidth,
+      overflow: 'hidden'
+    }
+  }, /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement(Empty, {
+    image: Empty.PRESENTED_IMAGE_SIMPLE,
+    description: locale?.emptyText
+  })))) : /*#__PURE__*/React.createElement(Fragment, null, virtualRows.map(virtualRow => {
+    const row = rows[virtualRow.index];
+    const isEditing = row.id === editingKey;
+    return /*#__PURE__*/React.createElement(TableBodyRow, _extends({}, rest, {
+      table: table,
+      tableId: tableId,
+      key: row.id,
+      row: row,
+      columnVirtualizer: columnVirtualizer,
+      rowVirtualizer: rowVirtualizer,
+      virtualPaddingLeft: virtualPaddingLeft,
+      virtualPaddingRight: virtualPaddingRight,
+      virtualRow: virtualRow,
+      fixedLeftColumns: fixedLeftColumns,
+      fixedRightColumns: fixedRightColumns,
+      isEditing: isEditing
+    }));
+  })));
+};
+export default TableBody;

package/es/table-virtuoso/body/TableBodyCell.d.ts

@@ -0,0 +1,14 @@
+import type { Cell, Table } from "@tanstack/react-table";
+import type { CommandClick } from "../../table-component/type";
+import React from "react";
+import type { VirtualItem } from "@tanstack/react-virtual";
+interface TableBodyCellProps<T> {
+    table: Table<T>;
+    tableId: string;
+    cell: Cell<T, unknown>;
+    commandClick?: (args: CommandClick<T>) => void;
+    virtualRow: VirtualItem;
+    [key: string]: any;
+}
+declare const TableBodyCell: <RecordType extends object>(props: TableBodyCellProps<RecordType>) => React.JSX.Element;
+export default TableBodyCell;

package/es/table-virtuoso/body/TableBodyCell.js

@@ -0,0 +1,466 @@
+import { flexRender } from "@tanstack/react-table";
+import Space from "rc-master-ui/es/space";
+// import Command from "../components/command/Command";
+
+import ReactDOMServer from 'react-dom/server';
+import { getCommonPinningStyles } from "../hook/utils";
+import Checkbox from "rc-master-ui/es/checkbox/Checkbox";
+import classNames from "classnames";
+import React from "react";
+import { TableContext } from "../useContext";
+import { toggleRowSelection } from "../hook/useColumns";
+import Command from "../../table-component/components/command/Command";
+const renderCellIndex = props => {
+  const {
+    cell,
+    pagination
+  } = props;
+  const parrents = cell.row.getParentRows();
+  if (parrents && parrents.length > 0) {
+    return /*#__PURE__*/React.createElement("span", {
+      className: "ui-rc_cell-content"
+    }, parrents.map(pr => {
+      return `${pr.index + 1}.`;
+    }), cell.row.index + 1);
+  }
+  if (pagination && pagination.onChange) {
+    return /*#__PURE__*/React.createElement("span", {
+      className: "ui-rc_cell-content"
+    }, cell.row.index + (pagination ? ((pagination.currentPage ?? 1) - 1) * (pagination?.pageSize ?? 0) : 0) + 1);
+  }
+  return /*#__PURE__*/React.createElement("span", {
+    className: "ui-rc_cell-content"
+  }, cell.row.index + 1);
+};
+const renderCommand = args => {
+  const {
+    cell,
+    commandClick,
+    id,
+    data
+  } = args;
+  const col = cell.column.columnDef.meta ?? {};
+  const record = cell.row.original;
+
+  // const commandItems = args.cell.column.columnDef?.meta?.commandItems ?? []
+
+  const commands = col.commandItems ? col.commandItems.map(it => {
+    return {
+      ...it,
+      visible: typeof it.visible === 'function' ? it.visible?.(record) : it.visible
+    };
+  }) : [];
+  return /*#__PURE__*/React.createElement("div", {
+    className: "ui-rc_cell-content"
+  }, /*#__PURE__*/React.createElement(Space, null, commands.filter(it => it.visible !== false).map(item => {
+    return /*#__PURE__*/React.createElement(Command, {
+      id: id,
+      key: item.id,
+      item: item,
+      record: record,
+      onClick: () => {
+        commandClick?.({
+          id: item.id,
+          // rowId: getRowKey(record, index) as any,
+          rowId: record.rowId,
+          rowData: record,
+          index: cell.row.index,
+          rows: [...data]
+        });
+      }
+    });
+  })));
+};
+const renderSelection = args => {
+  const {
+    row
+  } = args.cell;
+  const {
+    cell,
+    expandIconColumnIndex,
+    isDataTree,
+    expanded,
+    setExpanded
+  } = args;
+  const {
+    selectionSettings,
+    setIsSelectionChange,
+    isSelectionChange
+  } = args;
+  const checked = selectionSettings?.type === 'single' || selectionSettings?.checkStrictly ? row.getIsSelected() : row.getIsSelected() || row.getIsAllSubRowsSelected();
+  const indeterminate = selectionSettings?.type === 'single' || selectionSettings?.checkStrictly ? false : row.getIsSomeSelected() && selectionSettings && selectionSettings.mode === 'checkbox' || row.getIsSomeSelected();
+  return /*#__PURE__*/React.createElement("div", {
+    style: {}
+  }, cell.column.getIndex() === expandIconColumnIndex && isDataTree && /*#__PURE__*/React.createElement("div", {
+    className: "ui-rc-table-row-expand-trigger",
+    style: {
+      paddingLeft: `${cell.row.depth * 25}px`
+    }
+  }, /*#__PURE__*/React.createElement("div", null, cell.row.getCanExpand() ? /*#__PURE__*/React.createElement("button", {
+    // onClick: row.getToggleExpandedHandler(),
+    onClick: () => {
+      const keys = Object.keys(expanded);
+      // @ts-ignore
+      const tmp = {
+        ...expanded
+      };
+      if (keys.includes(cell.row.id)) {
+        delete tmp[cell.row.id];
+        setExpanded(tmp);
+      } else {
+        setExpanded(old => ({
+          ...old,
+          [cell.row.id]: true
+        }));
+      }
+    },
+    style: {
+      cursor: "pointer"
+    },
+    className: "ui-rc-table-row-expand"
+  }, cell.row.getIsExpanded() ? /*#__PURE__*/React.createElement("span", {
+    className: "ui-rc-table-row-expand-icon ui-rc-table-row-expand-icon-expanded"
+  }) : /*#__PURE__*/React.createElement("span", {
+    className: "ui-rc-table-row-expand-icon ui-rc-table-row-expand-icon-collapsed"
+  })) : /*#__PURE__*/React.createElement("span", {
+    className: "ui-rc-table-row-expand-icon ui-rc-table-row-expand-icon-spaced"
+  }))), /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement(Checkbox, {
+    checked: checked,
+    indeterminate: indeterminate,
+    onChange: e => {
+      toggleRowSelection({
+        e,
+        cell,
+        setIsSelectionChange,
+        isSelectionChange,
+        selectionSettings
+      });
+    },
+    disabled: !row.getCanSelect()
+  })));
+};
+const TableBodyCell = props => {
+  const {
+    cell,
+    commandClick,
+    // tableId,
+    table,
+    isEditing,
+    colSpan,
+    groupValue
+  } = props;
+  const {
+    id,
+    prefix,
+    focusedCell,
+    setFocusedCell,
+    // endCell,
+    // startCell,
+    originData,
+    expanded,
+    setExpanded,
+    expandable,
+    isDataTree,
+    setIsSelectionChange,
+    isSelectionChange,
+    selectionSettings,
+    wrapSettings,
+    pagination
+    // dataSource
+  } = React.useContext(TableContext);
+  const expandIconColumnIndex = expandable?.expandIconColumnIndex ?? 0;
+  const [isOpenTooltip, setIsOpenTooltip] = React.useState(false);
+  const record = cell.row.original;
+  const columnMeta = cell.column.columnDef.meta ?? {};
+  const cellStyles = typeof columnMeta.onCellStyles === 'function' ? columnMeta.onCellStyles(cell.getValue(), cell) : columnMeta.onCellStyles;
+
+  // const tooltipContent = (isOpenTooltip === false || columnMeta.type === 'checkbox') ? '' : flexRender(cell.column.columnDef.cell, cell.getContext());
+  const tooltipContent = isOpenTooltip === false ? '' : columnMeta?.tooltipDescription ? typeof columnMeta.tooltipDescription === 'function' ? columnMeta.tooltipDescription({
+    value: cell.getValue(),
+    record
+  }) : columnMeta.tooltipDescription : columnMeta.template && typeof columnMeta.template !== 'function' ? columnMeta.template : cell.getValue();
+  const allRows = table.getRowModel().flatRows;
+  const rowNumber = allRows.findIndex(it => it.id === cell.row.id);
+  const colIndex = cell.column.getIndex();
+  const isPinned = cell.column.getIsPinned();
+  const isLastLeftPinnedColumn = isPinned === "left" && cell.column.getIsLastColumn("left");
+  const isFirstRightPinnedColumn = isPinned === "right" && cell.column.getIsFirstColumn("right");
+  const enableClick = typeof columnMeta.allowSelection === 'function' ? columnMeta.allowSelection(record) : columnMeta.allowSelection;
+
+  // const firstVisibleNormalColumn = table.getVisibleLeafColumns().filter(col => col.id !== 'selection' && col.id !== '#')[0];
+  // const firstVisibleNormalColumn = table.getVisibleLeafColumns().filter(col => col.id !== 'selection' && col.id !== '#')[0];
+
+  // const parrents = cell.row.getParentRows();
+
+  if (cell.column.id === "#") {
+    return /*#__PURE__*/React.createElement("td", {
+      key: cell.id,
+      className: classNames(`${prefix}-grid-cell ${prefix}-grid-cell-index`, {
+        [`${prefix}-grid-cell-ellipsis`]: true,
+        [`${prefix}-grid-cell-fix-left-last`]: isLastLeftPinnedColumn,
+        [`${prefix}-grid-cell-fix-right-first`]: isFirstRightPinnedColumn,
+        [`${prefix}-grid-cell-text-center`]: columnMeta?.textAlign === 'center',
+        [`${prefix}-grid-cell-text-right`]: columnMeta?.textAlign === 'right'
+      }),
+      style: {
+        ...cellStyles,
+        // display: 'flex',
+        userSelect: 'none',
+        width: cell.column.getSize(),
+        minWidth: cell.column.getSize(),
+        ...getCommonPinningStyles(cell.column)
+      },
+      onClick: e => {
+        if (!selectionSettings || selectionSettings.checkboxOnly !== true) {
+          toggleRowSelection({
+            e,
+            cell,
+            setIsSelectionChange,
+            isSelectionChange,
+            selectionSettings
+          });
+        }
+      }
+    }, cell.column.getIndex() === expandIconColumnIndex && isDataTree && /*#__PURE__*/React.createElement("div", {
+      className: "ui-rc-table-row-expand-trigger",
+      style: {
+        paddingLeft: `${cell.row.depth * 25}px`
+      }
+    }, /*#__PURE__*/React.createElement("div", null, cell.row.getCanExpand() ? /*#__PURE__*/React.createElement("button", {
+      // onClick: cell.row.getToggleExpandedHandler(),
+      onClick: () => {
+        const keys = Object.keys(expanded);
+        // @ts-ignore
+        const tmp = {
+          ...expanded
+        };
+        if (keys.includes(cell.row.id)) {
+          delete tmp[cell.row.id];
+          setExpanded(tmp);
+        } else {
+          setExpanded(old => ({
+            ...old,
+            [cell.row.id]: true
+          }));
+        }
+      },
+      style: {
+        cursor: "pointer"
+      },
+      className: "ui-rc-table-row-expand"
+    }, cell.row.getIsExpanded() ? /*#__PURE__*/React.createElement("span", {
+      className: "ui-rc-table-row-expand-icon ui-rc-table-row-expand-icon-expanded"
+    }) : /*#__PURE__*/React.createElement("span", {
+      className: "ui-rc-table-row-expand-icon ui-rc-table-row-expand-icon-collapsed"
+    })) : /*#__PURE__*/React.createElement("span", {
+      className: "ui-rc-table-row-expand-icon ui-rc-table-row-expand-icon-spaced"
+    }))), renderCellIndex({
+      cell,
+      pagination
+    }));
+  }
+  if (cell.column.id === "command") {
+    return /*#__PURE__*/React.createElement("td", {
+      key: cell.id,
+      className: classNames(`${prefix}-grid-cell ${prefix}-grid-cell-command`, {
+        [`${prefix}-grid-cell-ellipsis`]: true,
+        [`${prefix}-grid-cell-fix-left-last`]: isLastLeftPinnedColumn,
+        [`${prefix}-grid-cell-fix-right-first`]: isFirstRightPinnedColumn,
+        [`${prefix}-grid-cell-text-center`]: columnMeta?.textAlign === 'center',
+        [`${prefix}-grid-cell-text-right`]: columnMeta?.textAlign === 'right'
+      }),
+      style: {
+        ...cellStyles,
+        // display: 'flex',
+        width: cell.column.getSize(),
+        minWidth: cell.column.getSize(),
+        ...getCommonPinningStyles(cell.column)
+      }
+    }, renderCommand({
+      cell,
+      commandClick,
+      id,
+      data: originData
+    }));
+  }
+  if (cell.column.id === "selection_column") {
+    return /*#__PURE__*/React.createElement("td", {
+      key: cell.id,
+      className: classNames(`${prefix}-grid-cell ${prefix}-grid-cell-selection`, {
+        [`${prefix}-grid-cell-ellipsis`]: true,
+        [`${prefix}-grid-cell-fix-left-last`]: isLastLeftPinnedColumn,
+        [`${prefix}-grid-cell-fix-right-first`]: isFirstRightPinnedColumn,
+        [`${prefix}-grid-cell-text-center`]: columnMeta?.textAlign === 'center',
+        [`${prefix}-grid-cell-text-right`]: columnMeta?.textAlign === 'right'
+      }),
+      style: {
+        ...cellStyles,
+        // display: 'flex',
+        minHeight: 36,
+        width: cell.column.getSize(),
+        minWidth: cell.column.getSize(),
+        ...getCommonPinningStyles(cell.column)
+      }
+    }, /*#__PURE__*/React.createElement("div", {
+      className: classNames('ui-rc_cell-content', {})
+    }, cell.column.id === "selection_column" && renderSelection({
+      cell,
+      table,
+      selectionSettings,
+      setIsSelectionChange,
+      expanded,
+      isDataTree,
+      setExpanded,
+      expandIconColumnIndex,
+      isSelectionChange
+    })));
+  }
+  return /*#__PURE__*/React.createElement("td", {
+    key: cell.id,
+    colSpan: colSpan,
+    ref: el => {
+      if (focusedCell?.rowId === cell.row.id && focusedCell?.colId === cell.column.id && !isEditing) {
+        el?.focus();
+      }
+    },
+    tabIndex: focusedCell?.rowId === cell.row.id && focusedCell?.colId === cell.column.id ? 0 : -1,
+    "data-col-index": colIndex,
+    "data-row-index": rowNumber,
+    "data-col-key": cell.column.id
+    // data-row-key={cell.row.id}
+    ,
+    "data-tooltip-id": `${id}-tooltip-content`,
+    "data-tooltip-html": ReactDOMServer.renderToStaticMarkup( /*#__PURE__*/React.createElement(React.Fragment, null, tooltipContent))
+    // data-tooltip-delay-show={500}
+    ,
+
+    className: classNames(`${prefix}-grid-cell`, {
+      // [`${prefix}-grid-cell-ellipsis`]: true,
+
+      [`${prefix}-grid-cell-ellipsis`]: !wrapSettings || !(wrapSettings && (wrapSettings.wrapMode === 'Both' || wrapSettings.wrapMode === 'Content')),
+      [`${prefix}-grid-cell-text-wrap`]: wrapSettings && (wrapSettings.wrapMode === 'Both' || wrapSettings.wrapMode === 'Content'),
+      // [`${prefix}-grid-cell-selected`]: isCellSelected,
+
+      [`${prefix}-grid-cell-fix-left-last`]: isLastLeftPinnedColumn,
+      [`${prefix}-grid-cell-fix-right-first`]: isFirstRightPinnedColumn,
+      [`${prefix}-grid-cell-text-center`]: columnMeta?.textAlign === 'center',
+      [`${prefix}-grid-cell-text-right`]: columnMeta?.textAlign === 'right' || columnMeta.type === 'number'
+    }),
+    style: {
+      ...cellStyles,
+      // display: 'flex',
+      width: cell.column.getSize(),
+      minWidth: cell.column.getSize(),
+      minHeight: 36,
+      ...getCommonPinningStyles(cell.column)
+    },
+    onMouseEnter: e => {
+      if (e.target.firstChild?.clientWidth < e.target.firstChild?.scrollWidth) {
+        setIsOpenTooltip(true);
+      }
+    },
+    onKeyDown: e => {
+      const flatRows = table.getRowModel().flatRows;
+      if (e.key === 'ArrowDown' && rowNumber < flatRows.length - 1) {
+        const nextIndex = cell.row.index + 1;
+        // const nextIndex = rowNumber + 1
+
+        const nextId = flatRows[nextIndex].id;
+        setFocusedCell?.({
+          colId: cell.column.id,
+          rowId: nextId
+        });
+        const row = document.querySelector(`.ui-rc-grid-row[data-row-key="${nextId}"]`);
+        const cellFocus = row?.querySelector('.ui-rc-grid-cell:not(.ui-rc-grid-cell-selection)');
+        if (cellFocus) {
+          cellFocus.focus();
+        }
+      }
+      if (e.key === 'ArrowUp' && rowNumber > 0) {
+        const prevIndex = cell.row.index - 1;
+        const nextId = flatRows[prevIndex].id;
+        setFocusedCell?.({
+          colId: cell.column.id,
+          rowId: nextId
+        });
+        const row = document.querySelector(`.ui-rc-grid-row[data-row-key="${nextId}"]`);
+        const cellFocus = row?.querySelector('.ui-rc-grid-cell:not(.ui-rc-grid-cell-selection)');
+        if (cellFocus) {
+          cellFocus.focus();
+        }
+      }
+      if (e.ctrlKey && e.code === 'Space' && cell.row.getCanSelect()) {
+        toggleRowSelection({
+          e,
+          cell,
+          setIsSelectionChange,
+          isSelectionChange,
+          selectionSettings
+        });
+        cell.row.getToggleSelectedHandler()(e);
+      }
+    },
+    onClick: e => {
+      const selection = window.getSelection();
+      const text = selection ? selection.toString() : "";
+      if (text.length > 0 || enableClick === false) {} else {
+        if (!selectionSettings || selectionSettings.checkboxOnly !== true) {
+          toggleRowSelection({
+            e,
+            cell,
+            setIsSelectionChange,
+            isSelectionChange,
+            selectionSettings
+          });
+          setFocusedCell?.({
+            colId: cell.column.id,
+            rowId: cell.row.id
+          });
+        }
+      }
+    }
+  }, cell.column.getIndex() === expandIconColumnIndex && isDataTree ? /*#__PURE__*/React.createElement("div", {
+    className: classNames('ui-rc_cell-content', {})
+  }, cell.column.getIndex() === expandIconColumnIndex && isDataTree && /*#__PURE__*/React.createElement("div", {
+    className: "ui-rc-table-row-expand-trigger",
+    style: {
+      paddingLeft: `${cell.row.depth * 25}px`
+    }
+  }, /*#__PURE__*/React.createElement("div", null, cell.row.getCanExpand() ? /*#__PURE__*/React.createElement("button", {
+    // onClick: cell.row.getToggleExpandedHandler(),
+
+    // onClick: (e) => {
+    //   e.stopPropagation()
+    //   cell.row.toggleExpanded()
+    // },
+
+    onClick: e => {
+      e.stopPropagation();
+      const keys = Object.keys(expanded);
+      // @ts-ignore
+      const tmp = {
+        ...expanded
+      };
+      if (keys.includes(cell.row.id)) {
+        delete tmp[cell.row.id];
+        setExpanded(tmp);
+      } else {
+        setExpanded(old => ({
+          ...old,
+          [cell.row.id]: true
+        }));
+      }
+    },
+    style: {
+      cursor: "pointer"
+    },
+    className: "ui-rc-table-row-expand"
+  }, cell.row.getIsExpanded() ? /*#__PURE__*/React.createElement("span", {
+    className: "ui-rc-table-row-expand-icon ui-rc-table-row-expand-icon-expanded"
+  }) : /*#__PURE__*/React.createElement("span", {
+    className: "ui-rc-table-row-expand-icon ui-rc-table-row-expand-icon-collapsed"
+  })) : /*#__PURE__*/React.createElement("span", {
+    className: "ui-rc-table-row-expand-icon ui-rc-table-row-expand-icon-spaced"
+  }))), groupValue ? groupValue : flexRender(cell.column.columnDef.cell, cell.getContext())) : /*#__PURE__*/React.createElement(React.Fragment, null, groupValue ? groupValue : flexRender(cell.column.columnDef.cell, cell.getContext())));
+};
+export default TableBodyCell;

package/es/table-virtuoso/body/TableBodyRow.d.ts

@@ -0,0 +1,13 @@
+import { type Row, type Table } from "@tanstack/react-table";
+import type { CommandClick } from "../../table-component/type";
+import React from "react";
+interface TableBodyRowProps<T> {
+    tableId: string;
+    table: Table<T>;
+    row: Row<T>;
+    commandClick?: (args: CommandClick<T>) => void;
+    editAble?: boolean;
+    [key: string]: any;
+}
+declare const TableBodyRow: <RecordType extends object>({ tableId, table, row, virtualRow, commandClick, contextMenuItems, onContextMenu, ...rest }: TableBodyRowProps<RecordType>) => React.JSX.Element;
+export default TableBodyRow;

package/es/table-virtuoso/body/TableBodyRow.js

@@ -0,0 +1,116 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+// import type { VirtualItem, Virtualizer } from "@tanstack/react-virtual"
+import TableBodyCell from "./TableBodyCell";
+import { flexRender } from "@tanstack/react-table";
+import React from "react";
+import { TableContext } from "../useContext";
+import classNames from "classnames";
+const TableBodyRow = ({
+  tableId,
+  table,
+  row,
+  virtualRow,
+  commandClick,
+  contextMenuItems,
+  onContextMenu,
+  ...rest
+}) => {
+  const {
+    prefix,
+    recordDoubleClick,
+    focusedCell,
+    rowClassName,
+    onRowStyles,
+    groupSetting
+  } = React.useContext(TableContext);
+  const rowClass = typeof rowClassName === 'function' ? rowClassName(row.original, row.index, row.depth) : rowClassName;
+  const rowStyles = typeof onRowStyles === 'function' ? onRowStyles(row.original, row) : onRowStyles;
+  const visibleCells = row.getVisibleCells();
+  const allCells = row.getAllCells();
+  return /*#__PURE__*/React.createElement("tr", _extends({
+    key: row.id,
+    "data-row-key": row.id
+  }, rest, {
+    className: classNames(`${prefix}-grid-row ${rowClass ?? ''}`, {
+      [`${prefix}-grid-row-selected`]: row.getIsSelected(),
+      [`${prefix}-grid-row-focus`]: row.id === focusedCell?.rowId,
+      [`${prefix}-grid-row-parent`]: row.subRows && row.subRows.length > 0
+    }),
+    style: {
+      ...rowStyles
+    },
+    onDoubleClick: e => {
+      recordDoubleClick?.({
+        e,
+        rowData: row.original,
+        rowIndex: row.index
+      });
+    },
+    onContextMenu: e => {
+      if (contextMenuItems && contextMenuItems.length) {
+        onContextMenu?.(row.original)(e);
+      }
+    }
+  }), visibleCells.map(cell => {
+    const nonGroupColumns = visibleCells.filter(col => col.column.id !== 'selection_column' && col.column.id !== '#');
+    const firstNonGroupColumn = nonGroupColumns[0];
+
+    // const colSpan  = row.subRows && cell.column.id === firstNonGroupColumn?.id ? (groupSetting?.groupColumnSpan ?? 2)
+    const colSpan = row.subRows && row.subRows.length > 0 && cell.column.id === firstNonGroupColumn?.column.id ? 2 : row.subRows && nonGroupColumns[1].column.id === cell.column.id ? 0 : 1;
+    if (row.subRows && row.subRows.length > 0 && colSpan === 0) {
+      return null;
+    }
+
+    // if (groupAble && column.field === firstNonGroupColumn?.field && row.subRows) {
+    if (cell.column.id === firstNonGroupColumn.column.id && row.subRows && row.subRows.length > 0) {
+      const {
+        field
+      } = row.original ?? {};
+      const cellGroup = allCells.find(it => it.column.id === field);
+
+      // const header = allColumns.find((it) => it.id === field)
+
+      const headerContext = cellGroup && groupSetting?.showHeaderColumn !== false ? {
+        table,
+        column: cellGroup.column,
+        header: {
+          id: cellGroup.column.id,
+          column: cellGroup.column,
+          depth: 0,
+          index: 0,
+          subHeaders: []
+        }
+      } : undefined;
+      const cellValue = cellGroup ? cellGroup.getValue() : '';
+      const headertext = headerContext && cellGroup ? flexRender(cellGroup.column.columnDef.header, headerContext) : '';
+      const cellContent = cellGroup ? flexRender(cellGroup.column.columnDef.cell, cellGroup.getContext()) : '';
+      const groupValue = typeof groupSetting?.groupTemplate === 'function' ? groupSetting?.groupTemplate({
+        column: cellGroup?.column.columnDef.meta,
+        rowData: row.original,
+        value: cellValue
+      }) : /*#__PURE__*/React.createElement(React.Fragment, null, headertext, headertext ? ': ' : '', " ", cellContent);
+      return /*#__PURE__*/React.createElement(TableBodyCell, {
+        table: table,
+        tableId: tableId,
+        key: cell.id,
+        cell: cell,
+        commandClick: commandClick,
+        virtualRow: virtualRow,
+        isEditing: false,
+        colSpan: colSpan ?? 1,
+        groupValue: groupValue
+      });
+    }
+    return /*#__PURE__*/React.createElement(TableBodyCell, {
+      table: table,
+      tableId: tableId,
+      key: cell.id,
+      cell: cell,
+      commandClick: commandClick,
+      virtualRow: virtualRow,
+      isEditing: false,
+      colSpan: colSpan ?? 1
+    });
+  }));
+};
+export default TableBodyRow;