@dtjoy/dt-design 1.1.2 → 1.1.5

package/es/table/Table.d.ts

@@ -0,0 +1,19 @@
+import { EXPAND_COLUMN } from './constant';
+import type { RefTable } from './interface';
+import Column from './features/columns/Column';
+import ColumnGroup from './features/columns/ColumnGroup';
+import { SELECTION_ALL, SELECTION_COLUMN, SELECTION_INVERT, SELECTION_NONE } from './features/selection/useSelection';
+import Summary from './components/Footer/Summary';
+import './style';
+declare const ForwardTable: RefTable & {
+    displayName?: string;
+    SELECTION_COLUMN: typeof SELECTION_COLUMN;
+    EXPAND_COLUMN: typeof EXPAND_COLUMN;
+    SELECTION_ALL: typeof SELECTION_ALL;
+    SELECTION_INVERT: typeof SELECTION_INVERT;
+    SELECTION_NONE: typeof SELECTION_NONE;
+    Column: typeof Column;
+    ColumnGroup: typeof ColumnGroup;
+    Summary: typeof Summary;
+};
+export default ForwardTable;

package/es/table/Table.js

@@ -0,0 +1,30 @@
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+import * as React from 'react';
+import { EXPAND_COLUMN } from "./constant";
+import Column from "./features/columns/Column";
+import ColumnGroup from "./features/columns/ColumnGroup";
+import { SELECTION_ALL, SELECTION_COLUMN, SELECTION_INVERT, SELECTION_NONE } from "./features/selection/useSelection";
+import InternalTable from "./InternalTable";
+import Summary from "./components/Footer/Summary";
+import "./style";
+var Table = function Table(props, ref) {
+  var renderTimesRef = React.useRef(0);
+  renderTimesRef.current += 1;
+  return /*#__PURE__*/React.createElement(InternalTable, _extends({}, props, {
+    ref: ref,
+    _renderTimes: renderTimesRef.current
+  }));
+};
+var ForwardTable = /*#__PURE__*/React.forwardRef(Table);
+ForwardTable.SELECTION_COLUMN = SELECTION_COLUMN;
+ForwardTable.EXPAND_COLUMN = EXPAND_COLUMN;
+ForwardTable.SELECTION_ALL = SELECTION_ALL;
+ForwardTable.SELECTION_INVERT = SELECTION_INVERT;
+ForwardTable.SELECTION_NONE = SELECTION_NONE;
+ForwardTable.Column = Column;
+ForwardTable.ColumnGroup = ColumnGroup;
+ForwardTable.Summary = Summary;
+if (process.env.NODE_ENV !== 'production') {
+  ForwardTable.displayName = 'Table';
+}
+export default ForwardTable;

package/es/table/TableMeasureRowContext.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const TableMeasureRowContext: React.Context<boolean>;
+export default TableMeasureRowContext;

package/es/table/TableMeasureRowContext.js

@@ -0,0 +1,3 @@
+import React from 'react';
+var TableMeasureRowContext = /*#__PURE__*/React.createContext(false);
+export default TableMeasureRowContext;

package/es/table/components/Body/BodyRow.d.ts

@@ -0,0 +1,37 @@
+import * as React from 'react';
+import useRowInfo from '../../shared/hooks/useRowInfo';
+import type { ColumnType, CustomizeComponent } from '../../interface';
+import type { TableProps } from '../RcTable';
+export interface BodyRowProps<RecordType> {
+    record: RecordType;
+    index: number;
+    renderIndex: number;
+    className?: string;
+    style?: React.CSSProperties;
+    classNames: NonNullable<TableProps['classNames']>['body'];
+    styles: NonNullable<TableProps['styles']>['body'];
+    rowComponent: CustomizeComponent;
+    cellComponent: CustomizeComponent;
+    scopeCellComponent: CustomizeComponent;
+    indent?: number;
+    rowKey: React.Key;
+    rowKeys: React.Key[];
+    expandedRowInfo?: {
+        offset: number;
+        colSpan: number;
+        sticky: number;
+    };
+}
+export declare function getCellProps<RecordType>(rowInfo: ReturnType<typeof useRowInfo<RecordType>>, column: ColumnType<RecordType>, colIndex: number, indent: number, index: number, rowKeys?: React.Key[], expandedRowOffset?: number): {
+    key: React.Key;
+    fixedInfo: import("../..").FixedInfo;
+    appendCellNode: React.ReactNode;
+    additionalCellProps: React.HTMLAttributes<any> & React.TdHTMLAttributes<any>;
+};
+declare const _default: {
+    <RecordType extends {
+        children?: readonly RecordType[];
+    }>(props: BodyRowProps<RecordType>): React.JSX.Element;
+    displayName: string;
+};
+export default _default;

