add all frontend files

node_modules/rc-table/es/Body/BodyRow.d.ts

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

node_modules/rc-table/es/Body/BodyRow.js

@@ -0,0 +1,173 @@
+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 classNames from 'classnames';
+import * as React from 'react';
+import Cell from "../Cell";
+import { responseImmutable } from "../context/TableContext";
+import devRenderTimes from "../hooks/useRenderTimes";
+import useRowInfo from "../hooks/useRowInfo";
+import ExpandedRow from "./ExpandedRow";
+import { computedExpandedClassName } from "../utils/expandUtil";
+// ==================================================================================
+// ==                                 getCellProps                                 ==
+// ==================================================================================
+export function getCellProps(rowInfo, column, colIndex, indent, index) {
+  var _column$onCell;
+  var rowKeys = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : [];
+  var expandedRowOffset = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : 0;
+  var record = rowInfo.record,
+    prefixCls = rowInfo.prefixCls,
+    columnsKey = rowInfo.columnsKey,
+    fixedInfoList = rowInfo.fixedInfoList,
+    expandIconColumnIndex = rowInfo.expandIconColumnIndex,
+    nestExpandable = rowInfo.nestExpandable,
+    indentSize = rowInfo.indentSize,
+    expandIcon = rowInfo.expandIcon,
+    expanded = rowInfo.expanded,
+    hasNestChildren = rowInfo.hasNestChildren,
+    onTriggerExpand = rowInfo.onTriggerExpand,
+    expandable = rowInfo.expandable,
+    expandedKeys = rowInfo.expandedKeys;
+  var key = columnsKey[colIndex];
+  var fixedInfo = fixedInfoList[colIndex];
+
+  // ============= Used for nest expandable =============
+  var appendCellNode;
+  if (colIndex === (expandIconColumnIndex || 0) && nestExpandable) {
+    appendCellNode = /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("span", {
+      style: {
+        paddingLeft: "".concat(indentSize * indent, "px")
+      },
+      className: "".concat(prefixCls, "-row-indent indent-level-").concat(indent)
+    }), expandIcon({
+      prefixCls: prefixCls,
+      expanded: expanded,
+      expandable: hasNestChildren,
+      record: record,
+      onExpand: onTriggerExpand
+    }));
+  }
+  var additionalCellProps = ((_column$onCell = column.onCell) === null || _column$onCell === void 0 ? void 0 : _column$onCell.call(column, record, index)) || {};
+
+  // Expandable row has offset
+  if (expandedRowOffset) {
+    var _additionalCellProps$ = additionalCellProps.rowSpan,
+      rowSpan = _additionalCellProps$ === void 0 ? 1 : _additionalCellProps$;
+
+    // For expandable row with rowSpan,
+    // We should increase the rowSpan if the row is expanded
+    if (expandable && rowSpan && colIndex < expandedRowOffset) {
+      var currentRowSpan = rowSpan;
+      for (var i = index; i < index + rowSpan; i += 1) {
+        var rowKey = rowKeys[i];
+        if (expandedKeys.has(rowKey)) {
+          currentRowSpan += 1;
+        }
+      }
+      additionalCellProps.rowSpan = currentRowSpan;
+    }
+  }
+  return {
+    key: key,
+    fixedInfo: fixedInfo,
+    appendCellNode: appendCellNode,
+    additionalCellProps: additionalCellProps
+  };
+}
+
+// ==================================================================================
+// ==                                 getCellProps                                 ==
+// ==================================================================================
+function BodyRow(props) {
+  if (process.env.NODE_ENV !== 'production') {
+    devRenderTimes(props);
+  }
+  var className = props.className,
+    style = props.style,
+    record = props.record,
+    index = props.index,
+    renderIndex = props.renderIndex,
+    rowKey = props.rowKey,
+    rowKeys = props.rowKeys,
+    _props$indent = props.indent,
+    indent = _props$indent === void 0 ? 0 : _props$indent,
+    RowComponent = props.rowComponent,
+    cellComponent = props.cellComponent,
+    scopeCellComponent = props.scopeCellComponent,
+    expandedRowInfo = props.expandedRowInfo;
+  var rowInfo = useRowInfo(record, rowKey, index, indent);
+  var prefixCls = rowInfo.prefixCls,
+    flattenColumns = rowInfo.flattenColumns,
+    expandedRowClassName = rowInfo.expandedRowClassName,
+    expandedRowRender = rowInfo.expandedRowRender,
+    rowProps = rowInfo.rowProps,
+    expanded = rowInfo.expanded,
+    rowSupportExpand = rowInfo.rowSupportExpand;
+
+  // Force render expand row if expanded before
+  var expandedRef = React.useRef(false);
+  expandedRef.current || (expandedRef.current = expanded);
+  if (process.env.NODE_ENV !== 'production') {
+    devRenderTimes(props);
+  }
+
+  // 若没有 expandedRowRender 参数, 将使用 baseRowNode 渲染 Children
+  // 此时如果 level > 1 则说明是 expandedRow, 一样需要附加 computedExpandedRowClassName
+  var expandedClsName = computedExpandedClassName(expandedRowClassName, record, index, indent);
+
+  // ======================== Base tr row ========================
+  var baseRowNode = /*#__PURE__*/React.createElement(RowComponent, _extends({}, rowProps, {
+    "data-row-key": rowKey,
+    className: classNames(className, "".concat(prefixCls, "-row"), "".concat(prefixCls, "-row-level-").concat(indent), rowProps === null || rowProps === void 0 ? void 0 : rowProps.className, _defineProperty({}, expandedClsName, indent >= 1)),
+    style: _objectSpread(_objectSpread({}, style), rowProps === null || rowProps === void 0 ? void 0 : rowProps.style)
+  }), flattenColumns.map(function (column, colIndex) {
+    var render = column.render,
+      dataIndex = column.dataIndex,
+      columnClassName = column.className;
+    var _getCellProps = getCellProps(rowInfo, column, colIndex, indent, index, rowKeys, expandedRowInfo === null || expandedRowInfo === void 0 ? void 0 : expandedRowInfo.offset),
+      key = _getCellProps.key,
+      fixedInfo = _getCellProps.fixedInfo,
+      appendCellNode = _getCellProps.appendCellNode,
+      additionalCellProps = _getCellProps.additionalCellProps;
+    return /*#__PURE__*/React.createElement(Cell, _extends({
+      className: columnClassName,
+      ellipsis: column.ellipsis,
+      align: column.align,
+      scope: column.rowScope,
+      component: column.rowScope ? scopeCellComponent : cellComponent,
+      prefixCls: prefixCls,
+      key: key,
+      record: record,
+      index: index,
+      renderIndex: renderIndex,
+      dataIndex: dataIndex,
+      render: render,
+      shouldCellUpdate: column.shouldCellUpdate
+    }, fixedInfo, {
+      appendNode: appendCellNode,
+      additionalProps: additionalCellProps
+    }));
+  }));
+
+  // ======================== Expand Row =========================
+  var expandRowNode;
+  if (rowSupportExpand && (expandedRef.current || expanded)) {
+    var expandContent = expandedRowRender(record, index, indent + 1, expanded);
+    expandRowNode = /*#__PURE__*/React.createElement(ExpandedRow, {
+      expanded: expanded,
+      className: classNames("".concat(prefixCls, "-expanded-row"), "".concat(prefixCls, "-expanded-row-level-").concat(indent + 1), expandedClsName),
+      prefixCls: prefixCls,
+      component: RowComponent,
+      cellComponent: cellComponent,
+      colSpan: expandedRowInfo ? expandedRowInfo.colSpan : flattenColumns.length,
+      stickyOffset: expandedRowInfo === null || expandedRowInfo === void 0 ? void 0 : expandedRowInfo.sticky,
+      isEmpty: false
+    }, expandContent);
+  }
+  return /*#__PURE__*/React.createElement(React.Fragment, null, baseRowNode, expandRowNode);
+}
+if (process.env.NODE_ENV !== 'production') {
+  BodyRow.displayName = 'BodyRow';
+}
+export default responseImmutable(BodyRow);

