add all frontend files

node_modules/rc-table/es/VirtualTable/BodyGrid.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import type { OnCustomizeScroll, ScrollConfig } from '../interface';
+export interface GridProps<RecordType = any> {
+    data: RecordType[];
+    onScroll: OnCustomizeScroll;
+}
+export interface GridRef {
+    scrollLeft: number;
+    nativeElement: HTMLDivElement;
+    scrollTo: (scrollConfig: ScrollConfig) => void;
+}
+declare const ResponseGrid: React.ForwardRefExoticComponent<GridProps<any> & React.RefAttributes<GridRef>>;
+export default ResponseGrid;

node_modules/rc-table/es/VirtualTable/BodyGrid.js

@@ -0,0 +1,273 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { useContext } from '@rc-component/context';
+import VirtualList from 'rc-virtual-list';
+import * as React from 'react';
+import TableContext, { responseImmutable } from "../context/TableContext";
+import useFlattenRecords from "../hooks/useFlattenRecords";
+import BodyLine from "./BodyLine";
+import { GridContext, StaticContext } from "./context";
+var Grid = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  var data = props.data,
+    onScroll = props.onScroll;
+  var _useContext = useContext(TableContext, ['flattenColumns', 'onColumnResize', 'getRowKey', 'prefixCls', 'expandedKeys', 'childrenColumnName', 'scrollX', 'direction']),
+    flattenColumns = _useContext.flattenColumns,
+    onColumnResize = _useContext.onColumnResize,
+    getRowKey = _useContext.getRowKey,
+    expandedKeys = _useContext.expandedKeys,
+    prefixCls = _useContext.prefixCls,
+    childrenColumnName = _useContext.childrenColumnName,
+    scrollX = _useContext.scrollX,
+    direction = _useContext.direction;
+  var _useContext2 = useContext(StaticContext),
+    sticky = _useContext2.sticky,
+    scrollY = _useContext2.scrollY,
+    listItemHeight = _useContext2.listItemHeight,
+    getComponent = _useContext2.getComponent,
+    onTablePropScroll = _useContext2.onScroll;
+
+  // =========================== Ref ============================
+  var listRef = React.useRef();
+
+  // =========================== Data ===========================
+  var flattenData = useFlattenRecords(data, childrenColumnName, expandedKeys, getRowKey);
+
+  // ========================== Column ==========================
+  var columnsWidth = React.useMemo(function () {
+    var total = 0;
+    return flattenColumns.map(function (_ref) {
+      var width = _ref.width,
+        minWidth = _ref.minWidth,
+        key = _ref.key;
+      var finalWidth = Math.max(width || 0, minWidth || 0);
+      total += finalWidth;
+      return [key, finalWidth, total];
+    });
+  }, [flattenColumns]);
+  var columnsOffset = React.useMemo(function () {
+    return columnsWidth.map(function (colWidth) {
+      return colWidth[2];
+    });
+  }, [columnsWidth]);
+  React.useEffect(function () {
+    columnsWidth.forEach(function (_ref2) {
+      var _ref3 = _slicedToArray(_ref2, 2),
+        key = _ref3[0],
+        width = _ref3[1];
+      onColumnResize(key, width);
+    });
+  }, [columnsWidth]);
+
+  // =========================== Ref ============================
+  React.useImperativeHandle(ref, function () {
+    var _listRef$current2;
+    var obj = {
+      scrollTo: function scrollTo(config) {
+        var _listRef$current;
+        (_listRef$current = listRef.current) === null || _listRef$current === void 0 || _listRef$current.scrollTo(config);
+      },
+      nativeElement: (_listRef$current2 = listRef.current) === null || _listRef$current2 === void 0 ? void 0 : _listRef$current2.nativeElement
+    };
+    Object.defineProperty(obj, 'scrollLeft', {
+      get: function get() {
+        var _listRef$current3;
+        return ((_listRef$current3 = listRef.current) === null || _listRef$current3 === void 0 ? void 0 : _listRef$current3.getScrollInfo().x) || 0;
+      },
+      set: function set(value) {
+        var _listRef$current4;
+        (_listRef$current4 = listRef.current) === null || _listRef$current4 === void 0 || _listRef$current4.scrollTo({
+          left: value
+        });
+      }
+    });
+
+    // https://github.com/ant-design/ant-design/issues/54734
+    Object.defineProperty(obj, 'scrollTop', {
+      get: function get() {
+        var _listRef$current5;
+        return ((_listRef$current5 = listRef.current) === null || _listRef$current5 === void 0 ? void 0 : _listRef$current5.getScrollInfo().y) || 0;
+      },
+      set: function set(value) {
+        var _listRef$current6;
+        (_listRef$current6 = listRef.current) === null || _listRef$current6 === void 0 || _listRef$current6.scrollTo({
+          top: value
+        });
+      }
+    });
+    return obj;
+  });
+
+  // ======================= Col/Row Span =======================
+  var getRowSpan = function getRowSpan(column, index) {
+    var _flattenData$index;
+    var record = (_flattenData$index = flattenData[index]) === null || _flattenData$index === void 0 ? void 0 : _flattenData$index.record;
+    var onCell = column.onCell;
+    if (onCell) {
+      var _cellProps$rowSpan;
+      var cellProps = onCell(record, index);
+      return (_cellProps$rowSpan = cellProps === null || cellProps === void 0 ? void 0 : cellProps.rowSpan) !== null && _cellProps$rowSpan !== void 0 ? _cellProps$rowSpan : 1;
+    }
+    return 1;
+  };
+  var extraRender = function extraRender(info) {
+    var start = info.start,
+      end = info.end,
+      getSize = info.getSize,
+      offsetY = info.offsetY;
+
+    // Do nothing if no data
+    if (end < 0) {
+      return null;
+    }
+
+    // Find first rowSpan column
+    var firstRowSpanColumns = flattenColumns.filter(
+    // rowSpan is 0
+    function (column) {
+      return getRowSpan(column, start) === 0;
+    });
+    var startIndex = start;
+    var _loop = function _loop(i) {
+      firstRowSpanColumns = firstRowSpanColumns.filter(function (column) {
+        return getRowSpan(column, i) === 0;
+      });
+      if (!firstRowSpanColumns.length) {
+        startIndex = i;
+        return 1; // break
+      }
+    };
+    for (var i = start; i >= 0; i -= 1) {
+      if (_loop(i)) break;
+    }
+
+    // Find last rowSpan column
+    var lastRowSpanColumns = flattenColumns.filter(
+    // rowSpan is not 1
+    function (column) {
+      return getRowSpan(column, end) !== 1;
+    });
+    var endIndex = end;
+    var _loop2 = function _loop2(_i) {
+      lastRowSpanColumns = lastRowSpanColumns.filter(function (column) {
+        return getRowSpan(column, _i) !== 1;
+      });
+      if (!lastRowSpanColumns.length) {
+        endIndex = Math.max(_i - 1, end);
+        return 1; // break
+      }
+    };
+    for (var _i = end; _i < flattenData.length; _i += 1) {
+      if (_loop2(_i)) break;
+    }
+
+    // Collect the line who has rowSpan
+    var spanLines = [];
+    var _loop3 = function _loop3(_i2) {
+      var item = flattenData[_i2];
+
+      // This code will never reach, just incase
+      if (!item) {
+        return 1; // continue
+      }
+      if (flattenColumns.some(function (column) {
+        return getRowSpan(column, _i2) > 1;
+      })) {
+        spanLines.push(_i2);
+      }
+    };
+    for (var _i2 = startIndex; _i2 <= endIndex; _i2 += 1) {
+      if (_loop3(_i2)) continue;
+    }
+
+    // Patch extra line on the page
+    var nodes = spanLines.map(function (index) {
+      var item = flattenData[index];
+      var rowKey = getRowKey(item.record, index);
+      var getHeight = function getHeight(rowSpan) {
+        var endItemIndex = index + rowSpan - 1;
+        var endItemKey = getRowKey(flattenData[endItemIndex].record, endItemIndex);
+        var sizeInfo = getSize(rowKey, endItemKey);
+        return sizeInfo.bottom - sizeInfo.top;
+      };
+      var sizeInfo = getSize(rowKey);
+      return /*#__PURE__*/React.createElement(BodyLine, {
+        key: index,
+        data: item,
+        rowKey: rowKey,
+        index: index,
+        style: {
+          top: -offsetY + sizeInfo.top
+        },
+        extra: true,
+        getHeight: getHeight
+      });
+    });
+    return nodes;
+  };
+
+  // ========================= Context ==========================
+  var gridContext = React.useMemo(function () {
+    return {
+      columnsOffset: columnsOffset
+    };
+  }, [columnsOffset]);
+
+  // ========================== Render ==========================
+  var tblPrefixCls = "".concat(prefixCls, "-tbody");
+
+  // default 'div' in rc-virtual-list
+  var wrapperComponent = getComponent(['body', 'wrapper']);
+
+  // ========================== Sticky Scroll Bar ==========================
+  var horizontalScrollBarStyle = {};
+  if (sticky) {
+    horizontalScrollBarStyle.position = 'sticky';
+    horizontalScrollBarStyle.bottom = 0;
+    if (_typeof(sticky) === 'object' && sticky.offsetScroll) {
+      horizontalScrollBarStyle.bottom = sticky.offsetScroll;
+    }
+  }
+  return /*#__PURE__*/React.createElement(GridContext.Provider, {
+    value: gridContext
+  }, /*#__PURE__*/React.createElement(VirtualList, {
+    fullHeight: false,
+    ref: listRef,
+    prefixCls: "".concat(tblPrefixCls, "-virtual"),
+    styles: {
+      horizontalScrollBar: horizontalScrollBarStyle
+    },
+    className: tblPrefixCls,
+    height: scrollY,
+    itemHeight: listItemHeight || 24,
+    data: flattenData,
+    itemKey: function itemKey(item) {
+      return getRowKey(item.record);
+    },
+    component: wrapperComponent,
+    scrollWidth: scrollX,
+    direction: direction,
+    onVirtualScroll: function onVirtualScroll(_ref4) {
+      var _listRef$current7;
+      var x = _ref4.x;
+      onScroll({
+        currentTarget: (_listRef$current7 = listRef.current) === null || _listRef$current7 === void 0 ? void 0 : _listRef$current7.nativeElement,
+        scrollLeft: x
+      });
+    },
+    onScroll: onTablePropScroll,
+    extraRender: extraRender
+  }, function (item, index, itemProps) {
+    var rowKey = getRowKey(item.record, index);
+    return /*#__PURE__*/React.createElement(BodyLine, {
+      data: item,
+      rowKey: rowKey,
+      index: index,
+      style: itemProps.style
+    });
+  }));
+});
+var ResponseGrid = responseImmutable(Grid);
+if (process.env.NODE_ENV !== 'production') {
+  ResponseGrid.displayName = 'ResponseGrid';
+}
+export default ResponseGrid;