package/es/table/components/Body/BodyRow.js

@@ -0,0 +1,182 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { clsx } from 'clsx';
+import * as React from 'react';
+import Cell from "../Cell";
+import { responseImmutable } from "../../shared/context/TableContext";
+import devRenderTimes from "../../shared/hooks/useRenderTimes";
+import useRowInfo from "../../shared/hooks/useRowInfo";
+import ExpandedRow from "./ExpandedRow";
+import { computedExpandedClassName } from "../../features/expand/expandUtil";
+// ==================================================================================
+// ==                                 getCellProps                                 ==
+// ==================================================================================
+export function getCellProps(rowInfo, column, colIndex, indent, index) {
+  var _column$onCell;
+  var rowKeys = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : [];
+  var expandedRowOffset = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : 0;
+  var record = rowInfo.record,
+    prefixCls = rowInfo.prefixCls,
+    columnsKey = rowInfo.columnsKey,
+    fixedInfoList = rowInfo.fixedInfoList,
+    expandIconColumnIndex = rowInfo.expandIconColumnIndex,
+    nestExpandable = rowInfo.nestExpandable,
+    indentSize = rowInfo.indentSize,
+    expandIcon = rowInfo.expandIcon,
+    expanded = rowInfo.expanded,
+    hasNestChildren = rowInfo.hasNestChildren,
+    onTriggerExpand = rowInfo.onTriggerExpand,
+    expandable = rowInfo.expandable,
+    expandedKeys = rowInfo.expandedKeys;
+  var key = columnsKey[colIndex];
+  var fixedInfo = fixedInfoList[colIndex];
+
+  // ============= Used for nest expandable =============
+  var appendCellNode;
+  if (colIndex === (expandIconColumnIndex || 0) && nestExpandable) {
+    appendCellNode = /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("span", {
+      style: {
+        paddingLeft: "".concat(indentSize * indent, "px")
+      },
+      className: "".concat(prefixCls, "-row-indent indent-level-").concat(indent)
+    }), expandIcon({
+      prefixCls: prefixCls,
+      expanded: expanded,
+      expandable: hasNestChildren,
+      record: record,
+      onExpand: onTriggerExpand
+    }));
+  }
+  var additionalCellProps = ((_column$onCell = column.onCell) === null || _column$onCell === void 0 ? void 0 : _column$onCell.call(column, record, index)) || {};
+
+  // Expandable row has offset
+  if (expandedRowOffset) {
+    var _additionalCellProps$ = additionalCellProps.rowSpan,
+      rowSpan = _additionalCellProps$ === void 0 ? 1 : _additionalCellProps$;
+
+    // For expandable row with rowSpan,
+    // We should increase the rowSpan if the row is expanded
+    if (expandable && rowSpan && colIndex < expandedRowOffset) {
+      var currentRowSpan = rowSpan;
+      for (var i = index; i < index + rowSpan; i += 1) {
+        var rowKey = rowKeys[i];
+        if (expandedKeys.has(rowKey)) {
+          currentRowSpan += 1;
+        }
+      }
+      additionalCellProps.rowSpan = currentRowSpan;
+    }
+  }
+  return {
+    key: key,
+    fixedInfo: fixedInfo,
+    appendCellNode: appendCellNode,
+    additionalCellProps: additionalCellProps
+  };
+}
+
+// ==================================================================================
+// ==                                 getCellProps                                 ==
+// ==================================================================================
+var BodyRow = function BodyRow(props) {
+  if (process.env.NODE_ENV !== 'production') {
+    devRenderTimes(props);
+  }
+  var className = props.className,
+    style = props.style,
+    _props$classNames = props.classNames,
+    classNames = _props$classNames === void 0 ? {} : _props$classNames,
+    _props$styles = props.styles,
+    styles = _props$styles === void 0 ? {} : _props$styles,
+    record = props.record,
+    index = props.index,
+    renderIndex = props.renderIndex,
+    rowKey = props.rowKey,
+    rowKeys = props.rowKeys,
+    _props$indent = props.indent,
+    indent = _props$indent === void 0 ? 0 : _props$indent,
+    RowComponent = props.rowComponent,
+    cellComponent = props.cellComponent,
+    scopeCellComponent = props.scopeCellComponent,
+    expandedRowInfo = props.expandedRowInfo;
+  var rowInfo = useRowInfo(record, rowKey, index, indent);
+  var prefixCls = rowInfo.prefixCls,
+    flattenColumns = rowInfo.flattenColumns,
+    expandedRowClassName = rowInfo.expandedRowClassName,
+    expandedRowRender = rowInfo.expandedRowRender,
+    rowProps = rowInfo.rowProps,
+    expanded = rowInfo.expanded,
+    rowSupportExpand = rowInfo.rowSupportExpand;
+
+  // Force render expand row if expanded before
+  var expandedRef = React.useRef(false);
+  expandedRef.current || (expandedRef.current = expanded);
+  if (process.env.NODE_ENV !== 'production') {
+    devRenderTimes(props);
+  }
+
+  // 若没有 expandedRowRender 参数, 将使用 baseRowNode 渲染 Children
+  // 此时如果 level > 1 则说明是 expandedRow, 一样需要附加 computedExpandedRowClassName
+  var expandedClsName = computedExpandedClassName(expandedRowClassName, record, index, indent);
+
+  // ======================== Base tr row ========================
+  var baseRowNode = /*#__PURE__*/React.createElement(RowComponent, _extends({}, rowProps, {
+    "data-row-key": rowKey,
+    className: clsx(className, "".concat(prefixCls, "-row"), "".concat(prefixCls, "-row-level-").concat(indent), rowProps === null || rowProps === void 0 ? void 0 : rowProps.className, classNames.row, _defineProperty({}, expandedClsName, indent >= 1)),
+    style: _objectSpread(_objectSpread(_objectSpread({}, style), rowProps === null || rowProps === void 0 ? void 0 : rowProps.style), styles.row)
+  }), flattenColumns.map(function (column, colIndex) {
+    var render = column.render,
+      dataIndex = column.dataIndex,
+      columnClassName = column.className;
+    var _getCellProps = getCellProps(rowInfo, column, colIndex, indent, index, rowKeys, expandedRowInfo === null || expandedRowInfo === void 0 ? void 0 : expandedRowInfo.offset),
+      key = _getCellProps.key,
+      fixedInfo = _getCellProps.fixedInfo,
+      appendCellNode = _getCellProps.appendCellNode,
+      additionalCellProps = _getCellProps.additionalCellProps;
+    return /*#__PURE__*/React.createElement(Cell, _extends({
+      className: clsx(columnClassName, classNames.cell),
+      style: styles.cell,
+      ellipsis: column.ellipsis,
+      align: column.align,
+      scope: column.rowScope,
+      component: column.rowScope ? scopeCellComponent : cellComponent,
+      prefixCls: prefixCls,
+      key: key,
+      record: record,
+      index: index,
+      renderIndex: renderIndex,
+      dataIndex: dataIndex,
+      render: render,
+      shouldCellUpdate: column.shouldCellUpdate
+    }, fixedInfo, {
+      appendNode: appendCellNode,
+      additionalProps: additionalCellProps
+    }));
+  }));
+
+  // ======================== Expand Row =========================
+  var expandRowNode;
+  if (rowSupportExpand && (expandedRef.current || expanded)) {
+    var expandContent = expandedRowRender(record, index, indent + 1, expanded);
+    expandRowNode = /*#__PURE__*/React.createElement(ExpandedRow, {
+      expanded: expanded,
+      className: clsx("".concat(prefixCls, "-expanded-row"), "".concat(prefixCls, "-expanded-row-level-").concat(indent + 1), expandedClsName),
+      prefixCls: prefixCls,
+      component: RowComponent,
+      cellComponent: cellComponent,
+      colSpan: expandedRowInfo ? expandedRowInfo.colSpan : flattenColumns.length,
+      isEmpty: false,
+      stickyOffset: expandedRowInfo === null || expandedRowInfo === void 0 ? void 0 : expandedRowInfo.sticky
+    }, expandContent);
+  }
+  return /*#__PURE__*/React.createElement(React.Fragment, null, baseRowNode, expandRowNode);
+};
+if (process.env.NODE_ENV !== 'production') {
+  BodyRow.displayName = 'BodyRow';
+}
+export default responseImmutable(BodyRow);