node_modules/rc-table/es/Body/ExpandedRow.d.ts

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

node_modules/rc-table/es/Body/ExpandedRow.js

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

node_modules/rc-table/es/Body/MeasureCell.d.ts

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

node_modules/rc-table/es/Body/MeasureCell.js

@@ -0,0 +1,23 @@
+import * as React from 'react';
+import ResizeObserver from 'rc-resize-observer';
+import useLayoutEffect from "rc-util/es/hooks/useLayoutEffect";
+export default function MeasureCell(_ref) {
+  var columnKey = _ref.columnKey,
+    onColumnResize = _ref.onColumnResize,
+    prefixCls = _ref.prefixCls,
+    title = _ref.title;
+  var cellRef = React.useRef();
+  useLayoutEffect(function () {
+    if (cellRef.current) {
+      onColumnResize(columnKey, cellRef.current.offsetWidth);
+    }
+  }, []);
+  return /*#__PURE__*/React.createElement(ResizeObserver, {
+    data: columnKey
+  }, /*#__PURE__*/React.createElement("th", {
+    ref: cellRef,
+    className: "".concat(prefixCls, "-measure-cell")
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "-measure-cell-content")
+  }, title || '\xa0')));
+}

node_modules/rc-table/es/Body/MeasureRow.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import type { ColumnType } from '../interface';
+export interface MeasureRowProps {
+    prefixCls: string;
+    onColumnResize: (key: React.Key, width: number) => void;
+    columnsKey: React.Key[];
+    columns: readonly ColumnType<any>[];
+}
+export default function MeasureRow({ prefixCls, columnsKey, onColumnResize, columns, }: MeasureRowProps): string | number | boolean | Iterable<React.ReactNode> | React.JSX.Element;

