acud 0.0.60

package/lib/table/baseTable/Table.js

@@ -0,0 +1,750 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof3 = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.INTERNAL_HOOKS = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _isVisible = _interopRequireDefault(require("rc-util/lib/Dom/isVisible"));
+
+var _pickAttrs = _interopRequireDefault(require("rc-util/lib/pickAttrs"));
+
+var _styleChecker = require("rc-util/lib/Dom/styleChecker");
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _shallowequal = _interopRequireDefault(require("shallowequal"));
+
+var _warning = _interopRequireDefault(require("rc-util/lib/warning"));
+
+var _rcResizeObserver = _interopRequireDefault(require("rc-resize-observer"));
+
+var _getScrollBarSize = require("rc-util/lib/getScrollBarSize");
+
+var _ColumnGroup = _interopRequireDefault(require("./sugar/ColumnGroup"));
+
+var _Column = _interopRequireDefault(require("./sugar/Column"));
+
+var _Header = _interopRequireDefault(require("./Header/Header"));
+
+var _TableContext = _interopRequireDefault(require("./context/TableContext"));
+
+var _BodyContext = _interopRequireDefault(require("./context/BodyContext"));
+
+var _Body = _interopRequireDefault(require("./Body"));
+
+var _useColumns3 = _interopRequireDefault(require("./hooks/useColumns"));
+
+var _useFrame = require("./hooks/useFrame");
+
+var _valueUtil = require("./utils/valueUtil");
+
+var _ResizeContext = _interopRequireDefault(require("./context/ResizeContext"));
+
+var _useStickyOffsets = _interopRequireDefault(require("./hooks/useStickyOffsets"));
+
+var _ColGroup = _interopRequireDefault(require("./ColGroup"));
+
+var _legacyUtil = require("./utils/legacyUtil");
+
+var _Panel = _interopRequireDefault(require("./Panel"));
+
+var _Footer = _interopRequireWildcard(require("./Footer"));
+
+var _expandUtil = require("./utils/expandUtil");
+
+var _fixUtil = require("./utils/fixUtil");
+
+var _stickyScrollBar = _interopRequireDefault(require("./stickyScrollBar"));
+
+var _useSticky2 = _interopRequireDefault(require("./hooks/useSticky"));
+
+var _FixedHolder = _interopRequireDefault(require("./FixedHolder"));
+
+var _Summary = _interopRequireDefault(require("./Footer/Summary"));
+
+var _StickyContext = _interopRequireDefault(require("./context/StickyContext"));
+
+var _ExpandedRowContext = _interopRequireDefault(require("./context/ExpandedRowContext"));
+
+var _constant = require("./constant");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof3(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/**
+ * 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
+ */
+// Used for conditions cache
+var EMPTY_DATA = []; // Used for customize scroll
+
+var EMPTY_SCROLL_TARGET = {};
+var INTERNAL_HOOKS = 'rc-table-internal-hook';
+exports.INTERNAL_HOOKS = INTERNAL_HOOKS;
+var MemoTableContent = /*#__PURE__*/React.memo(function (_ref) {
+  var children = _ref.children;
+  return children;
+}, function (prev, next) {
+  if (!(0, _shallowequal["default"])(prev.props, next.props)) {
+    return false;
+  } // No additional render when pinged status change.
+  // This is not a bug.
+
+
+  return prev.pingLeft !== next.pingLeft || prev.pingRight !== next.pingRight;
+});
+
+function Table(props) {
+  var _classNames;
+
+  var prefixCls = props.prefixCls,
+      className = props.className,
+      rowClassName = props.rowClassName,
+      style = props.style,
+      data = props.data,
+      rowKey = props.rowKey,
+      scroll = props.scroll,
+      tableLayout = props.tableLayout,
+      direction = props.direction,
+      title = props.title,
+      footer = props.footer,
+      summary = props.summary,
+      id = props.id,
+      showHeader = props.showHeader,
+      components = props.components,
+      emptyText = props.emptyText,
+      onRow = props.onRow,
+      onHeaderRow = props.onHeaderRow,
+      internalHooks = props.internalHooks,
+      transformColumns = props.transformColumns,
+      internalRefs = props.internalRefs,
+      sticky = props.sticky;
+  var mergedData = data || EMPTY_DATA;
+  var hasData = !!mergedData.length; // ===================== Warning ======================
+
+  if (process.env.NODE_ENV !== 'production') {
+    ['onRowClick', 'onRowDoubleClick', 'onRowContextMenu', 'onRowMouseEnter', 'onRowMouseLeave'].forEach(function (name) {
+      (0, _warning["default"])(props[name] === undefined, "`".concat(name, "` is removed, please use `onRow` instead."));
+    });
+    (0, _warning["default"])(!('getBodyWrapper' in props), '`getBodyWrapper` is deprecated, please use custom `components` instead.');
+  } // ==================== Customize =====================
+
+
+  var mergedComponents = React.useMemo(function () {
+    return (0, _valueUtil.mergeObject)(components, {});
+  }, [components]);
+  var getComponent = React.useCallback(function (path, defaultComponent) {
+    return (0, _valueUtil.getPathValue)(mergedComponents, path) || defaultComponent;
+  }, [mergedComponents]);
+  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') {
+        (0, _warning["default"])(key !== undefined, 'Each record in table should have a unique `key` prop, or set `rowKey` to an unique primary key.');
+      }
+
+      return key;
+    };
+  }, [rowKey]); // ====================== Expand ======================
+
+  var expandableConfig = (0, _legacyUtil.getExpandableProps)(props);
+  var expandIcon = expandableConfig.expandIcon,
+      expandedRowKeys = expandableConfig.expandedRowKeys,
+      defaultExpandedRowKeys = expandableConfig.defaultExpandedRowKeys,
+      defaultExpandAllRows = expandableConfig.defaultExpandAllRows,
+      expandedRowRender = expandableConfig.expandedRowRender,
+      onExpand = expandableConfig.onExpand,
+      onExpandedRowsChange = expandableConfig.onExpandedRowsChange,
+      expandRowByClick = expandableConfig.expandRowByClick,
+      rowExpandable = expandableConfig.rowExpandable,
+      expandIconColumnIndex = expandableConfig.expandIconColumnIndex,
+      expandedRowClassName = expandableConfig.expandedRowClassName,
+      childrenColumnName = expandableConfig.childrenColumnName,
+      indentSize = expandableConfig.indentSize;
+  var mergedExpandIcon = expandIcon || _expandUtil.renderExpandIcon;
+  var mergedChildrenColumnName = childrenColumnName || 'children';
+  var expandableType = React.useMemo(function () {
+    if (expandedRowRender) {
+      return 'row';
+    }
+    /* eslint-disable no-underscore-dangle */
+
+    /**
+     * Fix https://github.com/ant-design/ant-design/issues/21154
+     * This is a workaround to not to break current behavior.
+     * We can remove follow code after final release.
+     *
+     * To other developer:
+     *  Do not use `__PARENT_RENDER_ICON__` in prod since we will remove this when refactor
+     */
+
+
+    if (props.expandable && internalHooks === INTERNAL_HOOKS && props.expandable.__PARENT_RENDER_ICON__ || mergedData.some(function (record) {
+      return record && (0, _typeof2["default"])(record) === 'object' && record[mergedChildrenColumnName];
+    })) {
+      return 'nest';
+    }
+    /* eslint-enable */
+
+
+    return false;
+  }, [!!expandedRowRender, mergedData]);
+
+  var _React$useState = React.useState(function () {
+    if (defaultExpandedRowKeys) {
+      return defaultExpandedRowKeys;
+    }
+
+    if (defaultExpandAllRows) {
+      return (0, _expandUtil.findAllChildrenKeys)(mergedData, getRowKey, mergedChildrenColumnName);
+    }
+
+    return [];
+  }),
+      _React$useState2 = (0, _slicedToArray2["default"])(_React$useState, 2),
+      innerExpandedKeys = _React$useState2[0],
+      setInnerExpandedKeys = _React$useState2[1];
+
+  var mergedExpandedKeys = React.useMemo(function () {
+    return new Set(expandedRowKeys || innerExpandedKeys || []);
+  }, [expandedRowKeys, innerExpandedKeys]);
+  var onTriggerExpand = React.useCallback(function (record) {
+    var key = getRowKey(record, mergedData.indexOf(record));
+    var newExpandedKeys;
+    var hasKey = mergedExpandedKeys.has(key);
+
+    if (hasKey) {
+      mergedExpandedKeys["delete"](key);
+      newExpandedKeys = (0, _toConsumableArray2["default"])(mergedExpandedKeys);
+    } else {
+      newExpandedKeys = [].concat((0, _toConsumableArray2["default"])(mergedExpandedKeys), [key]);
+    }
+
+    setInnerExpandedKeys(newExpandedKeys);
+
+    if (onExpand) {
+      onExpand(!hasKey, record);
+    }
+
+    if (onExpandedRowsChange) {
+      onExpandedRowsChange(newExpandedKeys);
+    }
+  }, [getRowKey, mergedExpandedKeys, mergedData, onExpand, onExpandedRowsChange]); // Warning if use `expandedRowRender` and nest children in the same time
+
+  if (process.env.NODE_ENV !== 'production' && expandedRowRender && mergedData.some(function (record) {
+    return Array.isArray(record === null || record === void 0 ? void 0 : record[mergedChildrenColumnName]);
+  })) {
+    (0, _warning["default"])(false, '`expandedRowRender` should not use with nested Table');
+  } // ====================== Column ======================
+
+
+  var _React$useState3 = React.useState(0),
+      _React$useState4 = (0, _slicedToArray2["default"])(_React$useState3, 2),
+      componentWidth = _React$useState4[0],
+      setComponentWidth = _React$useState4[1];
+
+  var _useColumns = (0, _useColumns3["default"])((0, _extends2["default"])((0, _extends2["default"])((0, _extends2["default"])({}, props), expandableConfig), {
+    expandable: !!expandedRowRender,
+    expandedKeys: mergedExpandedKeys,
+    getRowKey: getRowKey,
+    // https://github.com/ant-design/ant-design/issues/23894
+    onTriggerExpand: onTriggerExpand,
+    expandIcon: mergedExpandIcon,
+    expandIconColumnIndex: expandIconColumnIndex,
+    direction: direction
+  }), internalHooks === INTERNAL_HOOKS ? transformColumns : null),
+      _useColumns2 = (0, _slicedToArray2["default"])(_useColumns, 2),
+      columns = _useColumns2[0],
+      flattenColumns = _useColumns2[1];
+
+  var columnContext = React.useMemo(function () {
+    return {
+      columns: columns,
+      flattenColumns: flattenColumns
+    };
+  }, [columns, flattenColumns]); // ====================== Scroll ======================
+
+  var fullTableRef = React.useRef();
+  var scrollHeaderRef = React.useRef();
+  var scrollBodyRef = React.useRef();
+  var scrollSummaryRef = React.useRef();
+
+  var _React$useState5 = React.useState(false),
+      _React$useState6 = (0, _slicedToArray2["default"])(_React$useState5, 2),
+      pingedLeft = _React$useState6[0],
+      setPingedLeft = _React$useState6[1];
+
+  var _React$useState7 = React.useState(false),
+      _React$useState8 = (0, _slicedToArray2["default"])(_React$useState7, 2),
+      pingedRight = _React$useState8[0],
+      setPingedRight = _React$useState8[1];
+
+  var _useLayoutState = (0, _useFrame.useLayoutState)(new Map()),
+      _useLayoutState2 = (0, _slicedToArray2["default"])(_useLayoutState, 2),
+      colsWidths = _useLayoutState2[0],
+      updateColsWidths = _useLayoutState2[1]; // Convert map to number width
+
+
+  var colsKeys = (0, _valueUtil.getColumnsKey)(flattenColumns);
+  var pureColWidths = colsKeys.map(function (columnKey) {
+    return colsWidths.get(columnKey);
+  });
+  var colWidths = React.useMemo(function () {
+    return pureColWidths;
+  }, [pureColWidths.join('_')]);
+  var stickyOffsets = (0, _useStickyOffsets["default"])(colWidths, flattenColumns.length, direction);
+  var fixHeader = scroll && (0, _valueUtil.validateValue)(scroll.y);
+  var horizonScroll = scroll && (0, _valueUtil.validateValue)(scroll.x) || Boolean(expandableConfig.fixed);
+  var fixColumn = horizonScroll && flattenColumns.some(function (_ref2) {
+    var fixed = _ref2.fixed;
+    return fixed;
+  }); // Sticky
+
+  var stickyRef = React.useRef();
+
+  var _useSticky = (0, _useSticky2["default"])(sticky, 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 = summary === null || summary === void 0 ? void 0 : summary(mergedData);
+  var fixFooter = (fixHeader || isSticky) && /*#__PURE__*/React.isValidElement(summaryNode) && summaryNode.type === _Summary["default"] && summaryNode.props.fixed; // Scroll
+
+  var scrollXStyle;
+  var scrollYStyle;
+  var scrollTableStyle;
+
+  if (fixHeader) {
+    scrollYStyle = {
+      overflowY: 'scroll',
+      maxHeight: scroll.y
+    };
+  }
+
+  if (horizonScroll) {
+    scrollXStyle = {
+      overflowX: 'auto'
+    };
+
+    if (!fixHeader) {
+      scrollYStyle = {
+        overflowY: 'hidden'
+      };
+    }
+
+    scrollTableStyle = {
+      width: scroll.x === true ? 'auto' : scroll.x,
+      minWidth: '100%'
+    };
+  }
+
+  var onColumnResize = React.useCallback(function (columnKey, width) {
+    if ((0, _isVisible["default"])(fullTableRef.current)) {
+      updateColsWidths(function (widths) {
+        if (widths.get(columnKey) !== width) {
+          var newWidths = new Map(widths);
+          newWidths.set(columnKey, width);
+          return newWidths;
+        }
+
+        return widths;
+      });
+    }
+  }, []);
+
+  var _useTimeoutLock = (0, _useFrame.useTimeoutLock)(null),
+      _useTimeoutLock2 = (0, _slicedToArray2["default"])(_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) {
+      // eslint-disable-next-line no-param-reassign
+      target.scrollLeft = scrollLeft;
+    }
+  }
+
+  var onScroll = function onScroll(_ref3) {
+    var currentTarget = _ref3.currentTarget,
+        scrollLeft = _ref3.scrollLeft;
+
+    var _a;
+
+    var isRTL = direction === 'rtl';
+    var mergedScrollLeft = typeof scrollLeft === 'number' ? scrollLeft : currentTarget.scrollLeft;
+    var compareTarget = currentTarget || EMPTY_SCROLL_TARGET;
+
+    if (!getScrollTarget() || getScrollTarget() === compareTarget) {
+      setScrollTarget(compareTarget);
+      forceScroll(mergedScrollLeft, scrollHeaderRef.current);
+      forceScroll(mergedScrollLeft, scrollBodyRef.current);
+      forceScroll(mergedScrollLeft, scrollSummaryRef.current);
+      forceScroll(mergedScrollLeft, (_a = stickyRef.current) === null || _a === void 0 ? void 0 : _a.setScrollLeft);
+    }
+
+    if (currentTarget) {
+      var scrollWidth = currentTarget.scrollWidth,
+          clientWidth = currentTarget.clientWidth;
+
+      if (isRTL) {
+        setPingedLeft(-mergedScrollLeft < scrollWidth - clientWidth);
+        setPingedRight(-mergedScrollLeft > 0);
+      } else {
+        setPingedLeft(mergedScrollLeft > 0);
+        setPingedRight(mergedScrollLeft < scrollWidth - clientWidth);
+      }
+    }
+  };
+
+  var triggerOnScroll = function triggerOnScroll() {
+    if (horizonScroll && scrollBodyRef.current) {
+      onScroll({
+        currentTarget: scrollBodyRef.current
+      });
+    } else {
+      setPingedLeft(false);
+      setPingedRight(false);
+    }
+  };
+
+  var onFullTableResize = function onFullTableResize(_ref4) {
+    var width = _ref4.width;
+
+    if (width !== componentWidth) {
+      triggerOnScroll();
+      setComponentWidth(fullTableRef.current ? fullTableRef.current.offsetWidth : width);
+    }
+  }; // 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$useState9 = React.useState(0),
+      _React$useState10 = (0, _slicedToArray2["default"])(_React$useState9, 2),
+      scrollbarSize = _React$useState10[0],
+      setScrollbarSize = _React$useState10[1];
+
+  var _React$useState11 = React.useState(true),
+      _React$useState12 = (0, _slicedToArray2["default"])(_React$useState11, 2),
+      supportSticky = _React$useState12[0],
+      setSupportSticky = _React$useState12[1]; // Only IE not support, we mark as support first
+
+
+  React.useEffect(function () {
+    setScrollbarSize((0, _getScrollBarSize.getTargetScrollBarSize)(scrollBodyRef.current).width);
+    setSupportSticky((0, _styleChecker.isStyleSupport)('position', 'sticky'));
+  }, []); // ================== INTERNAL HOOKS ==================
+
+  React.useEffect(function () {
+    if (internalHooks === INTERNAL_HOOKS && internalRefs) {
+      internalRefs.body.current = scrollBodyRef.current;
+    }
+  }); // ====================== Render ======================
+
+  var TableComponent = getComponent(['table'], 'table'); // Table layout
+
+  var mergedTableLayout = React.useMemo(function () {
+    if (tableLayout) {
+      return tableLayout;
+    }
+
+    if (fixColumn) {
+      return scroll.x === 'max-content' ? 'auto' : 'fixed';
+    }
+
+    if (fixHeader || isSticky || flattenColumns.some(function (_ref5) {
+      var ellipsis = _ref5.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,
+    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["default"], {
+    data: mergedData,
+    measureColumnWidth: fixHeader || horizonScroll || isSticky,
+    expandedKeys: mergedExpandedKeys,
+    rowExpandable: rowExpandable,
+    getRowKey: getRowKey,
+    onRow: onRow,
+    emptyNode: emptyNode,
+    childrenColumnName: mergedChildrenColumnName
+  });
+  var bodyColGroup = /*#__PURE__*/React.createElement(_ColGroup["default"], {
+    colWidths: flattenColumns.map(function (_ref6) {
+      var width = _ref6.width;
+      return width;
+    }),
+    columns: flattenColumns
+  });
+  var customizeScrollBody = getComponent(['body']);
+
+  if (process.env.NODE_ENV !== 'production' && typeof customizeScrollBody === 'function' && hasData && !fixHeader) {
+    (0, _warning["default"])(false, '`components.body` with render props is only work on `scroll.y`.');
+  }
+
+  if (fixHeader || isSticky) {
+    // >>>>>> Fixed Header
+    var bodyContent;
+
+    if (typeof customizeScrollBody === 'function') {
+      bodyContent = customizeScrollBody(mergedData, {
+        scrollbarSize: scrollbarSize,
+        ref: scrollBodyRef,
+        onScroll: onScroll
+      });
+      headerProps.colWidths = flattenColumns.map(function (_ref7, index) {
+        var width = _ref7.width;
+        var colWidth = index === columns.length - 1 ? width - scrollbarSize : width;
+
+        if (typeof colWidth === 'number' && !Number.isNaN(colWidth)) {
+          return colWidth;
+        }
+
+        (0, _warning["default"])(false, 'When use `components.body` with render props. Each column should have a fixed `width` value.');
+        return 0;
+      });
+    } else {
+      bodyContent = /*#__PURE__*/React.createElement("div", {
+        style: (0, _extends2["default"])((0, _extends2["default"])({}, scrollXStyle), scrollYStyle),
+        onScroll: onScroll,
+        ref: scrollBodyRef,
+        className: (0, _classnames["default"])("".concat(prefixCls, "-body"))
+      }, /*#__PURE__*/React.createElement(TableComponent, {
+        style: (0, _extends2["default"])((0, _extends2["default"])({}, scrollTableStyle), {
+          tableLayout: mergedTableLayout
+        })
+      }, bodyColGroup, bodyTable, !fixFooter && summaryNode && /*#__PURE__*/React.createElement(_Footer["default"], {
+        stickyOffsets: stickyOffsets,
+        flattenColumns: flattenColumns
+      }, summaryNode)));
+    } // Fixed holder share the props
+
+
+    var fixedHolderProps = (0, _extends2["default"])((0, _extends2["default"])((0, _extends2["default"])({
+      noData: !mergedData.length,
+      maxContentScroll: horizonScroll && scroll.x === 'max-content'
+    }, headerProps), columnContext), {
+      direction: direction,
+      stickyClassName: stickyClassName,
+      onScroll: onScroll
+    });
+    groupTableNode = /*#__PURE__*/React.createElement(React.Fragment, null, showHeader !== false && /*#__PURE__*/React.createElement(_FixedHolder["default"], (0, _extends2["default"])({}, fixedHolderProps, {
+      stickyTopOffset: offsetHeader,
+      className: "".concat(prefixCls, "-header"),
+      ref: scrollHeaderRef
+    }), function (fixedHolderPassProps) {
+      return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(_Header["default"], fixedHolderPassProps), fixFooter === 'top' && /*#__PURE__*/React.createElement(_Footer["default"], fixedHolderPassProps, summaryNode));
+    }), bodyContent, fixFooter && fixFooter !== 'top' && /*#__PURE__*/React.createElement(_FixedHolder["default"], (0, _extends2["default"])({}, fixedHolderProps, {
+      stickyBottomOffset: offsetSummary,
+      className: "".concat(prefixCls, "-summary"),
+      ref: scrollSummaryRef
+    }), function (fixedHolderPassProps) {
+      return /*#__PURE__*/React.createElement(_Footer["default"], fixedHolderPassProps, summaryNode);
+    }), isSticky && /*#__PURE__*/React.createElement(_stickyScrollBar["default"], {
+      ref: stickyRef,
+      offsetScroll: offsetScroll,
+      scrollBodyRef: scrollBodyRef,
+      onScroll: onScroll,
+      container: container
+    }));
+  } else {
+    // >>>>>> Unique table
+    groupTableNode = /*#__PURE__*/React.createElement("div", {
+      style: (0, _extends2["default"])((0, _extends2["default"])({}, scrollXStyle), scrollYStyle),
+      className: (0, _classnames["default"])("".concat(prefixCls, "-content")),
+      onScroll: onScroll,
+      ref: scrollBodyRef
+    }, /*#__PURE__*/React.createElement(TableComponent, {
+      style: (0, _extends2["default"])((0, _extends2["default"])({}, scrollTableStyle), {
+        tableLayout: mergedTableLayout
+      })
+    }, bodyColGroup, showHeader !== false && /*#__PURE__*/React.createElement(_Header["default"], (0, _extends2["default"])({}, headerProps, columnContext)), bodyTable, summaryNode && /*#__PURE__*/React.createElement(_Footer["default"], {
+      stickyOffsets: stickyOffsets,
+      flattenColumns: flattenColumns
+    }, summaryNode)));
+  }
+
+  var ariaProps = (0, _pickAttrs["default"])(props, {
+    aria: true,
+    data: true
+  });
+  var fullTable = /*#__PURE__*/React.createElement("div", (0, _extends2["default"])({
+    className: (0, _classnames["default"])(prefixCls, className, (_classNames = {}, (0, _defineProperty2["default"])(_classNames, "".concat(prefixCls, "-rtl"), direction === 'rtl'), (0, _defineProperty2["default"])(_classNames, "".concat(prefixCls, "-ping-left"), pingedLeft), (0, _defineProperty2["default"])(_classNames, "".concat(prefixCls, "-ping-right"), pingedRight), (0, _defineProperty2["default"])(_classNames, "".concat(prefixCls, "-layout-fixed"), tableLayout === 'fixed'), (0, _defineProperty2["default"])(_classNames, "".concat(prefixCls, "-fixed-header"), fixHeader), (0, _defineProperty2["default"])(_classNames, "".concat(prefixCls, "-fixed-column"), fixColumn), (0, _defineProperty2["default"])(_classNames, "".concat(prefixCls, "-scroll-horizontal"), horizonScroll), (0, _defineProperty2["default"])(_classNames, "".concat(prefixCls, "-has-fix-left"), flattenColumns[0] && flattenColumns[0].fixed), (0, _defineProperty2["default"])(_classNames, "".concat(prefixCls, "-has-fix-right"), flattenColumns[flattenColumns.length - 1] && flattenColumns[flattenColumns.length - 1].fixed === 'right'), _classNames)),
+    style: style,
+    id: id,
+    ref: fullTableRef
+  }, ariaProps), /*#__PURE__*/React.createElement(MemoTableContent, {
+    pingLeft: pingedLeft,
+    pingRight: pingedRight,
+    props: (0, _extends2["default"])((0, _extends2["default"])({}, props), {
+      stickyOffsets: stickyOffsets,
+      mergedExpandedKeys: mergedExpandedKeys
+    })
+  }, title && /*#__PURE__*/React.createElement(_Panel["default"], {
+    className: "".concat(prefixCls, "-title")
+  }, title(mergedData)), /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "-container")
+  }, groupTableNode), footer && /*#__PURE__*/React.createElement(_Panel["default"], {
+    className: "".concat(prefixCls, "-footer")
+  }, footer(mergedData))));
+
+  if (horizonScroll) {
+    fullTable = /*#__PURE__*/React.createElement(_rcResizeObserver["default"], {
+      onResize: onFullTableResize
+    }, fullTable);
+  }
+
+  var TableContextValue = React.useMemo(function () {
+    return {
+      prefixCls: prefixCls,
+      getComponent: getComponent,
+      scrollbarSize: scrollbarSize,
+      direction: direction,
+      fixedInfoList: flattenColumns.map(function (_, colIndex) {
+        return (0, _fixUtil.getCellFixedInfo)(colIndex, colIndex, flattenColumns, stickyOffsets, direction);
+      }),
+      isSticky: isSticky
+    };
+  }, [prefixCls, getComponent, scrollbarSize, direction, flattenColumns, stickyOffsets, direction, isSticky]);
+  var BodyContextValue = React.useMemo(function () {
+    return (0, _extends2["default"])((0, _extends2["default"])({}, columnContext), {
+      tableLayout: mergedTableLayout,
+      rowClassName: rowClassName,
+      expandedRowClassName: expandedRowClassName,
+      expandIcon: mergedExpandIcon,
+      expandableType: expandableType,
+      expandRowByClick: expandRowByClick,
+      expandedRowRender: expandedRowRender,
+      onTriggerExpand: onTriggerExpand,
+      expandIconColumnIndex: expandIconColumnIndex,
+      indentSize: indentSize
+    });
+  }, [columnContext, mergedTableLayout, rowClassName, expandedRowClassName, mergedExpandIcon, expandableType, expandRowByClick, expandedRowRender, onTriggerExpand, expandIconColumnIndex, indentSize]);
+  var ExpandedRowContextValue = React.useMemo(function () {
+    return {
+      componentWidth: componentWidth,
+      fixHeader: fixHeader,
+      fixColumn: fixColumn,
+      horizonScroll: horizonScroll
+    };
+  }, [componentWidth, fixHeader, fixColumn, horizonScroll]);
+  var ResizeContextValue = React.useMemo(function () {
+    return {
+      onColumnResize: onColumnResize
+    };
+  }, [onColumnResize]);
+  return /*#__PURE__*/React.createElement(_StickyContext["default"].Provider, {
+    value: supportSticky
+  }, /*#__PURE__*/React.createElement(_TableContext["default"].Provider, {
+    value: TableContextValue
+  }, /*#__PURE__*/React.createElement(_BodyContext["default"].Provider, {
+    value: BodyContextValue
+  }, /*#__PURE__*/React.createElement(_ExpandedRowContext["default"].Provider, {
+    value: ExpandedRowContextValue
+  }, /*#__PURE__*/React.createElement(_ResizeContext["default"].Provider, {
+    value: ResizeContextValue
+  }, fullTable)))));
+}
+
+Table.EXPAND_COLUMN = _constant.EXPAND_COLUMN;
+Table.Column = _Column["default"];
+Table.ColumnGroup = _ColumnGroup["default"];
+Table.Summary = _Footer.FooterComponents;
+Table.defaultProps = {
+  rowKey: 'key',
+  prefixCls: 'rc-table',
+  emptyText: function emptyText() {
+    return 'No Data';
+  }
+};
+var _default = Table;
+exports["default"] = _default;