package/es/table/components/Body/ExpandedRow.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import type { CustomizeComponent } from '../../interface';
+export interface ExpandedRowProps {
+    prefixCls: string;
+    component: CustomizeComponent;
+    cellComponent: CustomizeComponent;
+    className: string;
+    expanded: boolean;
+    children: React.ReactNode;
+    colSpan: number;
+    isEmpty: boolean;
+    stickyOffset?: number;
+}
+declare const ExpandedRow: React.FC<ExpandedRowProps>;
+export default ExpandedRow;

package/es/table/components/Body/ExpandedRow.js

@@ -0,0 +1,51 @@
+import { useContext } from "../../../_util/context";
+import * as React from 'react';
+import Cell from "../Cell";
+import TableContext from "../../shared/context/TableContext";
+import devRenderTimes from "../../shared/hooks/useRenderTimes";
+var ExpandedRow = function ExpandedRow(props) {
+  if (process.env.NODE_ENV !== 'production') {
+    devRenderTimes(props);
+  }
+  var prefixCls = props.prefixCls,
+    children = props.children,
+    Component = props.component,
+    cellComponent = props.cellComponent,
+    className = props.className,
+    expanded = props.expanded,
+    colSpan = props.colSpan,
+    isEmpty = props.isEmpty,
+    _props$stickyOffset = props.stickyOffset,
+    stickyOffset = _props$stickyOffset === void 0 ? 0 : _props$stickyOffset;
+  var _useContext = useContext(TableContext, ['scrollbarSize', 'fixHeader', 'fixColumn', 'componentWidth', 'horizonScroll']),
+    scrollbarSize = _useContext.scrollbarSize,
+    fixHeader = _useContext.fixHeader,
+    fixColumn = _useContext.fixColumn,
+    componentWidth = _useContext.componentWidth,
+    horizonScroll = _useContext.horizonScroll;
+
+  // Cache render node
+  var contentNode = children;
+  if (isEmpty ? horizonScroll && componentWidth : fixColumn) {
+    contentNode = /*#__PURE__*/React.createElement("div", {
+      style: {
+        width: componentWidth - stickyOffset - (fixHeader && !isEmpty ? scrollbarSize : 0),
+        position: 'sticky',
+        left: stickyOffset,
+        overflow: 'hidden'
+      },
+      className: "".concat(prefixCls, "-expanded-row-fixed")
+    }, contentNode);
+  }
+  return /*#__PURE__*/React.createElement(Component, {
+    className: className,
+    style: {
+      display: expanded ? undefined : 'none'
+    }
+  }, /*#__PURE__*/React.createElement(Cell, {
+    component: cellComponent,
+    prefixCls: prefixCls,
+    colSpan: colSpan
+  }, contentNode));
+};
+export default ExpandedRow;