node_modules/rc-table/es/VirtualTable/BodyLine.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import type { FlattenData } from '../hooks/useFlattenRecords';
+export interface BodyLineProps<RecordType = any> {
+    data: FlattenData<RecordType>;
+    index: number;
+    className?: string;
+    style?: React.CSSProperties;
+    rowKey: React.Key;
+    /** Render cell only when it has `rowSpan > 1` */
+    extra?: boolean;
+    getHeight?: (rowSpan: number) => number;
+}
+declare const ResponseBodyLine: React.ForwardRefExoticComponent<BodyLineProps<any> & React.RefAttributes<HTMLDivElement>>;
+export default ResponseBodyLine;

node_modules/rc-table/es/VirtualTable/BodyLine.js

@@ -0,0 +1,105 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["data", "index", "className", "rowKey", "style", "extra", "getHeight"];
+import { useContext } from '@rc-component/context';
+import classNames from 'classnames';
+import * as React from 'react';
+import Cell from "../Cell";
+import TableContext, { responseImmutable } from "../context/TableContext";
+import useRowInfo from "../hooks/useRowInfo";
+import VirtualCell from "./VirtualCell";
+import { StaticContext } from "./context";
+import { computedExpandedClassName } from "../utils/expandUtil";
+var BodyLine = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  var data = props.data,
+    index = props.index,
+    className = props.className,
+    rowKey = props.rowKey,
+    style = props.style,
+    extra = props.extra,
+    getHeight = props.getHeight,
+    restProps = _objectWithoutProperties(props, _excluded);
+  var record = data.record,
+    indent = data.indent,
+    renderIndex = data.index;
+  var _useContext = useContext(TableContext, ['prefixCls', 'flattenColumns', 'fixColumn', 'componentWidth', 'scrollX']),
+    scrollX = _useContext.scrollX,
+    flattenColumns = _useContext.flattenColumns,
+    prefixCls = _useContext.prefixCls,
+    fixColumn = _useContext.fixColumn,
+    componentWidth = _useContext.componentWidth;
+  var _useContext2 = useContext(StaticContext, ['getComponent']),
+    getComponent = _useContext2.getComponent;
+  var rowInfo = useRowInfo(record, rowKey, index, indent);
+  var RowComponent = getComponent(['body', 'row'], 'div');
+  var cellComponent = getComponent(['body', 'cell'], 'div');
+
+  // ========================== Expand ==========================
+  var rowSupportExpand = rowInfo.rowSupportExpand,
+    expanded = rowInfo.expanded,
+    rowProps = rowInfo.rowProps,
+    expandedRowRender = rowInfo.expandedRowRender,
+    expandedRowClassName = rowInfo.expandedRowClassName;
+  var expandRowNode;
+  if (rowSupportExpand && expanded) {
+    var expandContent = expandedRowRender(record, index, indent + 1, expanded);
+    var expandedClsName = computedExpandedClassName(expandedRowClassName, record, index, indent);
+    var additionalProps = {};
+    if (fixColumn) {
+      additionalProps = {
+        style: _defineProperty({}, '--virtual-width', "".concat(componentWidth, "px"))
+      };
+    }
+    var rowCellCls = "".concat(prefixCls, "-expanded-row-cell");
+    expandRowNode = /*#__PURE__*/React.createElement(RowComponent, {
+      className: classNames("".concat(prefixCls, "-expanded-row"), "".concat(prefixCls, "-expanded-row-level-").concat(indent + 1), expandedClsName)
+    }, /*#__PURE__*/React.createElement(Cell, {
+      component: cellComponent,
+      prefixCls: prefixCls,
+      className: classNames(rowCellCls, _defineProperty({}, "".concat(rowCellCls, "-fixed"), fixColumn)),
+      additionalProps: additionalProps
+    }, expandContent));
+  }
+
+  // ========================== Render ==========================
+  var rowStyle = _objectSpread(_objectSpread({}, style), {}, {
+    width: scrollX
+  });
+  if (extra) {
+    rowStyle.position = 'absolute';
+    rowStyle.pointerEvents = 'none';
+  }
+  var rowNode = /*#__PURE__*/React.createElement(RowComponent, _extends({}, rowProps, restProps, {
+    "data-row-key": rowKey,
+    ref: rowSupportExpand ? null : ref,
+    className: classNames(className, "".concat(prefixCls, "-row"), rowProps === null || rowProps === void 0 ? void 0 : rowProps.className, _defineProperty({}, "".concat(prefixCls, "-row-extra"), extra)),
+    style: _objectSpread(_objectSpread({}, rowStyle), rowProps === null || rowProps === void 0 ? void 0 : rowProps.style)
+  }), flattenColumns.map(function (column, colIndex) {
+    return /*#__PURE__*/React.createElement(VirtualCell, {
+      key: colIndex,
+      component: cellComponent,
+      rowInfo: rowInfo,
+      column: column,
+      colIndex: colIndex,
+      indent: indent,
+      index: index,
+      renderIndex: renderIndex,
+      record: record,
+      inverse: extra,
+      getHeight: getHeight
+    });
+  }));
+  if (rowSupportExpand) {
+    return /*#__PURE__*/React.createElement("div", {
+      ref: ref
+    }, rowNode, expandRowNode);
+  }
+  return rowNode;
+});
+var ResponseBodyLine = responseImmutable(BodyLine);
+if (process.env.NODE_ENV !== 'production') {
+  ResponseBodyLine.displayName = 'BodyLine';
+}
+export default ResponseBodyLine;

