@dtjoy/dt-design 1.1.2 → 1.1.5

package/es/table/components/RcTable.js

@@ -0,0 +1,757 @@
+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 _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+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); }
+/**
+ * Feature:
+ *  - fixed not need to set width
+ *  - support `rowExpandable` to config row expand logic
+ *  - add `summary` to support `() => ReactNode`
+ *
+ * Update:
+ *  - `dataIndex` is `array[]` now
+ *  - `expandable` wrap all the expand related props
+ *
+ * Removed:
+ *  - expandIconAsCell
+ *  - useFixedHeader
+ *  - rowRef
+ *  - columns[number].onCellClick
+ *  - onRowClick
+ *  - onRowDoubleClick
+ *  - onRowMouseEnter
+ *  - onRowMouseLeave
+ *  - getBodyWrapper
+ *  - bodyStyle
+ *
+ * Deprecated:
+ *  - All expanded props, move into expandable
+ */
+
+import { clsx } from 'clsx';
+import ResizeObserver from 'rc-resize-observer';
+import { getDOM } from 'rc-util/lib/Dom/findDOMNode';
+import getValue from 'rc-util/lib/utils/get';
+import { getTargetScrollBarSize } from 'rc-util/lib/getScrollBarSize';
+import isEqual from 'rc-util/lib/isEqual';
+import { pickAttrs } from "../../_util/rcUtil";
+import useEvent from "../../_util/hooks/useEvent";
+import useLayoutEffect from "../../_util/hooks/useLayoutEffect";
+import warning from 'rc-util/lib/warning';
+import * as React from 'react';
+import Body from "./Body";
+import ColGroup from "./ColGroup";
+import { INTERNAL_HOOKS } from "../constant";
+import TableContext, { makeImmutable } from "../shared/context/TableContext";
+import FixedHolder from "./FixedHolder";
+import Footer from "./Footer";
+import Summary from "./Footer/Summary";
+import Header from "./Header/Header";
+import useColumns from "../features/columns/useColumns";
+import useExpand from "../features/expand/useExpand";
+import useFixedInfo from "../features/fixed/useFixedInfo";
+import { useTimeoutLock } from "../features/virtual/useFrame";
+import useHover from "../features/hover/useHover";
+import useSticky from "../features/sticky/useSticky";
+import useStickyOffsets from "../features/fixed/useStickyOffsets";
+import Panel from "./Panel";
+import StickyScrollBar from "../features/sticky/stickyScrollBar";
+import { getColumnsKey, validateValue, validNumberValue } from "../shared/utils/valueUtil";
+export var DEFAULT_PREFIX = 'rc-table';
+
+// Used for conditions cache
+var EMPTY_DATA = [];
+
+// Used for customize scroll
+var EMPTY_SCROLL_TARGET = {};
+function defaultEmpty() {
+  return 'No Data';
+}
+var Table = function Table(tableProps, ref) {
+  var _flattenColumns$, _flattenColumns, _clsx, _styles$title, _styles$footer;
+  var props = _objectSpread({
+    rowKey: 'key',
+    prefixCls: DEFAULT_PREFIX,
+    emptyText: defaultEmpty
+  }, tableProps);
+  var prefixCls = props.prefixCls,
+    className = props.className,
+    rowClassName = props.rowClassName,
+    style = props.style,
+    classNames = props.classNames,
+    styles = props.styles,
+    data = props.data,
+    rowKey = props.rowKey,
+    scroll = props.scroll,
+    tableLayout = props.tableLayout,
+    direction = props.direction,
+    title = props.title,
+    footer = props.footer,
+    summary = props.summary,
+    caption = props.caption,
+    id = props.id,
+    showHeader = props.showHeader,
+    components = props.components,
+    emptyText = props.emptyText,
+    onRow = props.onRow,
+    onHeaderRow = props.onHeaderRow,
+    measureRowRender = props.measureRowRender,
+    onScroll = props.onScroll,
+    internalHooks = props.internalHooks,
+    transformColumns = props.transformColumns,
+    internalRefs = props.internalRefs,
+    tailor = props.tailor,
+    getContainerWidth = props.getContainerWidth,
+    sticky = props.sticky,
+    _props$rowHoverable = props.rowHoverable,
+    rowHoverable = _props$rowHoverable === void 0 ? true : _props$rowHoverable;
+  var mergedData = data || EMPTY_DATA;
+  var hasData = !!mergedData.length;
+  var useInternalHooks = internalHooks === INTERNAL_HOOKS;
+
+  // ===================== Warning ======================
+  if (process.env.NODE_ENV !== 'production') {
+    ['onRowClick', 'onRowDoubleClick', 'onRowContextMenu', 'onRowMouseEnter', 'onRowMouseLeave'].forEach(function (name) {
+      warning(props[name] === undefined, "`".concat(name, "` is removed, please use `onRow` instead."));
+    });
+    warning(!('getBodyWrapper' in props), '`getBodyWrapper` is deprecated, please use custom `components` instead.');
+  }
+
+  // ==================== Customize =====================
+  var getComponent = React.useCallback(function (path, defaultComponent) {
+    return getValue(components, path) || defaultComponent;
+  }, [components]);
+  var getRowKey = React.useMemo(function () {
+    if (typeof rowKey === 'function') {
+      return rowKey;
+    }
+    return function (record) {
+      var key = record && record[rowKey];
+      if (process.env.NODE_ENV !== 'production') {
+        warning(key !== undefined, 'Each record in table should have a unique `key` prop, or set `rowKey` to an unique primary key.');
+      }
+      return key;
+    };
+  }, [rowKey]);
+  var customizeScrollBody = getComponent(['body']);
+
+  // ====================== Hover =======================
+  var _useHover = useHover(),
+    _useHover2 = _slicedToArray(_useHover, 3),
+    startRow = _useHover2[0],
+    endRow = _useHover2[1],
+    onHover = _useHover2[2];
+
+  // ====================== Expand ======================
+  var _useExpand = useExpand(props, mergedData, getRowKey),
+    _useExpand2 = _slicedToArray(_useExpand, 6),
+    expandableConfig = _useExpand2[0],
+    expandableType = _useExpand2[1],
+    mergedExpandedKeys = _useExpand2[2],
+    mergedExpandIcon = _useExpand2[3],
+    mergedChildrenColumnName = _useExpand2[4],
+    onTriggerExpand = _useExpand2[5];
+
+  // ====================== Column ======================
+  var scrollX = scroll === null || scroll === void 0 ? void 0 : scroll.x;
+  var _React$useState = React.useState(0),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    componentWidth = _React$useState2[0],
+    setComponentWidth = _React$useState2[1];
+  var _useColumns = useColumns(_objectSpread(_objectSpread(_objectSpread({}, props), expandableConfig), {}, {
+      expandable: !!expandableConfig.expandedRowRender,
+      columnTitle: expandableConfig.columnTitle,
+      expandedKeys: mergedExpandedKeys,
+      getRowKey: getRowKey,
+      // https://github.com/ant-design/ant-design/issues/23894
+      onTriggerExpand: onTriggerExpand,
+      expandIcon: mergedExpandIcon,
+      expandIconColumnIndex: expandableConfig.expandIconColumnIndex,
+      direction: direction,
+      scrollWidth: useInternalHooks && tailor && typeof scrollX === 'number' ? scrollX : undefined,
+      clientWidth: componentWidth
+    }),
+    // `useColumns` guards the call with `if (transformColumns)`, so `null`
+    // ("no transform") is a valid runtime value here.
+    useInternalHooks ? transformColumns : null),
+    _useColumns2 = _slicedToArray(_useColumns, 3),
+    columns = _useColumns2[0],
+    flattenColumns = _useColumns2[1],
+    flattenScrollX = _useColumns2[2];
+  var mergedScrollX = flattenScrollX !== null && flattenScrollX !== void 0 ? flattenScrollX : scrollX;
+  var columnContext = React.useMemo(function () {
+    return {
+      columns: columns,
+      flattenColumns: flattenColumns
+    };
+  }, [columns, flattenColumns]);
+
+  // ======================= Refs =======================
+  var fullTableRef = React.useRef(null);
+  var scrollHeaderRef = React.useRef(null);
+  var scrollBodyRef = React.useRef(null);
+  var scrollBodyContainerRef = React.useRef(null);
+  React.useImperativeHandle(ref, function () {
+    return {
+      nativeElement: fullTableRef.current,
+      scrollTo: function scrollTo(config) {
+        var _scrollBodyRef$curren2;
+        if (scrollBodyRef.current instanceof HTMLElement) {
+          // Native scroll
+          var index = config.index,
+            top = config.top,
+            key = config.key,
+            offset = config.offset,
+            _config$align = config.align,
+            align = _config$align === void 0 ? 'nearest' : _config$align;
+          if (validNumberValue(top)) {
+            var _scrollBodyRef$curren;
+            // In top mode, offset is ignored
+            (_scrollBodyRef$curren = scrollBodyRef.current) === null || _scrollBodyRef$curren === void 0 || _scrollBodyRef$curren.scrollTo({
+              top: top
+            });
+          } else {
+            var mergedKey = key !== null && key !== void 0 ? key : index !== undefined ? getRowKey(mergedData[index]) : undefined;
+            var targetElement = scrollBodyRef.current.querySelector("[data-row-key=\"".concat(mergedKey, "\"]"));
+            if (targetElement) {
+              targetElement.scrollIntoView({
+                block: align
+              });
+              if (offset) {
+                var _container = scrollBodyRef.current;
+                _container.scrollTo({
+                  top: _container.scrollTop + offset
+                });
+              }
+            }
+          }
+        } else if ((_scrollBodyRef$curren2 = scrollBodyRef.current) !== null && _scrollBodyRef$curren2 !== void 0 && _scrollBodyRef$curren2.scrollTo) {
+          // Pass to proxy
+          scrollBodyRef.current.scrollTo(config);
+        }
+      }
+      // `validate` / `resetErrors` / `resetColumnWidths` are provided by the
+      // `InternalTable` wrapper, which spreads this handle and overrides them
+      // (see InternalTable.tsx). `nativeElement` is attached after mount.
+    };
+  });
+
+  // ====================== Scroll ======================
+  var scrollSummaryRef = React.useRef(null);
+  var _React$useState3 = React.useState(false),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    shadowStart = _React$useState4[0],
+    setShadowStart = _React$useState4[1];
+  var _React$useState5 = React.useState(false),
+    _React$useState6 = _slicedToArray(_React$useState5, 2),
+    shadowEnd = _React$useState6[0],
+    setShadowEnd = _React$useState6[1];
+  var _React$useState7 = React.useState(function () {
+      return new Map();
+    }),
+    _React$useState8 = _slicedToArray(_React$useState7, 2),
+    colsWidths = _React$useState8[0],
+    updateColsWidths = _React$useState8[1];
+
+  // Convert map to number width
+  var colsKeys = getColumnsKey(flattenColumns);
+  var pureColWidths = colsKeys.map(function (columnKey) {
+    return colsWidths.get(columnKey);
+  });
+  // `Map.get` may yield `undefined` for unmeasured columns; all consumers
+  // (`useStickyOffsets`, `FixedHolder`, `ColGroup`) tolerate that at runtime.
+  var colWidths = React.useMemo(function () {
+    return pureColWidths;
+  }, [pureColWidths.join('_')]);
+  var stickyOffsets = useStickyOffsets(colWidths, flattenColumns);
+  var fixHeader = !!scroll && validateValue(scroll.y);
+  var horizonScroll = scroll && validateValue(mergedScrollX) || Boolean(expandableConfig.fixed);
+  var fixColumn = horizonScroll && flattenColumns.some(function (_ref) {
+    var fixed = _ref.fixed;
+    return fixed;
+  });
+
+  // Sticky
+  var stickyRef = React.useRef(null);
+  var _useSticky = useSticky(sticky !== null && sticky !== void 0 ? sticky : false, prefixCls),
+    isSticky = _useSticky.isSticky,
+    offsetHeader = _useSticky.offsetHeader,
+    offsetSummary = _useSticky.offsetSummary,
+    offsetScroll = _useSticky.offsetScroll,
+    stickyClassName = _useSticky.stickyClassName,
+    container = _useSticky.container;
+
+  // Footer (Fix footer must fixed header)
+  var summaryNode = React.useMemo(function () {
+    return summary === null || summary === void 0 ? void 0 : summary(mergedData);
+  }, [summary, mergedData]);
+  var fixFooter = (fixHeader || isSticky) && /*#__PURE__*/React.isValidElement(summaryNode) && summaryNode.type === Summary && summaryNode.props.fixed;
+
+  // Scroll
+  var scrollXStyle = {};
+  var scrollYStyle = {};
+  var scrollTableStyle = {};
+  if (fixHeader) {
+    scrollYStyle = {
+      overflowY: hasData ? 'scroll' : 'auto',
+      maxHeight: scroll.y
+    };
+  }
+  if (horizonScroll) {
+    scrollXStyle = {
+      overflowX: 'auto'
+    };
+    // When no vertical scrollbar, should hide it
+    // https://github.com/ant-design/ant-design/pull/20705
+    // https://github.com/ant-design/ant-design/issues/21879
+    if (!fixHeader) {
+      scrollYStyle = {
+        overflowY: 'hidden'
+      };
+    }
+    scrollTableStyle = {
+      width: mergedScrollX === true ? 'auto' : mergedScrollX,
+      minWidth: '100%'
+    };
+  }
+  var onColumnResize = React.useCallback(function (columnKey, width) {
+    updateColsWidths(function (widths) {
+      if (widths.get(columnKey) !== width) {
+        var newWidths = new Map(widths);
+        newWidths.set(columnKey, width);
+        return newWidths;
+      }
+      return widths;
+    });
+  }, []);
+  var _useTimeoutLock = useTimeoutLock(null),
+    _useTimeoutLock2 = _slicedToArray(_useTimeoutLock, 2),
+    setScrollTarget = _useTimeoutLock2[0],
+    getScrollTarget = _useTimeoutLock2[1];
+  function forceScroll(scrollLeft, target) {
+    if (!target) {
+      return;
+    }
+    if (typeof target === 'function') {
+      target(scrollLeft);
+    } else if (target.scrollLeft !== scrollLeft) {
+      target.scrollLeft = scrollLeft;
+
+      // Delay to force scroll position if not sync
+      // ref: https://github.com/ant-design/ant-design/issues/37179
+      if (target.scrollLeft !== scrollLeft) {
+        setTimeout(function () {
+          target.scrollLeft = scrollLeft;
+        }, 0);
+      }
+    }
+  }
+  var _React$useState9 = React.useState([0, 0]),
+    _React$useState10 = _slicedToArray(_React$useState9, 2),
+    scrollInfo = _React$useState10[0],
+    setScrollInfo = _React$useState10[1];
+  var onInternalScroll = useEvent(function (_ref2) {
+    var _currentTarget$scroll;
+    var currentTarget = _ref2.currentTarget,
+      scrollLeft = _ref2.scrollLeft;
+    var mergedScrollLeft = typeof scrollLeft === 'number' ? scrollLeft : (_currentTarget$scroll = currentTarget === null || currentTarget === void 0 ? void 0 : currentTarget.scrollLeft) !== null && _currentTarget$scroll !== void 0 ? _currentTarget$scroll : 0;
+    var compareTarget = currentTarget || EMPTY_SCROLL_TARGET;
+    if (!getScrollTarget() || getScrollTarget() === compareTarget) {
+      var _stickyRef$current;
+      setScrollTarget(compareTarget);
+      forceScroll(mergedScrollLeft, scrollHeaderRef.current);
+      forceScroll(mergedScrollLeft, scrollBodyRef.current);
+      forceScroll(mergedScrollLeft, scrollSummaryRef.current);
+      forceScroll(mergedScrollLeft, (_stickyRef$current = stickyRef.current) === null || _stickyRef$current === void 0 ? void 0 : _stickyRef$current.setScrollLeft);
+    }
+    var measureTarget = currentTarget || scrollHeaderRef.current;
+    if (measureTarget) {
+      var scrollWidth =
+      // Should use mergedScrollX in virtual table(useInternalHooks && tailor === true)
+      useInternalHooks && tailor && typeof mergedScrollX === 'number' ? mergedScrollX : measureTarget.scrollWidth;
+      var clientWidth = measureTarget.clientWidth;
+      var absScrollStart = Math.abs(mergedScrollLeft);
+      setScrollInfo(function (ori) {
+        var nextScrollInfo = [absScrollStart, scrollWidth - clientWidth];
+        return isEqual(ori, nextScrollInfo) ? ori : nextScrollInfo;
+      });
+
+      // There is no space to scroll
+      if (scrollWidth === clientWidth) {
+        setShadowStart(false);
+        setShadowEnd(false);
+        return;
+      }
+      setShadowStart(absScrollStart > 0);
+      setShadowEnd(absScrollStart < scrollWidth - clientWidth - 1);
+    }
+  });
+  var onBodyScroll = useEvent(function (e) {
+    onInternalScroll(e);
+    onScroll === null || onScroll === void 0 || onScroll(e);
+  });
+  var triggerOnScroll = function triggerOnScroll() {
+    if (horizonScroll && scrollBodyRef.current) {
+      var _scrollBodyRef$curren3;
+      onInternalScroll({
+        currentTarget: getDOM(scrollBodyRef.current),
+        scrollLeft: (_scrollBodyRef$curren3 = scrollBodyRef.current) === null || _scrollBodyRef$curren3 === void 0 ? void 0 : _scrollBodyRef$curren3.scrollLeft
+      });
+    } else {
+      setShadowStart(false);
+      setShadowEnd(false);
+    }
+  };
+  var onFullTableResize = function onFullTableResize(offsetWidth) {
+    var _stickyRef$current2, _ref3, _fullTableRef$current;
+    (_stickyRef$current2 = stickyRef.current) === null || _stickyRef$current2 === void 0 || _stickyRef$current2.checkScrollBarVisible();
+    var mergedWidth = (_ref3 = offsetWidth !== null && offsetWidth !== void 0 ? offsetWidth : (_fullTableRef$current = fullTableRef.current) === null || _fullTableRef$current === void 0 ? void 0 : _fullTableRef$current.offsetWidth) !== null && _ref3 !== void 0 ? _ref3 : 0;
+    if (useInternalHooks && getContainerWidth && fullTableRef.current) {
+      mergedWidth = getContainerWidth(fullTableRef.current, mergedWidth) || mergedWidth;
+    }
+    if (mergedWidth !== componentWidth) {
+      triggerOnScroll();
+      setComponentWidth(mergedWidth);
+    }
+  };
+
+  // fix https://github.com/ant-design/ant-design/issues/49279
+  useLayoutEffect(function () {
+    if (horizonScroll) {
+      onFullTableResize();
+    }
+  }, [horizonScroll]);
+
+  // Sync scroll bar when init or `horizonScroll`, `data` and `columns.length` changed
+  var mounted = React.useRef(false);
+  React.useEffect(function () {
+    // onFullTableResize will be trigger once when ResizeObserver is mounted
+    // This will reduce one duplicated triggerOnScroll time
+    if (mounted.current) {
+      triggerOnScroll();
+    }
+  }, [horizonScroll, data, columns.length]);
+  React.useEffect(function () {
+    mounted.current = true;
+  }, []);
+
+  // ===================== Effects ======================
+  var _React$useState11 = React.useState(0),
+    _React$useState12 = _slicedToArray(_React$useState11, 2),
+    scrollbarSize = _React$useState12[0],
+    setScrollbarSize = _React$useState12[1];
+  useLayoutEffect(function () {
+    if (!tailor || !useInternalHooks) {
+      if (scrollBodyRef.current instanceof Element) {
+        setScrollbarSize(getTargetScrollBarSize(scrollBodyRef.current).width);
+      } else {
+        setScrollbarSize(getTargetScrollBarSize(scrollBodyContainerRef.current).width);
+      }
+    }
+  }, []);
+
+  // ================== INTERNAL HOOKS ==================
+  React.useEffect(function () {
+    if (useInternalHooks && internalRefs) {
+      internalRefs.body.current = scrollBodyRef.current;
+    }
+  });
+
+  // ========================================================================
+  // ==                               Render                               ==
+  // ========================================================================
+  // =================== Render: Func ===================
+  var renderFixedHeaderTable = React.useCallback(function (fixedHolderPassProps) {
+    return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Header, fixedHolderPassProps), fixFooter === 'top' && /*#__PURE__*/React.createElement(Footer, fixedHolderPassProps, summaryNode));
+  }, [fixFooter, summaryNode]);
+  var renderFixedFooterTable = React.useCallback(function (fixedHolderPassProps) {
+    return /*#__PURE__*/React.createElement(Footer, fixedHolderPassProps, summaryNode);
+  }, [summaryNode]);
+
+  // =================== Render: Node ===================
+  var TableComponent = getComponent(['table'], 'table');
+
+  // Table layout
+  var mergedTableLayout = React.useMemo(function () {
+    if (tableLayout) {
+      return tableLayout;
+    }
+    // https://github.com/ant-design/ant-design/issues/25227
+    // When scroll.x is max-content, no need to fix table layout
+    // it's width should stretch out to fit content
+    if (fixColumn) {
+      return mergedScrollX === 'max-content' ? 'auto' : 'fixed';
+    }
+    if (fixHeader || isSticky || flattenColumns.some(function (_ref4) {
+      var ellipsis = _ref4.ellipsis;
+      return ellipsis;
+    })) {
+      return 'fixed';
+    }
+    return 'auto';
+  }, [fixHeader, fixColumn, flattenColumns, tableLayout, isSticky]);
+  var groupTableNode;
+
+  // Header props
+  var headerProps = {
+    colWidths: colWidths,
+    columCount: flattenColumns.length,
+    stickyOffsets: stickyOffsets,
+    // `HeaderRow` guards `onHeaderRow` with a truthiness check, so `undefined`
+    // is a valid runtime value here.
+    onHeaderRow: onHeaderRow,
+    fixHeader: fixHeader,
+    scroll: scroll
+  };
+
+  // Empty
+  var emptyNode = React.useMemo(function () {
+    if (hasData) {
+      return null;
+    }
+    if (typeof emptyText === 'function') {
+      return emptyText();
+    }
+    return emptyText;
+  }, [hasData, emptyText]);
+
+  // Body
+  var bodyTable = /*#__PURE__*/React.createElement(Body, {
+    data: mergedData,
+    measureColumnWidth: fixHeader || horizonScroll || isSticky
+  });
+  var bodyColGroup =
+  /*#__PURE__*/
+  // A column without `width` renders an unset `<col>` width; `ColGroup`
+  // treats falsy widths as "no width", so the value is safe at runtime.
+  React.createElement(ColGroup, {
+    colWidths: flattenColumns.map(function (_ref5) {
+      var width = _ref5.width;
+      return width;
+    }),
+    columns: flattenColumns
+  });
+  var captionElement = caption !== null && caption !== undefined ? /*#__PURE__*/React.createElement("caption", {
+    className: "".concat(prefixCls, "-caption")
+  }, caption) : undefined;
+  var dataProps = pickAttrs(props, {
+    data: true
+  });
+  var ariaProps = pickAttrs(props, {
+    aria: true
+  });
+  if (fixHeader || isSticky) {
+    // >>>>>> Fixed Header
+    var bodyContent;
+    if (typeof customizeScrollBody === 'function') {
+      bodyContent = customizeScrollBody(mergedData, {
+        scrollbarSize: scrollbarSize,
+        ref: scrollBodyRef,
+        onScroll: onInternalScroll
+      });
+      headerProps.colWidths = flattenColumns.map(function (_ref6, index) {
+        var width = _ref6.width;
+        var colWidth = index === flattenColumns.length - 1 ? width - scrollbarSize : width;
+        if (typeof colWidth === 'number' && !Number.isNaN(colWidth)) {
+          return colWidth;
+        }
+        if (process.env.NODE_ENV !== 'production') {
+          var _props$columns;
+          warning(((_props$columns = props.columns) === null || _props$columns === void 0 ? void 0 : _props$columns.length) === 0, 'When use `components.body` with render props. Each column should have a fixed `width` value.');
+        }
+        return 0;
+      });
+    } else {
+      bodyContent = /*#__PURE__*/React.createElement("div", {
+        style: _objectSpread(_objectSpread({}, scrollXStyle), scrollYStyle),
+        onScroll: onBodyScroll,
+        ref: scrollBodyRef,
+        className: "".concat(prefixCls, "-body")
+      }, /*#__PURE__*/React.createElement(TableComponent, _extends({
+        style: _objectSpread(_objectSpread({}, scrollTableStyle), {}, {
+          tableLayout: mergedTableLayout
+        })
+      }, ariaProps), captionElement, bodyColGroup, bodyTable, !fixFooter && summaryNode && /*#__PURE__*/React.createElement(Footer, {
+        stickyOffsets: stickyOffsets,
+        flattenColumns: flattenColumns
+      }, summaryNode)));
+    }
+
+    // Fixed holder share the props
+    var fixedHolderProps = _objectSpread(_objectSpread(_objectSpread({
+      noData: !mergedData.length,
+      maxContentScroll: horizonScroll && mergedScrollX === 'max-content'
+    }, headerProps), columnContext), {}, {
+      // `FixedHolder` only compares `direction === 'rtl'`, so the `'ltr'`
+      // fallback behaves exactly like `undefined`.
+      direction: direction !== null && direction !== void 0 ? direction : 'ltr',
+      stickyClassName: stickyClassName,
+      scrollX: mergedScrollX,
+      tableLayout: mergedTableLayout,
+      onScroll: onInternalScroll
+    });
+    groupTableNode = /*#__PURE__*/React.createElement(React.Fragment, null, showHeader !== false && /*#__PURE__*/React.createElement(FixedHolder, _extends({}, fixedHolderProps, {
+      stickyTopOffset: offsetHeader,
+      className: "".concat(prefixCls, "-header"),
+      ref: scrollHeaderRef,
+      colGroup: bodyColGroup
+    }), renderFixedHeaderTable), bodyContent, fixFooter && fixFooter !== 'top' && /*#__PURE__*/React.createElement(FixedHolder, _extends({}, fixedHolderProps, {
+      stickyBottomOffset: offsetSummary,
+      className: "".concat(prefixCls, "-summary"),
+      ref: scrollSummaryRef,
+      colGroup: bodyColGroup
+    }), renderFixedFooterTable), isSticky && scrollBodyRef.current && scrollBodyRef.current instanceof Element && /*#__PURE__*/React.createElement(StickyScrollBar, {
+      ref: stickyRef,
+      offsetScroll: offsetScroll,
+      scrollBodyRef: scrollBodyRef,
+      onScroll: onInternalScroll,
+      container: container
+      // Only compared against `'rtl'` inside `StickyScrollBar`, so the
+      // `'ltr'` fallback behaves exactly like `undefined`.
+      ,
+      direction: direction !== null && direction !== void 0 ? direction : 'ltr'
+    }));
+  } else {
+    // >>>>>> Unique table
+    groupTableNode = /*#__PURE__*/React.createElement("div", {
+      style: _objectSpread(_objectSpread(_objectSpread({}, scrollXStyle), scrollYStyle), styles === null || styles === void 0 ? void 0 : styles.content),
+      className: clsx("".concat(prefixCls, "-content"), classNames === null || classNames === void 0 ? void 0 : classNames.content),
+      onScroll: onInternalScroll,
+      ref: scrollBodyRef
+    }, /*#__PURE__*/React.createElement(TableComponent, _extends({
+      style: _objectSpread(_objectSpread({}, scrollTableStyle), {}, {
+        tableLayout: mergedTableLayout
+      })
+    }, ariaProps), captionElement, bodyColGroup, showHeader !== false && /*#__PURE__*/React.createElement(Header, _extends({}, headerProps, columnContext)), bodyTable, summaryNode && /*#__PURE__*/React.createElement(Footer, {
+      stickyOffsets: stickyOffsets,
+      flattenColumns: flattenColumns
+    }, summaryNode)));
+  }
+  var tableStyle = _objectSpread({}, style);
+
+  // Add css var for sticky header `zIndex` calc
+  if (isSticky) {
+    tableStyle['--columns-count'] = flattenColumns.length;
+  }
+  var fullTable = /*#__PURE__*/React.createElement("div", _extends({
+    className: clsx(prefixCls, className, (_clsx = {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_clsx, "".concat(prefixCls, "-rtl"), direction === 'rtl'), "".concat(prefixCls, "-fix-start-shadow"), horizonScroll), "".concat(prefixCls, "-fix-end-shadow"), horizonScroll), "".concat(prefixCls, "-fix-start-shadow-show"), horizonScroll && shadowStart), "".concat(prefixCls, "-fix-end-shadow-show"), horizonScroll && shadowEnd), "".concat(prefixCls, "-layout-fixed"), tableLayout === 'fixed'), "".concat(prefixCls, "-fixed-header"), fixHeader), "".concat(prefixCls, "-fixed-column"), fixColumn), "".concat(prefixCls, "-scroll-horizontal"), horizonScroll), "".concat(prefixCls, "-has-fix-start"), (_flattenColumns$ = flattenColumns[0]) === null || _flattenColumns$ === void 0 ? void 0 : _flattenColumns$.fixed), _defineProperty(_clsx, "".concat(prefixCls, "-has-fix-end"), ((_flattenColumns = flattenColumns[flattenColumns.length - 1]) === null || _flattenColumns === void 0 ? void 0 : _flattenColumns.fixed) === 'end'))),
+    style: tableStyle,
+    id: id,
+    ref: fullTableRef
+  }, dataProps), title && /*#__PURE__*/React.createElement(Panel, {
+    className: clsx("".concat(prefixCls, "-title"), classNames === null || classNames === void 0 ? void 0 : classNames.title),
+    style: (_styles$title = styles === null || styles === void 0 ? void 0 : styles.title) !== null && _styles$title !== void 0 ? _styles$title : {}
+  }, title(mergedData)), /*#__PURE__*/React.createElement("div", {
+    ref: scrollBodyContainerRef,
+    className: clsx("".concat(prefixCls, "-container"), classNames === null || classNames === void 0 ? void 0 : classNames.section),
+    style: styles === null || styles === void 0 ? void 0 : styles.section
+  }, groupTableNode), footer && /*#__PURE__*/React.createElement(Panel, {
+    className: clsx("".concat(prefixCls, "-footer"), classNames === null || classNames === void 0 ? void 0 : classNames.footer),
+    style: (_styles$footer = styles === null || styles === void 0 ? void 0 : styles.footer) !== null && _styles$footer !== void 0 ? _styles$footer : {}
+  }, footer(mergedData)));
+  if (horizonScroll) {
+    fullTable = /*#__PURE__*/React.createElement(ResizeObserver, {
+      onResize: function onResize(_ref7) {
+        var offsetWidth = _ref7.offsetWidth;
+        return onFullTableResize(offsetWidth);
+      }
+    }, fullTable);
+  }
+  var fixedInfoList = useFixedInfo(flattenColumns, stickyOffsets);
+  var TableContextValue = React.useMemo(function () {
+    return {
+      // Scroll
+      scrollX: mergedScrollX,
+      scrollInfo: scrollInfo,
+      classNames: classNames,
+      styles: styles,
+      // Table
+      prefixCls: prefixCls,
+      getComponent: getComponent,
+      scrollbarSize: scrollbarSize,
+      direction: direction,
+      fixedInfoList: fixedInfoList,
+      isSticky: isSticky,
+      componentWidth: componentWidth,
+      fixHeader: fixHeader,
+      fixColumn: fixColumn,
+      horizonScroll: horizonScroll,
+      // Body
+      tableLayout: mergedTableLayout,
+      rowClassName: rowClassName,
+      expandedRowClassName: expandableConfig.expandedRowClassName,
+      expandIcon: mergedExpandIcon,
+      expandableType: expandableType,
+      expandRowByClick: expandableConfig.expandRowByClick,
+      expandedRowRender: expandableConfig.expandedRowRender,
+      expandedRowOffset: expandableConfig.expandedRowOffset,
+      onTriggerExpand: onTriggerExpand,
+      expandIconColumnIndex: expandableConfig.expandIconColumnIndex,
+      indentSize: expandableConfig.indentSize,
+      allColumnsFixedLeft: flattenColumns.every(function (col) {
+        return col.fixed === 'start';
+      }),
+      emptyNode: emptyNode,
+      // Column
+      columns: columns,
+      flattenColumns: flattenColumns,
+      onColumnResize: onColumnResize,
+      colWidths: colWidths,
+      // Row
+      hoverStartRow: startRow,
+      hoverEndRow: endRow,
+      onHover: onHover,
+      rowExpandable: expandableConfig.rowExpandable,
+      onRow: onRow,
+      getRowKey: getRowKey,
+      expandedKeys: mergedExpandedKeys,
+      childrenColumnName: mergedChildrenColumnName,
+      rowHoverable: rowHoverable,
+      // Measure Row
+      measureRowRender: measureRowRender
+    };
+  }, [
+  // Scroll
+  mergedScrollX, scrollInfo, classNames, styles,
+  // Table
+  prefixCls, getComponent, scrollbarSize, direction, fixedInfoList, isSticky, componentWidth, fixHeader, fixColumn, horizonScroll,
+  // Body
+  mergedTableLayout, rowClassName, expandableConfig.expandedRowClassName, mergedExpandIcon, expandableType, expandableConfig.expandRowByClick, expandableConfig.expandedRowRender, expandableConfig.expandedRowOffset, onTriggerExpand, expandableConfig.expandIconColumnIndex, expandableConfig.indentSize, emptyNode,
+  // Column
+  columns, flattenColumns, onColumnResize, colWidths,
+  // Row
+  startRow, endRow, onHover, expandableConfig.rowExpandable, onRow, getRowKey, mergedExpandedKeys, mergedChildrenColumnName, rowHoverable, measureRowRender]);
+  return (
+    /*#__PURE__*/
+    // Several fields (e.g. `scrollX`, `direction`, `indentSize`) can be
+    // `undefined` at runtime and all context consumers already guard them;
+    // the context type (declared outside this file) marks them required.
+    React.createElement(TableContext.Provider, {
+      value: TableContextValue
+    }, fullTable)
+  );
+};
+var RefTable = /*#__PURE__*/React.forwardRef(Table);
+if (process.env.NODE_ENV !== 'production') {
+  RefTable.displayName = 'Table';
+}
+export var genTable = function genTable(shouldTriggerRender) {
+  return makeImmutable(RefTable, shouldTriggerRender);
+};
+var RcTable = genTable(function (prev, next) {
+  var _ref8 = prev,
+    prevRenderTimes = _ref8._renderTimes;
+  var _ref9 = next,
+    nextRenderTimes = _ref9._renderTimes;
+  return prevRenderTimes !== nextRenderTimes;
+});
+export default RcTable;