package/es/table/components/Body/MeasureCell.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+export interface MeasureCellProps {
+    columnKey: React.Key;
+    onColumnResize: (key: React.Key, width: number) => void;
+    title?: React.ReactNode;
+}
+declare const MeasureCell: React.FC<MeasureCellProps>;
+export default MeasureCell;

package/es/table/components/Body/MeasureCell.js

@@ -0,0 +1,33 @@
+import * as React from 'react';
+import ResizeObserver from 'rc-resize-observer';
+import useLayoutEffect from "../../../_util/hooks/useLayoutEffect";
+var MeasureCell = function MeasureCell(props) {
+  var columnKey = props.columnKey,
+    onColumnResize = props.onColumnResize,
+    title = props.title;
+  var cellRef = React.useRef(null);
+  useLayoutEffect(function () {
+    if (cellRef.current) {
+      onColumnResize(columnKey, cellRef.current.offsetWidth);
+    }
+  }, [columnKey, onColumnResize]);
+  return /*#__PURE__*/React.createElement(ResizeObserver, {
+    data: columnKey
+  }, /*#__PURE__*/React.createElement("td", {
+    ref: cellRef,
+    style: {
+      paddingTop: 0,
+      paddingBottom: 0,
+      borderTop: 0,
+      borderBottom: 0,
+      height: 0
+    }
+  }, /*#__PURE__*/React.createElement("div", {
+    style: {
+      height: 0,
+      overflow: 'hidden',
+      fontWeight: 'bold'
+    }
+  }, title || '\xA0')));
+};
+export default MeasureCell;