node_modules/rc-table/es/VirtualTable/VirtualCell.d.ts

@@ -0,0 +1,26 @@
+import * as React from 'react';
+import type useRowInfo from '../hooks/useRowInfo';
+import type { ColumnType, CustomizeComponent } from '../interface';
+export interface VirtualCellProps<RecordType> {
+    rowInfo: ReturnType<typeof useRowInfo<RecordType>>;
+    column: ColumnType<RecordType>;
+    colIndex: number;
+    indent: number;
+    index: number;
+    component?: CustomizeComponent;
+    /** Used for `column.render` */
+    renderIndex: number;
+    record: RecordType;
+    style?: React.CSSProperties;
+    className?: string;
+    /** Render cell only when it has `rowSpan > 1` */
+    inverse?: boolean;
+    getHeight?: (rowSpan: number) => number;
+}
+/**
+ * Return the width of the column by `colSpan`.
+ * When `colSpan` is `0` will be trade as `1`.
+ */
+export declare function getColumnWidth(colIndex: number, colSpan: number, columnsOffset: number[]): number;
+declare function VirtualCell<RecordType = any>(props: VirtualCellProps<RecordType>): React.JSX.Element;
+export default VirtualCell;

node_modules/rc-table/es/VirtualTable/VirtualCell.js