node_modules/rc-table/es/Body/MeasureRow.js

@@ -0,0 +1,47 @@
+import * as React from 'react';
+import ResizeObserver from 'rc-resize-observer';
+import MeasureCell from "./MeasureCell";
+import isVisible from "rc-util/es/Dom/isVisible";
+import { useContext } from '@rc-component/context';
+import TableContext from "../context/TableContext";
+export default function MeasureRow(_ref) {
+  var prefixCls = _ref.prefixCls,
+    columnsKey = _ref.columnsKey,
+    onColumnResize = _ref.onColumnResize,
+    columns = _ref.columns;
+  var ref = React.useRef(null);
+  var _useContext = useContext(TableContext, ['measureRowRender']),
+    measureRowRender = _useContext.measureRowRender;
+  var measureRow = /*#__PURE__*/React.createElement("tr", {
+    "aria-hidden": "true",
+    className: "".concat(prefixCls, "-measure-row"),
+    ref: ref,
+    tabIndex: -1
+  }, /*#__PURE__*/React.createElement(ResizeObserver.Collection, {
+    onBatchResize: function onBatchResize(infoList) {
+      if (isVisible(ref.current)) {
+        infoList.forEach(function (_ref2) {
+          var columnKey = _ref2.data,
+            size = _ref2.size;
+          onColumnResize(columnKey, size.offsetWidth);
+        });
+      }
+    }
+  }, columnsKey.map(function (columnKey) {
+    var column = columns.find(function (col) {
+      return col.key === columnKey;
+    });
+    var rawTitle = column === null || column === void 0 ? void 0 : column.title;
+    var titleForMeasure = /*#__PURE__*/React.isValidElement(rawTitle) ? /*#__PURE__*/React.cloneElement(rawTitle, {
+      ref: null
+    }) : rawTitle;
+    return /*#__PURE__*/React.createElement(MeasureCell, {
+      prefixCls: prefixCls,
+      key: columnKey,
+      columnKey: columnKey,
+      onColumnResize: onColumnResize,
+      title: titleForMeasure
+    });
+  })));
+  return measureRowRender ? measureRowRender(measureRow) : measureRow;
+}

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

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

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

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