package/es/table/components/Body/MeasureRow.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import type { ColumnType } from '../../interface';
+export interface MeasureRowProps {
+    prefixCls: string;
+    onColumnResize: (key: React.Key, width: number) => void;
+    columnsKey: React.Key[];
+    columns: readonly ColumnType<any>[];
+}
+declare const MeasureRow: React.FC<MeasureRowProps>;
+export default MeasureRow;

package/es/table/components/Body/MeasureRow.js

@@ -0,0 +1,54 @@
+import * as React from 'react';
+import ResizeObserver from 'rc-resize-observer';
+import MeasureCell from "./MeasureCell";
+import isVisible from 'rc-util/lib/Dom/isVisible';
+import { useContext } from "../../../_util/context";
+import TableContext from "../../shared/context/TableContext";
+import TableMeasureRowContext from "../../TableMeasureRowContext";
+var MeasureRow = function MeasureRow(_ref) {
+  var prefixCls = _ref.prefixCls,
+    columnsKey = _ref.columnsKey,
+    onColumnResize = _ref.onColumnResize,
+    columns = _ref.columns;
+  var ref = React.useRef(null);
+  var _useContext = useContext(TableContext, ['measureRowRender']),
+    measureRowRender = _useContext.measureRowRender;
+  var measureRow = /*#__PURE__*/React.createElement("tr", {
+    className: "".concat(prefixCls, "-measure-row"),
+    style: {
+      height: 0,
+      visibility: 'hidden'
+    },
+    ref: ref
+  }, /*#__PURE__*/React.createElement(ResizeObserver.Collection, {
+    onBatchResize: function onBatchResize(infoList) {
+      if (ref.current && isVisible(ref.current)) {
+        infoList.forEach(function (_ref2) {
+          var columnKey = _ref2.data,
+            size = _ref2.size;
+          onColumnResize(columnKey, size.offsetWidth);
+        });
+      }
+    }
+  }, columnsKey.map(function (columnKey) {
+    var column = columns.find(function (col) {
+      return col.key === columnKey;
+    });
+    var rawTitle = column === null || column === void 0 ? void 0 : column.title;
+    // `title` can be a render function per `ColumnTitle`; `MeasureCell` only renders ReactNode
+    var titleForMeasure = /*#__PURE__*/React.isValidElement(rawTitle) ? /*#__PURE__*/React.cloneElement(rawTitle, {
+      ref: null
+    }) : rawTitle;
+    return /*#__PURE__*/React.createElement(MeasureCell, {
+      key: columnKey,
+      columnKey: columnKey,
+      onColumnResize: onColumnResize,
+      title: titleForMeasure
+    });
+  })));
+  var row = /*#__PURE__*/React.createElement(TableMeasureRowContext.Provider, {
+    value: true
+  }, measureRow);
+  return typeof measureRowRender === 'function' ? measureRowRender(row) : row;
+};
+export default MeasureRow;