@@ -0,0 +1,113 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { useContext } from '@rc-component/context';
+import classNames from 'classnames';
+import * as React from 'react';
+import { getCellProps } from "../Body/BodyRow";
+import Cell from "../Cell";
+import { GridContext } from "./context";
+/**
+ * Return the width of the column by `colSpan`.
+ * When `colSpan` is `0` will be trade as `1`.
+ */
+export function getColumnWidth(colIndex, colSpan, columnsOffset) {
+  var mergedColSpan = colSpan || 1;
+  return columnsOffset[colIndex + mergedColSpan] - (columnsOffset[colIndex] || 0);
+}
+function VirtualCell(props) {
+  var rowInfo = props.rowInfo,
+    column = props.column,
+    colIndex = props.colIndex,
+    indent = props.indent,
+    index = props.index,
+    component = props.component,
+    renderIndex = props.renderIndex,
+    record = props.record,
+    style = props.style,
+    className = props.className,
+    inverse = props.inverse,
+    getHeight = props.getHeight;
+  var render = column.render,
+    dataIndex = column.dataIndex,
+    columnClassName = column.className,
+    colWidth = column.width;
+  var _useContext = useContext(GridContext, ['columnsOffset']),
+    columnsOffset = _useContext.columnsOffset;
+
+  // TODO: support `expandableRowOffset`
+  var _getCellProps = getCellProps(rowInfo, column, colIndex, indent, index),
+    key = _getCellProps.key,
+    fixedInfo = _getCellProps.fixedInfo,
+    appendCellNode = _getCellProps.appendCellNode,
+    additionalCellProps = _getCellProps.additionalCellProps;
+  var cellStyle = additionalCellProps.style,
+    _additionalCellProps$ = additionalCellProps.colSpan,
+    colSpan = _additionalCellProps$ === void 0 ? 1 : _additionalCellProps$,
+    _additionalCellProps$2 = additionalCellProps.rowSpan,
+    rowSpan = _additionalCellProps$2 === void 0 ? 1 : _additionalCellProps$2;
+
+  // ========================= ColWidth =========================
+  // column width
+  var startColIndex = colIndex - 1;
+  var concatColWidth = getColumnWidth(startColIndex, colSpan, columnsOffset);
+
+  // margin offset
+  var marginOffset = colSpan > 1 ? colWidth - concatColWidth : 0;
+
+  // ========================== Style ===========================
+  var mergedStyle = _objectSpread(_objectSpread(_objectSpread({}, cellStyle), style), {}, {
+    flex: "0 0 ".concat(concatColWidth, "px"),
+    width: "".concat(concatColWidth, "px"),
+    marginRight: marginOffset,
+    pointerEvents: 'auto'
+  });
+
+  // When `colSpan` or `rowSpan` is `0`, should skip render.
+  var needHide = React.useMemo(function () {
+    if (inverse) {
+      return rowSpan <= 1;
+    } else {
+      return colSpan === 0 || rowSpan === 0 || rowSpan > 1;
+    }
+  }, [rowSpan, colSpan, inverse]);
+
+  // 0 rowSpan or colSpan should not render
+  if (needHide) {
+    mergedStyle.visibility = 'hidden';
+  } else if (inverse) {
+    mergedStyle.height = getHeight === null || getHeight === void 0 ? void 0 : getHeight(rowSpan);
+  }
+  var mergedRender = needHide ? function () {
+    return null;
+  } : render;
+
+  // ========================== Render ==========================
+  var cellSpan = {};
+
+  // Virtual should reset `colSpan` & `rowSpan`
+  if (rowSpan === 0 || colSpan === 0) {
+    cellSpan.rowSpan = 1;
+    cellSpan.colSpan = 1;
+  }
+  return /*#__PURE__*/React.createElement(Cell, _extends({
+    className: classNames(columnClassName, className),
+    ellipsis: column.ellipsis,
+    align: column.align,
+    scope: column.rowScope,
+    component: component,
+    prefixCls: rowInfo.prefixCls,
+    key: key,
+    record: record,
+    index: index,
+    renderIndex: renderIndex,
+    dataIndex: dataIndex,
+    render: mergedRender,
+    shouldCellUpdate: column.shouldCellUpdate
+  }, fixedInfo, {
+    appendNode: appendCellNode,
+    additionalProps: _objectSpread(_objectSpread({}, additionalCellProps), {}, {
+      style: mergedStyle
+    }, cellSpan)
+  }));
+}
+export default VirtualCell;