package/es/table/components/Body/index.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import type { DefaultRecordType } from '../../interface';
+export interface BodyProps<RecordType> {
+    data: readonly RecordType[];
+    measureColumnWidth: boolean;
+}
+declare const _default: {
+    <RecordType extends DefaultRecordType>(props: BodyProps<RecordType>): React.JSX.Element;
+    displayName: string;
+};
+export default _default;

package/es/table/components/Body/index.js

@@ -0,0 +1,123 @@
+import { useContext } from "../../../_util/context";
+import * as React from 'react';
+import { clsx } from 'clsx';
+import PerfContext from "../../shared/context/PerfContext";
+import TableContext, { responseImmutable } from "../../shared/context/TableContext";
+import useFlattenRecords from "../../features/virtual/useFlattenRecords";
+import devRenderTimes from "../../shared/hooks/useRenderTimes";
+import { getColumnsKey } from "../../shared/utils/valueUtil";
+import BodyRow from "./BodyRow";
+import ExpandedRow from "./ExpandedRow";
+import MeasureRow from "./MeasureRow";
+var Body = function Body(props) {
+  if (process.env.NODE_ENV !== 'production') {
+    devRenderTimes(props);
+  }
+  var data = props.data,
+    measureColumnWidth = props.measureColumnWidth;
+  var _useContext = useContext(TableContext, ['prefixCls', 'getComponent', 'onColumnResize', 'flattenColumns', 'getRowKey', 'expandedKeys', 'childrenColumnName', 'emptyNode', 'classNames', 'styles', 'expandedRowOffset', 'fixedInfoList', 'colWidths']),
+    prefixCls = _useContext.prefixCls,
+    getComponent = _useContext.getComponent,
+    onColumnResize = _useContext.onColumnResize,
+    flattenColumns = _useContext.flattenColumns,
+    getRowKey = _useContext.getRowKey,
+    expandedKeys = _useContext.expandedKeys,
+    childrenColumnName = _useContext.childrenColumnName,
+    emptyNode = _useContext.emptyNode,
+    classNames = _useContext.classNames,
+    styles = _useContext.styles,
+    _useContext$expandedR = _useContext.expandedRowOffset,
+    expandedRowOffset = _useContext$expandedR === void 0 ? 0 : _useContext$expandedR,
+    colWidths = _useContext.colWidths;
+  var _ref = classNames || {},
+    _ref$body = _ref.body,
+    bodyCls = _ref$body === void 0 ? {} : _ref$body;
+  var _ref2 = styles || {},
+    _ref2$body = _ref2.body,
+    bodyStyles = _ref2$body === void 0 ? {} : _ref2$body;
+  var flattenData = useFlattenRecords(data, childrenColumnName, expandedKeys, getRowKey);
+  var rowKeys = React.useMemo(function () {
+    return flattenData.map(function (item) {
+      return item.rowKey;
+    });
+  }, [flattenData]);
+
+  // =================== Performance ====================
+  var perfRef = React.useRef({
+    renderWithProps: false
+  });
+
+  // ===================== Expanded =====================
+  // `expandedRowOffset` data is same for all the rows.
+  // Let's calc on Body side to save performance.
+  var expandedRowInfo = React.useMemo(function () {
+    var expandedColSpan = flattenColumns.length - expandedRowOffset;
+    var expandedStickyStart = 0;
+    for (var i = 0; i < expandedRowOffset; i += 1) {
+      expandedStickyStart += colWidths[i] || 0;
+    }
+    return {
+      offset: expandedRowOffset,
+      colSpan: expandedColSpan,
+      sticky: expandedStickyStart
+    };
+  }, [flattenColumns.length, expandedRowOffset, colWidths]);
+
+  // ====================== Render ======================
+  var WrapperComponent = getComponent(['body', 'wrapper'], 'tbody');
+  var trComponent = getComponent(['body', 'row'], 'tr');
+  var tdComponent = getComponent(['body', 'cell'], 'td');
+  var thComponent = getComponent(['body', 'cell'], 'th');
+  var rows;
+  if (data.length) {
+    rows = flattenData.map(function (item, idx) {
+      var record = item.record,
+        indent = item.indent,
+        renderIndex = item.index,
+        rowKey = item.rowKey;
+      return /*#__PURE__*/React.createElement(BodyRow, {
+        classNames: bodyCls,
+        styles: bodyStyles,
+        key: rowKey,
+        rowKey: rowKey,
+        rowKeys: rowKeys,
+        record: record,
+        index: idx,
+        renderIndex: renderIndex,
+        rowComponent: trComponent,
+        cellComponent: tdComponent,
+        scopeCellComponent: thComponent,
+        indent: indent
+        // Expanded row info
+        ,
+        expandedRowInfo: expandedRowInfo
+      });
+    });
+  } else {
+    rows = /*#__PURE__*/React.createElement(ExpandedRow, {
+      expanded: true,
+      className: "".concat(prefixCls, "-placeholder"),
+      prefixCls: prefixCls,
+      component: trComponent,
+      cellComponent: tdComponent,
+      colSpan: flattenColumns.length,
+      isEmpty: true
+    }, emptyNode);
+  }
+  var columnsKey = getColumnsKey(flattenColumns);
+  return /*#__PURE__*/React.createElement(PerfContext.Provider, {
+    value: perfRef.current
+  }, /*#__PURE__*/React.createElement(WrapperComponent, {
+    style: bodyStyles.wrapper,
+    className: clsx("".concat(prefixCls, "-tbody"), bodyCls.wrapper)
+  }, measureColumnWidth && /*#__PURE__*/React.createElement(MeasureRow, {
+    prefixCls: prefixCls,
+    columnsKey: columnsKey,
+    onColumnResize: onColumnResize,
+    columns: flattenColumns
+  }), rows));
+};
+if (process.env.NODE_ENV !== 'production') {
+  Body.displayName = 'Body';
+}
+export default responseImmutable(Body);

package/es/table/components/Cell/index.d.ts

@@ -0,0 +1,39 @@
+import * as React from 'react';
+import type { AlignType, CellEllipsisType, ColumnType, CustomizeComponent, DataIndex, ScopeType } from '../../interface';
+export interface CellProps<RecordType> {
+    prefixCls?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    record?: RecordType;
+    /** `column` index is the real show rowIndex */
+    index?: number;
+    /** the index of the record. For the render(value, record, renderIndex) */
+    renderIndex?: number;
+    dataIndex?: DataIndex<RecordType>;
+    render?: ColumnType<RecordType>['render'];
+    component?: CustomizeComponent;
+    children?: React.ReactNode;
+    colSpan?: number;
+    rowSpan?: number;
+    scope?: ScopeType;
+    ellipsis?: CellEllipsisType;
+    align?: AlignType;
+    shouldCellUpdate?: (record: RecordType, prevRecord: RecordType) => boolean;
+    fixStart?: number | false;
+    fixEnd?: number | false;
+    fixedStartShadow?: boolean;
+    fixedEndShadow?: boolean;
+    offsetFixedStartShadow?: number;
+    offsetFixedEndShadow?: number;
+    zIndex?: number;
+    zIndexReverse?: number;
+    allColsFixedLeft?: boolean;
+    /** @private Used for `expandable` with nest tree */
+    appendNode?: React.ReactNode;
+    additionalProps?: React.TdHTMLAttributes<HTMLTableCellElement>;
+    rowType?: 'header' | 'body' | 'footer';
+    isSticky?: boolean;
+}
+declare const Cell: <RecordType>(props: CellProps<RecordType>) => React.JSX.Element | null;
+declare const _default: typeof Cell;
+export default _default;