node_modules/rc-table/es/VirtualTable/context.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import type { GetComponent, TableSticky } from '../interface';
+export interface StaticContextProps {
+    scrollY: number;
+    listItemHeight: number;
+    sticky: boolean | TableSticky;
+    getComponent: GetComponent;
+    onScroll?: React.UIEventHandler<HTMLDivElement>;
+}
+export declare const StaticContext: import("@rc-component/context").SelectorContext<StaticContextProps>;
+export interface GridContextProps {
+    columnsOffset: number[];
+}
+export declare const GridContext: import("@rc-component/context").SelectorContext<GridContextProps>;

node_modules/rc-table/es/VirtualTable/context.js

@@ -0,0 +1,3 @@
+import { createContext } from '@rc-component/context';
+export var StaticContext = createContext(null);
+export var GridContext = createContext(null);

node_modules/rc-table/es/VirtualTable/index.d.ts

@@ -0,0 +1,17 @@
+import type { CompareProps } from '@rc-component/context/lib/Immutable';
+import * as React from 'react';
+import type { Reference } from '../interface';
+import Table, { type TableProps } from '../Table';
+export interface VirtualTableProps<RecordType> extends Omit<TableProps<RecordType>, 'scroll'> {
+    scroll: {
+        x?: number;
+        y: number;
+    };
+    listItemHeight?: number;
+}
+export type ForwardGenericVirtualTable = (<RecordType>(props: TableProps<RecordType> & React.RefAttributes<Reference>) => React.ReactElement) & {
+    displayName?: string;
+};
+export declare function genVirtualTable(shouldTriggerRender?: CompareProps<typeof Table>): ForwardGenericVirtualTable;
+declare const _default: ForwardGenericVirtualTable;
+export default _default;

node_modules/rc-table/es/VirtualTable/index.js

@@ -0,0 +1,94 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import classNames from 'classnames';
+import { useEvent, warning } from 'rc-util';
+import * as React from 'react';
+import { INTERNAL_HOOKS } from "../constant";
+import { makeImmutable } from "../context/TableContext";
+import Table, { DEFAULT_PREFIX } from "../Table";
+import Grid from "./BodyGrid";
+import { StaticContext } from "./context";
+import getValue from "rc-util/es/utils/get";
+var renderBody = function renderBody(rawData, props) {
+  var ref = props.ref,
+    onScroll = props.onScroll;
+  return /*#__PURE__*/React.createElement(Grid, {
+    ref: ref,
+    data: rawData,
+    onScroll: onScroll
+  });
+};
+function VirtualTable(props, ref) {
+  var data = props.data,
+    columns = props.columns,
+    scroll = props.scroll,
+    sticky = props.sticky,
+    _props$prefixCls = props.prefixCls,
+    prefixCls = _props$prefixCls === void 0 ? DEFAULT_PREFIX : _props$prefixCls,
+    className = props.className,
+    listItemHeight = props.listItemHeight,
+    components = props.components,
+    onScroll = props.onScroll;
+  var _ref = scroll || {},
+    scrollX = _ref.x,
+    scrollY = _ref.y;
+
+  // Fill scrollX
+  if (typeof scrollX !== 'number') {
+    if (process.env.NODE_ENV !== 'production') {
+      warning(!scrollX, '`scroll.x` in virtual table must be number.');
+    }
+    scrollX = 1;
+  }
+
+  // Fill scrollY
+  if (typeof scrollY !== 'number') {
+    scrollY = 500;
+    if (process.env.NODE_ENV !== 'production') {
+      warning(false, '`scroll.y` in virtual table must be number.');
+    }
+  }
+  var getComponent = useEvent(function (path, defaultComponent) {
+    return getValue(components, path) || defaultComponent;
+  });
+
+  // Memo this
+  var onInternalScroll = useEvent(onScroll);
+
+  // ========================= Context ==========================
+  var context = React.useMemo(function () {
+    return {
+      sticky: sticky,
+      scrollY: scrollY,
+      listItemHeight: listItemHeight,
+      getComponent: getComponent,
+      onScroll: onInternalScroll
+    };
+  }, [sticky, scrollY, listItemHeight, getComponent, onInternalScroll]);
+
+  // ========================== Render ==========================
+  return /*#__PURE__*/React.createElement(StaticContext.Provider, {
+    value: context
+  }, /*#__PURE__*/React.createElement(Table, _extends({}, props, {
+    className: classNames(className, "".concat(prefixCls, "-virtual")),
+    scroll: _objectSpread(_objectSpread({}, scroll), {}, {
+      x: scrollX
+    }),
+    components: _objectSpread(_objectSpread({}, components), {}, {
+      // fix https://github.com/ant-design/ant-design/issues/48991
+      body: data !== null && data !== void 0 && data.length ? renderBody : undefined
+    }),
+    columns: columns,
+    internalHooks: INTERNAL_HOOKS,
+    tailor: true,
+    ref: ref
+  })));
+}
+var RefVirtualTable = /*#__PURE__*/React.forwardRef(VirtualTable);
+if (process.env.NODE_ENV !== 'production') {
+  RefVirtualTable.displayName = 'VirtualTable';
+}
+export function genVirtualTable(shouldTriggerRender) {
+  return makeImmutable(RefVirtualTable, shouldTriggerRender);
+}
+export default genVirtualTable();