Latest updates from IceHrmPro

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

@@ -0,0 +1,26 @@
+import * as React from 'react';
+import { StickyOffsets, CustomizeComponent, GetComponentProps, Key, GetRowKey } from '../interface';
+export interface BodyRowProps<RecordType> {
+    record: RecordType;
+    index: number;
+    className?: string;
+    style?: React.CSSProperties;
+    stickyOffsets: StickyOffsets;
+    recordKey: Key;
+    expandedKeys: Set<Key>;
+    rowComponent: CustomizeComponent;
+    cellComponent: CustomizeComponent;
+    onRow: GetComponentProps<RecordType>;
+    rowExpandable: (record: RecordType) => boolean;
+    indent?: number;
+    rowKey: React.Key;
+    getRowKey: GetRowKey<RecordType>;
+    childrenColumnName: string;
+}
+declare function BodyRow<RecordType extends {
+    children?: RecordType[];
+}>(props: BodyRowProps<RecordType>): JSX.Element;
+declare namespace BodyRow {
+    var displayName: string;
+}
+export default BodyRow;

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

@@ -0,0 +1,209 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+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(n); 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(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import * as React from 'react';
+import classNames from 'classnames';
+import Cell from '../Cell';
+import TableContext from '../context/TableContext';
+import BodyContext from '../context/BodyContext';
+import { getColumnsKey } from '../utils/valueUtil';
+import { getCellFixedInfo } from '../utils/fixUtil';
+import ExpandedRow from './ExpandedRow';
+
+function BodyRow(props) {
+  var className = props.className,
+      style = props.style,
+      stickyOffsets = props.stickyOffsets,
+      record = props.record,
+      index = props.index,
+      rowKey = props.rowKey,
+      getRowKey = props.getRowKey,
+      rowExpandable = props.rowExpandable,
+      onRow = props.onRow,
+      _props$indent = props.indent,
+      indent = _props$indent === void 0 ? 0 : _props$indent,
+      RowComponent = props.rowComponent,
+      cellComponent = props.cellComponent,
+      childrenColumnName = props.childrenColumnName;
+
+  var _React$useContext = React.useContext(TableContext),
+      prefixCls = _React$useContext.prefixCls,
+      direction = _React$useContext.direction;
+
+  var _React$useContext2 = React.useContext(BodyContext),
+      fixHeader = _React$useContext2.fixHeader,
+      fixColumn = _React$useContext2.fixColumn,
+      horizonScroll = _React$useContext2.horizonScroll,
+      componentWidth = _React$useContext2.componentWidth,
+      flattenColumns = _React$useContext2.flattenColumns,
+      expandableType = _React$useContext2.expandableType,
+      expandRowByClick = _React$useContext2.expandRowByClick,
+      onTriggerExpand = _React$useContext2.onTriggerExpand,
+      rowClassName = _React$useContext2.rowClassName,
+      expandedRowClassName = _React$useContext2.expandedRowClassName,
+      indentSize = _React$useContext2.indentSize,
+      expandIcon = _React$useContext2.expandIcon,
+      expandedRowRender = _React$useContext2.expandedRowRender,
+      expandIconColumnIndex = _React$useContext2.expandIconColumnIndex;
+
+  var _React$useState = React.useState(false),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      expandRended = _React$useState2[0],
+      setExpandRended = _React$useState2[1];
+
+  var expanded = props.expandedKeys.has(props.recordKey);
+  React.useEffect(function () {
+    if (expanded) {
+      setExpandRended(true);
+    }
+  }, [expanded]); // Move to Body to enhance performance
+
+  var fixedInfoList = flattenColumns.map(function (column, colIndex) {
+    return getCellFixedInfo(colIndex, colIndex, flattenColumns, stickyOffsets, direction);
+  });
+  var rowSupportExpand = expandableType === 'row' && (!rowExpandable || rowExpandable(record)); // Only when row is not expandable and `children` exist in record
+
+  var nestExpandable = expandableType === 'nest';
+  var hasNestChildren = childrenColumnName in record && record[childrenColumnName];
+  var mergedExpandable = rowSupportExpand || nestExpandable; // =========================== onRow ===========================
+
+  var additionalProps;
+
+  if (onRow) {
+    additionalProps = onRow(record, index);
+  }
+
+  var onClick = function onClick(event) {
+    if (expandRowByClick && mergedExpandable) {
+      onTriggerExpand(record, event);
+    }
+
+    if (additionalProps && additionalProps.onClick) {
+      var _additionalProps;
+
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+
+      (_additionalProps = additionalProps).onClick.apply(_additionalProps, [event].concat(args));
+    }
+  }; // ======================== Base tr row ========================
+
+
+  var computeRowClassName;
+
+  if (typeof rowClassName === 'string') {
+    computeRowClassName = rowClassName;
+  } else if (typeof rowClassName === 'function') {
+    computeRowClassName = rowClassName(record, index, indent);
+  }
+
+  var columnsKey = getColumnsKey(flattenColumns);
+  var baseRowNode = React.createElement(RowComponent, Object.assign({}, additionalProps, {
+    "data-row-key": rowKey,
+    className: classNames(className, "".concat(prefixCls, "-row"), "".concat(prefixCls, "-row-level-").concat(indent), computeRowClassName, additionalProps && additionalProps.className),
+    style: _objectSpread({}, style, {}, additionalProps ? additionalProps.style : null),
+    onClick: onClick
+  }), flattenColumns.map(function (column, colIndex) {
+    var render = column.render,
+        dataIndex = column.dataIndex,
+        columnClassName = column.className;
+    var key = columnsKey[colIndex];
+    var fixedInfo = fixedInfoList[colIndex]; // ============= Used for nest expandable =============
+
+    var appendCellNode;
+
+    if (colIndex === (expandIconColumnIndex || 0) && nestExpandable) {
+      appendCellNode = React.createElement(React.Fragment, null, 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;
+
+    if (column.onCell) {
+      additionalCellProps = column.onCell(record, index);
+    }
+
+    return React.createElement(Cell, Object.assign({
+      className: columnClassName,
+      ellipsis: column.ellipsis,
+      align: column.align,
+      component: cellComponent,
+      prefixCls: prefixCls,
+      key: key,
+      record: record,
+      index: index,
+      dataIndex: dataIndex,
+      render: render
+    }, fixedInfo, {
+      appendNode: appendCellNode,
+      additionalProps: additionalCellProps
+    }));
+  })); // ======================== Expand Row =========================
+
+  var expandRowNode;
+
+  if (rowSupportExpand && (expandRended || expanded)) {
+    var expandContent = expandedRowRender(record, index, indent + 1, expanded);
+    var computedExpandedRowClassName = expandedRowClassName && expandedRowClassName(record, index, indent);
+    expandRowNode = React.createElement(ExpandedRow, {
+      expanded: expanded,
+      className: classNames("".concat(prefixCls, "-expanded-row"), "".concat(prefixCls, "-expanded-row-level-").concat(indent + 1), computedExpandedRowClassName),
+      prefixCls: prefixCls,
+      fixHeader: fixHeader,
+      fixColumn: fixColumn,
+      horizonScroll: horizonScroll,
+      component: RowComponent,
+      componentWidth: componentWidth,
+      cellComponent: cellComponent,
+      colSpan: flattenColumns.length
+    }, expandContent);
+  } // ========================= Nest Row ==========================
+
+
+  var nestRowNode;
+
+  if (hasNestChildren && expanded) {
+    nestRowNode = (record[childrenColumnName] || []).map(function (subRecord, subIndex) {
+      var subKey = getRowKey(subRecord, subIndex);
+      return React.createElement(BodyRow, Object.assign({}, props, {
+        key: subKey,
+        rowKey: subKey,
+        record: subRecord,
+        recordKey: subKey,
+        index: subIndex,
+        indent: indent + 1
+      }));
+    });
+  }
+
+  return React.createElement(React.Fragment, null, baseRowNode, expandRowNode, nestRowNode);
+}
+
+BodyRow.displayName = 'BodyRow';
+export default BodyRow;

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

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { CustomizeComponent } from '../interface';
+export interface ExpandedRowProps<RecordType> {
+    prefixCls: string;
+    component: CustomizeComponent;
+    cellComponent: CustomizeComponent;
+    fixHeader: boolean;
+    fixColumn: boolean;
+    horizonScroll: boolean;
+    componentWidth: number;
+    className: string;
+    expanded: boolean;
+    children: React.ReactNode;
+    colSpan: number;
+}
+declare function ExpandedRow<RecordType>({ prefixCls, children, component: Component, cellComponent, fixHeader, fixColumn, horizonScroll, className, expanded, componentWidth, colSpan, }: ExpandedRowProps<RecordType>): JSX.Element;
+export default ExpandedRow;

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

@@ -0,0 +1,50 @@
+import * as React from 'react';
+import Cell from '../Cell';
+import TableContext from '../context/TableContext';
+
+function ExpandedRow(_ref) {
+  var prefixCls = _ref.prefixCls,
+      children = _ref.children,
+      Component = _ref.component,
+      cellComponent = _ref.cellComponent,
+      fixHeader = _ref.fixHeader,
+      fixColumn = _ref.fixColumn,
+      horizonScroll = _ref.horizonScroll,
+      className = _ref.className,
+      expanded = _ref.expanded,
+      componentWidth = _ref.componentWidth,
+      colSpan = _ref.colSpan;
+
+  var _React$useContext = React.useContext(TableContext),
+      scrollbarSize = _React$useContext.scrollbarSize; // Cache render node
+
+
+  return React.useMemo(function () {
+    var contentNode = children;
+
+    if (fixColumn) {
+      contentNode = React.createElement("div", {
+        style: {
+          width: componentWidth - (fixHeader ? scrollbarSize : 0),
+          position: 'sticky',
+          left: 0,
+          overflow: 'hidden'
+        },
+        className: "".concat(prefixCls, "-expanded-row-fixed")
+      }, contentNode);
+    }
+
+    return React.createElement(Component, {
+      className: className,
+      style: {
+        display: expanded ? null : 'none'
+      }
+    }, React.createElement(Cell, {
+      component: cellComponent,
+      prefixCls: prefixCls,
+      colSpan: colSpan
+    }, contentNode));
+  }, [children, Component, fixHeader, horizonScroll, className, expanded, componentWidth, colSpan, scrollbarSize]);
+}
+
+export default ExpandedRow;

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

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { GetRowKey, StickyOffsets, Key, GetComponentProps } from '../interface';
+export interface BodyProps<RecordType> {
+    data: RecordType[];
+    getRowKey: GetRowKey<RecordType>;
+    measureColumnWidth: boolean;
+    stickyOffsets: StickyOffsets;
+    expandedKeys: Set<Key>;
+    onRow: GetComponentProps<RecordType>;
+    rowExpandable: (record: RecordType) => boolean;
+    emptyNode: React.ReactNode;
+    childrenColumnName: string;
+}
+declare function Body<RecordType>({ data, getRowKey, measureColumnWidth, stickyOffsets, expandedKeys, onRow, rowExpandable, emptyNode, childrenColumnName, }: BodyProps<RecordType>): JSX.Element;
+declare const MemoBody: React.MemoExoticComponent<typeof Body>;
+export default MemoBody;

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

@@ -0,0 +1,103 @@
+import * as React from 'react';
+import ResizeObserver from 'rc-resize-observer';
+import BodyRow from './BodyRow';
+import TableContext from '../context/TableContext';
+import ExpandedRow from './ExpandedRow';
+import BodyContext from '../context/BodyContext';
+import { getColumnsKey } from '../utils/valueUtil';
+import ResizeContext from '../context/ResizeContext';
+
+function Body(_ref) {
+  var data = _ref.data,
+      getRowKey = _ref.getRowKey,
+      measureColumnWidth = _ref.measureColumnWidth,
+      stickyOffsets = _ref.stickyOffsets,
+      expandedKeys = _ref.expandedKeys,
+      onRow = _ref.onRow,
+      rowExpandable = _ref.rowExpandable,
+      emptyNode = _ref.emptyNode,
+      childrenColumnName = _ref.childrenColumnName;
+
+  var _React$useContext = React.useContext(ResizeContext),
+      onColumnResize = _React$useContext.onColumnResize;
+
+  var _React$useContext2 = React.useContext(TableContext),
+      prefixCls = _React$useContext2.prefixCls,
+      getComponent = _React$useContext2.getComponent;
+
+  var _React$useContext3 = React.useContext(BodyContext),
+      fixHeader = _React$useContext3.fixHeader,
+      horizonScroll = _React$useContext3.horizonScroll,
+      flattenColumns = _React$useContext3.flattenColumns,
+      componentWidth = _React$useContext3.componentWidth;
+
+  return React.useMemo(function () {
+    var WrapperComponent = getComponent(['body', 'wrapper'], 'tbody');
+    var trComponent = getComponent(['body', 'row'], 'tr');
+    var tdComponent = getComponent(['body', 'cell'], 'td');
+    var rows;
+
+    if (data.length) {
+      rows = data.map(function (record, index) {
+        var key = getRowKey(record, index);
+        return [React.createElement(BodyRow, {
+          key: key,
+          rowKey: key,
+          record: record,
+          recordKey: key,
+          index: index,
+          rowComponent: trComponent,
+          cellComponent: tdComponent,
+          stickyOffsets: stickyOffsets,
+          expandedKeys: expandedKeys,
+          onRow: onRow,
+          getRowKey: getRowKey,
+          rowExpandable: rowExpandable,
+          childrenColumnName: childrenColumnName
+        })];
+      });
+    } else {
+      rows = React.createElement(ExpandedRow, {
+        expanded: true,
+        className: "".concat(prefixCls, "-placeholder"),
+        prefixCls: prefixCls,
+        fixHeader: fixHeader,
+        fixColumn: horizonScroll,
+        horizonScroll: horizonScroll,
+        component: trComponent,
+        componentWidth: componentWidth,
+        cellComponent: tdComponent,
+        colSpan: flattenColumns.length
+      }, emptyNode);
+    }
+
+    var columnsKey = getColumnsKey(flattenColumns);
+    return React.createElement(WrapperComponent, {
+      className: "".concat(prefixCls, "-tbody")
+    }, measureColumnWidth && React.createElement("tr", {
+      "aria-hidden": "true",
+      className: "".concat(prefixCls, "-measure-row"),
+      style: {
+        height: 0
+      }
+    }, columnsKey.map(function (columnKey) {
+      return React.createElement(ResizeObserver, {
+        key: columnKey,
+        onResize: function onResize(_ref2) {
+          var offsetWidth = _ref2.offsetWidth;
+          onColumnResize(columnKey, offsetWidth);
+        }
+      }, React.createElement("td", {
+        style: {
+          padding: 0,
+          border: 0,
+          height: 0
+        }
+      }));
+    })), rows);
+  }, [data, prefixCls, onRow, measureColumnWidth, stickyOffsets, expandedKeys, getRowKey, getComponent, componentWidth, emptyNode]);
+}
+
+var MemoBody = React.memo(Body);
+MemoBody.displayName = 'Body';
+export default MemoBody;

web/node_modules/rc-table/es/Cell/index.d.ts

@@ -0,0 +1,28 @@
+import * as React from 'react';
+import { DataIndex, ColumnType, CustomizeComponent, DefaultRecordType, AlignType } from '../interface';
+export interface CellProps<RecordType extends DefaultRecordType> {
+    prefixCls?: string;
+    className?: string;
+    record?: RecordType;
+    /** `record` index. Not `column` index. */
+    index?: number;
+    dataIndex?: DataIndex;
+    render?: ColumnType<RecordType>['render'];
+    component?: CustomizeComponent;
+    children?: React.ReactNode;
+    colSpan?: number;
+    rowSpan?: number;
+    ellipsis?: boolean;
+    align?: AlignType;
+    fixLeft?: number | false;
+    fixRight?: number | false;
+    firstFixLeft?: boolean;
+    lastFixLeft?: boolean;
+    firstFixRight?: boolean;
+    lastFixRight?: boolean;
+    /** @private Used for `expandable` with nest tree */
+    appendNode?: React.ReactNode;
+    additionalProps?: React.HTMLAttributes<HTMLElement>;
+}
+declare const RefCell: React.ForwardRefExoticComponent<CellProps<Record<string, any>> & React.RefAttributes<any>>;
+export default RefCell;

web/node_modules/rc-table/es/Cell/index.js

@@ -0,0 +1,153 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+import * as React from 'react';
+import classNames from 'classnames';
+import { supportRef } from "rc-util/es/ref";
+import { getPathValue } from '../utils/valueUtil';
+
+function isRenderCell(data) {
+  return data && _typeof(data) === 'object' && !Array.isArray(data) && !React.isValidElement(data);
+}
+
+function isRefComponent(component) {
+  // String tag component also support ref
+  if (typeof component === 'string') {
+    return true;
+  }
+
+  return supportRef(component);
+}
+
+function Cell(_ref, ref) {
+  var _classNames;
+
+  var prefixCls = _ref.prefixCls,
+      className = _ref.className,
+      record = _ref.record,
+      index = _ref.index,
+      dataIndex = _ref.dataIndex,
+      render = _ref.render,
+      children = _ref.children,
+      _ref$component = _ref.component,
+      Component = _ref$component === void 0 ? 'td' : _ref$component,
+      colSpan = _ref.colSpan,
+      rowSpan = _ref.rowSpan,
+      fixLeft = _ref.fixLeft,
+      fixRight = _ref.fixRight,
+      firstFixLeft = _ref.firstFixLeft,
+      lastFixLeft = _ref.lastFixLeft,
+      firstFixRight = _ref.firstFixRight,
+      lastFixRight = _ref.lastFixRight,
+      appendNode = _ref.appendNode,
+      _ref$additionalProps = _ref.additionalProps,
+      additionalProps = _ref$additionalProps === void 0 ? {} : _ref$additionalProps,
+      ellipsis = _ref.ellipsis,
+      align = _ref.align;
+  var cellPrefixCls = "".concat(prefixCls, "-cell"); // ==================== Child Node ====================
+
+  var cellProps;
+  var childNode;
+
+  if (children) {
+    childNode = children;
+  } else {
+    var value = getPathValue(record, dataIndex); // Customize render node
+
+    childNode = value;
+
+    if (render) {
+      var renderData = render(value, record, index);
+
+      if (isRenderCell(renderData)) {
+        childNode = renderData.children;
+        cellProps = renderData.props;
+      } else {
+        childNode = renderData;
+      }
+    }
+  } // Not crash if final `childNode` is not validate ReactNode
+
+
+  if (_typeof(childNode) === 'object' && !Array.isArray(childNode) && !React.isValidElement(childNode)) {
+    childNode = null;
+  }
+
+  if (ellipsis && (lastFixLeft || firstFixRight)) {
+    childNode = React.createElement("span", {
+      className: "".concat(cellPrefixCls, "-content")
+    }, childNode);
+  }
+
+  var _ref2 = cellProps || {},
+      cellColSpan = _ref2.colSpan,
+      cellRowSpan = _ref2.rowSpan,
+      cellStyle = _ref2.style,
+      cellClassName = _ref2.className,
+      restCellProps = _objectWithoutProperties(_ref2, ["colSpan", "rowSpan", "style", "className"]);
+
+  var mergedColSpan = cellColSpan !== undefined ? cellColSpan : colSpan;
+  var mergedRowSpan = cellRowSpan !== undefined ? cellRowSpan : rowSpan;
+
+  if (mergedColSpan === 0 || mergedRowSpan === 0) {
+    return null;
+  } // ====================== Fixed =======================
+
+
+  var fixedStyle = {};
+  var isFixLeft = typeof fixLeft === 'number';
+  var isFixRight = typeof fixRight === 'number';
+
+  if (isFixLeft) {
+    fixedStyle.position = 'sticky';
+    fixedStyle.left = fixLeft;
+  }
+
+  if (isFixRight) {
+    fixedStyle.position = 'sticky';
+    fixedStyle.right = fixRight;
+  } // ====================== Align =======================
+
+
+  var alignStyle = {};
+
+  if (align) {
+    alignStyle.textAlign = align;
+  } // ====================== Render ======================
+
+
+  var title;
+
+  if (ellipsis) {
+    if (typeof childNode === 'string') {
+      title = childNode;
+    } else if (React.isValidElement(childNode) && typeof childNode.props.children === 'string') {
+      title = childNode.props.children;
+    }
+  }
+
+  var componentProps = _objectSpread({
+    title: title
+  }, restCellProps, {}, additionalProps, {
+    colSpan: mergedColSpan && mergedColSpan !== 1 ? mergedColSpan : null,
+    rowSpan: mergedRowSpan && mergedRowSpan !== 1 ? mergedRowSpan : null,
+    className: classNames(cellPrefixCls, className, (_classNames = {}, _defineProperty(_classNames, "".concat(cellPrefixCls, "-fix-left"), isFixLeft), _defineProperty(_classNames, "".concat(cellPrefixCls, "-fix-left-first"), firstFixLeft), _defineProperty(_classNames, "".concat(cellPrefixCls, "-fix-left-last"), lastFixLeft), _defineProperty(_classNames, "".concat(cellPrefixCls, "-fix-right"), isFixRight), _defineProperty(_classNames, "".concat(cellPrefixCls, "-fix-right-first"), firstFixRight), _defineProperty(_classNames, "".concat(cellPrefixCls, "-fix-right-last"), lastFixRight), _defineProperty(_classNames, "".concat(cellPrefixCls, "-ellipsis"), ellipsis), _defineProperty(_classNames, "".concat(cellPrefixCls, "-with-append"), appendNode), _classNames), additionalProps.className, cellClassName),
+    style: _objectSpread({}, additionalProps.style, {}, alignStyle, {}, fixedStyle, {}, cellStyle),
+    ref: isRefComponent(Component) ? ref : null
+  });
+
+  return React.createElement(Component, Object.assign({}, componentProps), appendNode, childNode);
+}
+
+var RefCell = React.forwardRef(Cell);
+RefCell.displayName = 'Cell';
+export default RefCell;

web/node_modules/rc-table/es/ColGroup.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { ColumnType } from './interface';
+export interface ColGroupProps<RecordType> {
+    colWidths: (number | string)[];
+    columns?: ColumnType<RecordType>[];
+    columCount?: number;
+}
+declare function ColGroup<RecordType>({ colWidths, columns, columCount }: ColGroupProps<RecordType>): JSX.Element;
+export default ColGroup;

web/node_modules/rc-table/es/ColGroup.js

@@ -0,0 +1,34 @@
+import * as React from 'react';
+import { INTERNAL_COL_DEFINE } from './utils/legacyUtil';
+
+function ColGroup(_ref) {
+  var colWidths = _ref.colWidths,
+      columns = _ref.columns,
+      columCount = _ref.columCount;
+  var cols = [];
+  var len = columCount || columns.length; // Only insert col with width & additional props
+  // Skip if rest col do not have any useful info
+
+  var mustInsert = false;
+
+  for (var i = len - 1; i >= 0; i -= 1) {
+    var width = colWidths[i];
+    var column = columns && columns[i];
+    var additionalProps = column && column[INTERNAL_COL_DEFINE];
+
+    if (width || additionalProps || mustInsert) {
+      cols.unshift(React.createElement("col", Object.assign({
+        key: i,
+        style: {
+          width: width,
+          minWidth: width
+        }
+      }, additionalProps)));
+      mustInsert = true;
+    }
+  }
+
+  return React.createElement("colgroup", null, cols);
+}
+
+export default ColGroup;

web/node_modules/rc-table/es/Footer/index.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+export interface FooterProps {
+    children: React.ReactNode;
+}
+declare function Footer({ children }: FooterProps): JSX.Element;
+export default Footer;

web/node_modules/rc-table/es/Footer/index.js

@@ -0,0 +1,8 @@
+import * as React from 'react';
+
+function Footer(_ref) {
+  var children = _ref.children;
+  return React.createElement("tfoot", null, children);
+}
+
+export default Footer;

web/node_modules/rc-table/es/Header/FixedHeader.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { HeaderProps } from './Header';
+export interface FixedHeaderProps<RecordType> extends HeaderProps<RecordType> {
+    colWidths: number[];
+    columCount: number;
+    direction: 'ltr' | 'rtl';
+}
+declare function FixedHeader<RecordType>({ columns, flattenColumns, colWidths, columCount, stickyOffsets, direction, ...props }: FixedHeaderProps<RecordType>): JSX.Element;
+export default FixedHeader;

web/node_modules/rc-table/es/Header/FixedHeader.js

@@ -0,0 +1,94 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread 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(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+import * as React from 'react';
+import Header from './Header';
+import ColGroup from '../ColGroup';
+import TableContext from '../context/TableContext';
+
+function FixedHeader(_ref) {
+  var columns = _ref.columns,
+      flattenColumns = _ref.flattenColumns,
+      colWidths = _ref.colWidths,
+      columCount = _ref.columCount,
+      stickyOffsets = _ref.stickyOffsets,
+      direction = _ref.direction,
+      props = _objectWithoutProperties(_ref, ["columns", "flattenColumns", "colWidths", "columCount", "stickyOffsets", "direction"]);
+
+  var _React$useContext = React.useContext(TableContext),
+      prefixCls = _React$useContext.prefixCls,
+      scrollbarSize = _React$useContext.scrollbarSize; // Add scrollbar column
+
+
+  var lastColumn = flattenColumns[flattenColumns.length - 1];
+  var ScrollBarColumn = {
+    fixed: lastColumn ? lastColumn.fixed : null,
+    onHeaderCell: function onHeaderCell() {
+      return {
+        className: "".concat(prefixCls, "-cell-scrollbar")
+      };
+    }
+  };
+  var columnsWithScrollbar = React.useMemo(function () {
+    return scrollbarSize ? [].concat(_toConsumableArray(columns), [ScrollBarColumn]) : columns;
+  }, [scrollbarSize, columns]);
+  var flattenColumnsWithScrollbar = React.useMemo(function () {
+    return scrollbarSize ? [].concat(_toConsumableArray(flattenColumns), [ScrollBarColumn]) : flattenColumns;
+  }, [scrollbarSize, flattenColumns]); // Calculate the sticky offsets
+
+  var headerStickyOffsets = React.useMemo(function () {
+    var right = stickyOffsets.right,
+        left = stickyOffsets.left;
+    return _objectSpread({}, stickyOffsets, {
+      left: direction === 'rtl' ? [].concat(_toConsumableArray(left.map(function (width) {
+        return width + scrollbarSize;
+      })), [0]) : left,
+      right: direction === 'rtl' ? right : [].concat(_toConsumableArray(right.map(function (width) {
+        return width + scrollbarSize;
+      })), [0])
+    });
+  }, [scrollbarSize, stickyOffsets]);
+  var cloneWidths = [];
+
+  for (var i = 0; i < columCount; i += 1) {
+    cloneWidths[i] = colWidths[i];
+  }
+
+  var columnWidthsReady = !colWidths.every(function (width) {
+    return !width;
+  });
+  return React.createElement("table", {
+    style: {
+      tableLayout: 'fixed',
+      visibility: columnWidthsReady ? null : 'hidden'
+    }
+  }, React.createElement(ColGroup, {
+    colWidths: [].concat(_toConsumableArray(colWidths), [scrollbarSize]),
+    columCount: columCount + 1
+  }), React.createElement(Header, Object.assign({}, props, {
+    stickyOffsets: headerStickyOffsets,
+    columns: columnsWithScrollbar,
+    flattenColumns: flattenColumnsWithScrollbar
+  })));
+}
+
+export default FixedHeader;

web/node_modules/rc-table/es/Header/Header.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import { ColumnsType, StickyOffsets, ColumnType, GetComponentProps } from '../interface';
+export interface HeaderProps<RecordType> {
+    columns: ColumnsType<RecordType>;
+    flattenColumns: ColumnType<RecordType>[];
+    stickyOffsets: StickyOffsets;
+    onHeaderRow: GetComponentProps<ColumnType<RecordType>[]>;
+}
+declare function Header<RecordType>({ stickyOffsets, columns, flattenColumns, onHeaderRow, }: HeaderProps<RecordType>): React.ReactElement;
+export default Header;

web/node_modules/rc-table/es/Header/Header.js

@@ -0,0 +1,102 @@
+import * as React from 'react';
+import HeaderRow from './HeaderRow';
+import TableContext from '../context/TableContext';
+
+function parseHeaderRows(rootColumns) {
+  var rows = [];
+
+  function fillRowCells(columns, colIndex) {
+    var rowIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    // Init rows
+    rows[rowIndex] = rows[rowIndex] || [];
+    var currentColIndex = colIndex;
+    var colSpans = columns.map(function (column) {
+      var cell = {
+        key: column.key,
+        className: column.className || '',
+        children: column.title,
+        column: column,
+        colStart: currentColIndex
+      };
+      var colSpan = 1;
+      var subColumns = column.children;
+
+      if (subColumns && subColumns.length > 0) {
+        colSpan = fillRowCells(subColumns, currentColIndex, rowIndex + 1).reduce(function (total, count) {
+          return total + count;
+        }, 0);
+        cell.hasSubColumns = true;
+      }
+
+      if ('colSpan' in column) {
+        colSpan = column.colSpan;
+      }
+
+      if ('rowSpan' in column) {
+        cell.rowSpan = column.rowSpan;
+      }
+
+      cell.colSpan = colSpan;
+      cell.colEnd = cell.colStart + colSpan - 1;
+      rows[rowIndex].push(cell);
+      currentColIndex += colSpan;
+      return colSpan;
+    });
+    return colSpans;
+  } // Generate `rows` cell data
+
+
+  fillRowCells(rootColumns, 0); // Handle `rowSpan`
+
+  var rowCount = rows.length;
+
+  var _loop = function _loop(rowIndex) {
+    rows[rowIndex].forEach(function (cell) {
+      if (!('rowSpan' in cell) && !cell.hasSubColumns) {
+        // eslint-disable-next-line no-param-reassign
+        cell.rowSpan = rowCount - rowIndex;
+      }
+    });
+  };
+
+  for (var rowIndex = 0; rowIndex < rowCount; rowIndex += 1) {
+    _loop(rowIndex);
+  }
+
+  return rows;
+}
+
+function Header(_ref) {
+  var stickyOffsets = _ref.stickyOffsets,
+      columns = _ref.columns,
+      flattenColumns = _ref.flattenColumns,
+      onHeaderRow = _ref.onHeaderRow;
+
+  var _React$useContext = React.useContext(TableContext),
+      prefixCls = _React$useContext.prefixCls,
+      getComponent = _React$useContext.getComponent;
+
+  var rows = React.useMemo(function () {
+    return parseHeaderRows(columns);
+  }, [columns]);
+  var WrapperComponent = getComponent(['header', 'wrapper'], 'thead');
+  var trComponent = getComponent(['header', 'row'], 'tr');
+  var thComponent = getComponent(['header', 'cell'], 'th');
+  return React.createElement(WrapperComponent, {
+    className: "".concat(prefixCls, "-thead")
+  }, rows.map(function (row, rowIndex) {
+    var rowNode = React.createElement(HeaderRow, {
+      key: rowIndex,
+      flattenColumns: flattenColumns,
+      cells: row,
+      stickyOffsets: stickyOffsets,
+      rowComponent: trComponent,
+      cellComponent: thComponent,
+      onHeaderRow: onHeaderRow,
+      index: rowIndex
+    });
+    return rowNode;
+  }));
+}
+
+export default Header;

web/node_modules/rc-table/es/Header/HeaderRow.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+import { CellType, StickyOffsets, ColumnType, CustomizeComponent, GetComponentProps } from '../interface';
+export interface RowProps<RecordType> {
+    cells: CellType<RecordType>[];
+    stickyOffsets: StickyOffsets;
+    flattenColumns: ColumnType<RecordType>[];
+    rowComponent: CustomizeComponent;
+    cellComponent: CustomizeComponent;
+    onHeaderRow: GetComponentProps<ColumnType<RecordType>[]>;
+    index: number;
+}
+declare function HeaderRow<RecordType>({ cells, stickyOffsets, flattenColumns, rowComponent: RowComponent, cellComponent: CellComponent, onHeaderRow, index, }: RowProps<RecordType>): JSX.Element;
+declare namespace HeaderRow {
+    var displayName: string;
+}
+export default HeaderRow;

web/node_modules/rc-table/es/Header/HeaderRow.js

@@ -0,0 +1,53 @@
+import * as React from 'react';
+import Cell from '../Cell';
+import TableContext from '../context/TableContext';
+import { getCellFixedInfo } from '../utils/fixUtil';
+import { getColumnsKey } from '../utils/valueUtil';
+
+function HeaderRow(_ref) {
+  var cells = _ref.cells,
+      stickyOffsets = _ref.stickyOffsets,
+      flattenColumns = _ref.flattenColumns,
+      RowComponent = _ref.rowComponent,
+      CellComponent = _ref.cellComponent,
+      onHeaderRow = _ref.onHeaderRow,
+      index = _ref.index;
+
+  var _React$useContext = React.useContext(TableContext),
+      prefixCls = _React$useContext.prefixCls,
+      direction = _React$useContext.direction;
+
+  var rowProps;
+
+  if (onHeaderRow) {
+    rowProps = onHeaderRow(cells.map(function (cell) {
+      return cell.column;
+    }), index);
+  }
+
+  var columnsKey = getColumnsKey(cells.map(function (cell) {
+    return cell.column;
+  }));
+  return React.createElement(RowComponent, Object.assign({}, rowProps), cells.map(function (cell, cellIndex) {
+    var column = cell.column;
+    var fixedInfo = getCellFixedInfo(cell.colStart, cell.colEnd, flattenColumns, stickyOffsets, direction);
+    var additionalProps;
+
+    if (column && column.onHeaderCell) {
+      additionalProps = cell.column.onHeaderCell(column);
+    }
+
+    return React.createElement(Cell, Object.assign({}, cell, {
+      ellipsis: column.ellipsis,
+      align: column.align,
+      component: CellComponent,
+      prefixCls: prefixCls,
+      key: columnsKey[cellIndex]
+    }, fixedInfo, {
+      additionalProps: additionalProps
+    }));
+  }));
+}
+
+HeaderRow.displayName = 'HeaderRow';
+export default HeaderRow;

web/node_modules/rc-table/es/Panel/index.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+export interface TitleProps {
+    className: string;
+    children: React.ReactNode;
+}
+declare function Panel({ className, children }: TitleProps): JSX.Element;
+export default Panel;

web/node_modules/rc-table/es/Panel/index.js

@@ -0,0 +1,11 @@
+import * as React from 'react';
+
+function Panel(_ref) {
+  var className = _ref.className,
+      children = _ref.children;
+  return React.createElement("div", {
+    className: className
+  }, children);
+}
+
+export default Panel;

web/node_modules/rc-table/es/Table.d.ts

@@ -0,0 +1,87 @@
+/**
+ * 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 * as React from 'react';
+import { GetRowKey, ColumnsType, TableComponents, DefaultRecordType, GetComponentProps, ExpandableConfig, LegacyExpandableProps, PanelRender, TableLayout, RowClassName, ColumnType } from './interface';
+export declare const INTERNAL_HOOKS = "rc-table-internal-hook";
+export interface TableProps<RecordType = unknown> extends LegacyExpandableProps<RecordType> {
+    prefixCls?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    children?: React.ReactNode;
+    data?: RecordType[];
+    columns?: ColumnsType<RecordType>;
+    rowKey?: string | GetRowKey<RecordType>;
+    tableLayout?: TableLayout;
+    scroll?: {
+        x?: number | true | string;
+        y?: number | string;
+    };
+    /** Config expand rows */
+    expandable?: ExpandableConfig<RecordType>;
+    indentSize?: number;
+    rowClassName?: string | RowClassName<RecordType>;
+    title?: PanelRender<RecordType>;
+    footer?: PanelRender<RecordType>;
+    summary?: (data: RecordType[]) => React.ReactNode;
+    id?: string;
+    showHeader?: boolean;
+    components?: TableComponents<RecordType>;
+    onRow?: GetComponentProps<RecordType>;
+    onHeaderRow?: GetComponentProps<ColumnType<RecordType>[]>;
+    emptyText?: React.ReactNode | (() => React.ReactNode);
+    direction?: 'ltr' | 'rtl';
+    /**
+     * @private Internal usage, may remove by refactor. Should always use `columns` instead.
+     *
+     * !!! DO NOT USE IN PRODUCTION ENVIRONMENT !!!
+     */
+    internalHooks?: string;
+    /**
+     * @private Internal usage, may remove by refactor. Should always use `columns` instead.
+     *
+     * !!! DO NOT USE IN PRODUCTION ENVIRONMENT !!!
+     */
+    transformColumns?: (columns: ColumnsType<RecordType>) => ColumnsType<RecordType>;
+    /**
+     * @private Internal usage, may remove by refactor.
+     *
+     * !!! DO NOT USE IN PRODUCTION ENVIRONMENT !!!
+     */
+    internalRefs?: {
+        body: React.MutableRefObject<HTMLDivElement>;
+    };
+}
+declare function Table<RecordType extends DefaultRecordType>(props: TableProps<RecordType>): JSX.Element;
+declare namespace Table {
+    var Column: typeof import("./sugar/Column").default;
+    var ColumnGroup: typeof import("./sugar/ColumnGroup").default;
+    var defaultProps: {
+        rowKey: string;
+        prefixCls: string;
+        emptyText: () => string;
+    };
+}
+export default Table;

web/node_modules/rc-table/es/Table.js

@@ -0,0 +1,598 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+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(n); 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(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+/**
+ * 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 * as React from 'react';
+import classNames from 'classnames';
+import shallowEqual from 'shallowequal';
+import warning from "rc-util/es/warning";
+import ResizeObserver from 'rc-resize-observer';
+import getScrollBarSize from "rc-util/es/getScrollBarSize";
+import ColumnGroup from './sugar/ColumnGroup';
+import Column from './sugar/Column';
+import FixedHeader from './Header/FixedHeader';
+import Header from './Header/Header';
+import TableContext from './context/TableContext';
+import BodyContext from './context/BodyContext';
+import Body from './Body';
+import useColumns from './hooks/useColumns';
+import { useFrameState, useTimeoutLock } from './hooks/useFrame';
+import { getPathValue, mergeObject, validateValue, getColumnsKey } from './utils/valueUtil';
+import ResizeContext from './context/ResizeContext';
+import useStickyOffsets from './hooks/useStickyOffsets';
+import ColGroup from './ColGroup';
+import { getExpandableProps, getDataAndAriaProps } from './utils/legacyUtil';
+import Panel from './Panel';
+import Footer from './Footer';
+import { findAllChildrenKeys, renderExpandIcon } from './utils/expandUtil'; // Used for conditions cache
+
+var EMPTY_DATA = []; // Used for customize scroll
+
+var EMPTY_SCROLL_TARGET = {};
+export var INTERNAL_HOOKS = 'rc-table-internal-hook';
+var MemoTableContent = React.memo(function (_ref) {
+  var children = _ref.children;
+  return children;
+}, function (prev, next) {
+  if (!shallowEqual(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;
+  var mergedData = data || EMPTY_DATA;
+  var hasData = !!mergedData.length; // ===================== Effects ======================
+
+  var _React$useState = React.useState(0),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      scrollbarSize = _React$useState2[0],
+      setScrollbarSize = _React$useState2[1];
+
+  React.useEffect(function () {
+    setScrollbarSize(getScrollBarSize());
+  }); // ===================== 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 mergedComponents = React.useMemo(function () {
+    return mergeObject(components, {});
+  }, [components]);
+  var getComponent = React.useCallback(function (path, defaultComponent) {
+    return getPathValue(mergedComponents, path) || defaultComponent;
+  }, [mergedComponents]);
+  var getRowKey = React.useMemo(function () {
+    if (typeof rowKey === 'function') {
+      return rowKey;
+    }
+
+    return function (record) {
+      var key = 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]); // ====================== Expand ======================
+
+  var expandableConfig = 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 || 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 mergedChildrenColumnName in record;
+    })) {
+      return 'nest';
+    }
+    /* eslint-enable */
+
+
+    return false;
+  }, [!!expandedRowRender, mergedData]);
+
+  var _React$useState3 = React.useState(function () {
+    if (defaultExpandedRowKeys) {
+      return defaultExpandedRowKeys;
+    }
+
+    if (defaultExpandAllRows) {
+      return findAllChildrenKeys(mergedData, getRowKey, mergedChildrenColumnName);
+    }
+
+    return [];
+  }),
+      _React$useState4 = _slicedToArray(_React$useState3, 2),
+      innerExpandedKeys = _React$useState4[0],
+      setInnerExpandedKeys = _React$useState4[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 = _toConsumableArray(mergedExpandedKeys);
+    } else {
+      newExpandedKeys = [].concat(_toConsumableArray(mergedExpandedKeys), [key]);
+    }
+
+    setInnerExpandedKeys(newExpandedKeys);
+
+    if (onExpand) {
+      onExpand(!hasKey, record);
+    }
+
+    if (onExpandedRowsChange) {
+      onExpandedRowsChange(newExpandedKeys);
+    }
+  }, [getRowKey, mergedExpandedKeys, mergedData, onExpand, onExpandedRowsChange]); // ====================== Column ======================
+
+  var _React$useState5 = React.useState(0),
+      _React$useState6 = _slicedToArray(_React$useState5, 2),
+      componentWidth = _React$useState6[0],
+      setComponentWidth = _React$useState6[1];
+
+  var _useColumns = useColumns(_objectSpread({}, props, {}, expandableConfig, {
+    expandable: !!expandedRowRender,
+    expandedKeys: mergedExpandedKeys,
+    getRowKey: getRowKey,
+    onTriggerExpand: onTriggerExpand,
+    expandIcon: mergedExpandIcon,
+    expandIconColumnIndex: expandIconColumnIndex,
+    direction: direction
+  }), internalHooks === INTERNAL_HOOKS ? transformColumns : null),
+      _useColumns2 = _slicedToArray(_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 _React$useState7 = React.useState(false),
+      _React$useState8 = _slicedToArray(_React$useState7, 2),
+      pingedLeft = _React$useState8[0],
+      setPingedLeft = _React$useState8[1];
+
+  var _React$useState9 = React.useState(false),
+      _React$useState10 = _slicedToArray(_React$useState9, 2),
+      pingedRight = _React$useState10[0],
+      setPingedRight = _React$useState10[1];
+
+  var _useFrameState = useFrameState(new Map()),
+      _useFrameState2 = _slicedToArray(_useFrameState, 2),
+      colsWidths = _useFrameState2[0],
+      updateColsWidths = _useFrameState2[1]; // Convert map to number width
+
+
+  var colsKeys = getColumnsKey(flattenColumns);
+  var pureColWidths = colsKeys.map(function (columnKey) {
+    return colsWidths.get(columnKey);
+  });
+  var colWidths = React.useMemo(function () {
+    return pureColWidths;
+  }, [pureColWidths.join('_')]);
+  var stickyOffsets = useStickyOffsets(colWidths, flattenColumns.length, direction);
+  var fixHeader = hasData && scroll && validateValue(scroll.y);
+  var horizonScroll = scroll && validateValue(scroll.x);
+  var fixColumn = horizonScroll && flattenColumns.some(function (_ref2) {
+    var fixed = _ref2.fixed;
+    return fixed;
+  });
+  var scrollXStyle;
+  var scrollYStyle;
+  var scrollTableStyle;
+
+  if (fixHeader) {
+    scrollYStyle = {
+      overflowY: 'scroll',
+      maxHeight: scroll.y
+    };
+  }
+
+  if (horizonScroll) {
+    scrollXStyle = {
+      overflowX: 'scroll'
+    }; // 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: scroll.x === true ? 'auto' : scroll.x,
+      minWidth: '100%'
+    };
+  }
+
+  var onColumnResize = React.useCallback(function (columnKey, width) {
+    updateColsWidths(function (widths) {
+      var newWidths = new Map(widths);
+      newWidths.set(columnKey, width);
+      return newWidths;
+    });
+  }, []);
+
+  var _useTimeoutLock = useTimeoutLock(null),
+      _useTimeoutLock2 = _slicedToArray(_useTimeoutLock, 2),
+      setScrollTarget = _useTimeoutLock2[0],
+      getScrollTarget = _useTimeoutLock2[1];
+
+  function forceScroll(scrollLeft, target) {
+    /* eslint-disable no-param-reassign */
+    if (target && target.scrollLeft !== scrollLeft) {
+      target.scrollLeft = scrollLeft;
+    }
+    /* eslint-enable */
+
+  }
+
+  var onScroll = function onScroll(_ref3) {
+    var currentTarget = _ref3.currentTarget,
+        scrollLeft = _ref3.scrollLeft;
+    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);
+    }
+
+    if (currentTarget) {
+      var scrollWidth = currentTarget.scrollWidth,
+          clientWidth = currentTarget.clientWidth;
+      setPingedLeft(mergedScrollLeft > 0);
+      setPingedRight(mergedScrollLeft < scrollWidth - clientWidth);
+    }
+  };
+
+  var triggerOnScroll = function triggerOnScroll() {
+    if (scrollBodyRef.current) {
+      onScroll({
+        currentTarget: scrollBodyRef.current
+      });
+    }
+  };
+
+  var onFullTableResize = function onFullTableResize(_ref4) {
+    var width = _ref4.width;
+    triggerOnScroll();
+    setComponentWidth(fullTableRef.current ? fullTableRef.current.offsetWidth : width);
+  }; // Sync scroll bar when init or `horizonScroll` changed
+
+
+  React.useEffect(function () {
+    return triggerOnScroll;
+  }, []);
+  React.useEffect(function () {
+    if (horizonScroll) {
+      triggerOnScroll();
+    }
+  }, [horizonScroll]); // ================== 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 (fixHeader || fixColumn || flattenColumns.some(function (_ref5) {
+      var ellipsis = _ref5.ellipsis;
+      return ellipsis;
+    })) {
+      return 'fixed';
+    }
+
+    return 'auto';
+  }, [fixHeader, fixColumn, flattenColumns, tableLayout]);
+  var groupTableNode; // Header props
+
+  var headerProps = {
+    colWidths: colWidths,
+    columCount: flattenColumns.length,
+    stickyOffsets: stickyOffsets,
+    onHeaderRow: onHeaderRow
+  }; // Empty
+
+  var emptyNode = React.useMemo(function () {
+    if (hasData) {
+      return null;
+    }
+
+    if (typeof emptyText === 'function') {
+      return emptyText();
+    }
+
+    return emptyText;
+  }, [hasData, emptyText]); // Body
+
+  var bodyTable = React.createElement(Body, {
+    data: mergedData,
+    measureColumnWidth: fixHeader || horizonScroll,
+    stickyOffsets: stickyOffsets,
+    expandedKeys: mergedExpandedKeys,
+    rowExpandable: rowExpandable,
+    getRowKey: getRowKey,
+    onRow: onRow,
+    emptyNode: emptyNode,
+    childrenColumnName: mergedChildrenColumnName
+  });
+  var bodyColGroup = React.createElement(ColGroup, {
+    colWidths: flattenColumns.map(function (_ref6) {
+      var width = _ref6.width;
+      return width;
+    }),
+    columns: flattenColumns
+  });
+  var footerTable = summary && React.createElement(Footer, null, summary(mergedData));
+  var customizeScrollBody = getComponent(['body']);
+
+  if (process.env.NODE_ENV !== 'production' && typeof customizeScrollBody === 'function' && hasData && !fixHeader) {
+    warning(false, '`components.body` with render props is only work on `scroll.y`.');
+  }
+
+  if (fixHeader) {
+    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;
+        }
+
+        warning(false, 'When use `components.body` with render props. Each column should have a fixed value.');
+        return 0;
+      });
+    } else {
+      bodyContent = React.createElement("div", {
+        style: _objectSpread({}, scrollXStyle, {}, scrollYStyle),
+        onScroll: onScroll,
+        ref: scrollBodyRef,
+        className: classNames("".concat(prefixCls, "-body"))
+      }, React.createElement(TableComponent, {
+        style: _objectSpread({}, scrollTableStyle, {
+          tableLayout: mergedTableLayout
+        })
+      }, bodyColGroup, bodyTable, footerTable));
+    }
+
+    groupTableNode = React.createElement(React.Fragment, null, showHeader !== false && React.createElement("div", {
+      style: {
+        overflow: 'hidden'
+      },
+      onScroll: onScroll,
+      ref: scrollHeaderRef,
+      className: classNames("".concat(prefixCls, "-header"))
+    }, React.createElement(FixedHeader, Object.assign({}, headerProps, columnContext, {
+      direction: direction
+    }))), bodyContent);
+  } else {
+    groupTableNode = React.createElement("div", {
+      style: _objectSpread({}, scrollXStyle, {}, scrollYStyle),
+      className: classNames("".concat(prefixCls, "-content")),
+      onScroll: onScroll,
+      ref: scrollBodyRef
+    }, React.createElement(TableComponent, {
+      style: _objectSpread({}, scrollTableStyle, {
+        tableLayout: mergedTableLayout
+      })
+    }, bodyColGroup, showHeader !== false && React.createElement(Header, Object.assign({}, headerProps, columnContext)), bodyTable, footerTable));
+  }
+
+  var ariaProps = getDataAndAriaProps(props);
+  var fullTable = React.createElement("div", Object.assign({
+    className: classNames(prefixCls, className, (_classNames = {}, _defineProperty(_classNames, "".concat(prefixCls, "-rtl"), direction === 'rtl'), _defineProperty(_classNames, "".concat(prefixCls, "-ping-left"), pingedLeft), _defineProperty(_classNames, "".concat(prefixCls, "-ping-right"), pingedRight), _defineProperty(_classNames, "".concat(prefixCls, "-layout-fixed"), tableLayout === 'fixed'), _defineProperty(_classNames, "".concat(prefixCls, "-fixed-header"), fixHeader), _defineProperty(_classNames, "".concat(prefixCls, "-fixed-column"), fixColumn), _defineProperty(_classNames, "".concat(prefixCls, "-scroll-horizontal"), horizonScroll), _defineProperty(_classNames, "".concat(prefixCls, "-has-fix-left"), flattenColumns[0] && flattenColumns[0].fixed), _defineProperty(_classNames, "".concat(prefixCls, "-has-fix-right"), flattenColumns[flattenColumns.length - 1] && flattenColumns[flattenColumns.length - 1].fixed === 'right'), _classNames)),
+    style: style,
+    id: id,
+    ref: fullTableRef
+  }, ariaProps), React.createElement(MemoTableContent, {
+    pingLeft: pingedLeft,
+    pingRight: pingedRight,
+    props: _objectSpread({}, props, {
+      stickyOffsets: stickyOffsets,
+      mergedExpandedKeys: mergedExpandedKeys
+    })
+  }, title && React.createElement(Panel, {
+    className: "".concat(prefixCls, "-title")
+  }, title(mergedData)), React.createElement("div", {
+    className: "".concat(prefixCls, "-container")
+  }, groupTableNode), footer && React.createElement(Panel, {
+    className: "".concat(prefixCls, "-footer")
+  }, footer(mergedData))));
+
+  if (horizonScroll) {
+    fullTable = React.createElement(ResizeObserver, {
+      onResize: onFullTableResize
+    }, fullTable);
+  }
+
+  var TableContextValue = React.useMemo(function () {
+    return {
+      prefixCls: prefixCls,
+      getComponent: getComponent,
+      scrollbarSize: scrollbarSize,
+      direction: direction
+    };
+  }, [prefixCls, getComponent, scrollbarSize, direction]);
+  var BodyContextValue = React.useMemo(function () {
+    return _objectSpread({}, columnContext, {
+      tableLayout: mergedTableLayout,
+      rowClassName: rowClassName,
+      expandedRowClassName: expandedRowClassName,
+      componentWidth: componentWidth,
+      fixHeader: fixHeader,
+      fixColumn: fixColumn,
+      horizonScroll: horizonScroll,
+      expandIcon: mergedExpandIcon,
+      expandableType: expandableType,
+      expandRowByClick: expandRowByClick,
+      expandedRowRender: expandedRowRender,
+      onTriggerExpand: onTriggerExpand,
+      expandIconColumnIndex: expandIconColumnIndex,
+      indentSize: indentSize
+    });
+  }, [columnContext, mergedTableLayout, rowClassName, expandedRowClassName, componentWidth, fixHeader, fixColumn, horizonScroll, mergedExpandIcon, expandableType, expandRowByClick, expandedRowRender, onTriggerExpand, expandIconColumnIndex, indentSize]);
+  var ResizeContextValue = React.useMemo(function () {
+    return {
+      onColumnResize: onColumnResize
+    };
+  }, [onColumnResize]);
+  return React.createElement(TableContext.Provider, {
+    value: TableContextValue
+  }, React.createElement(BodyContext.Provider, {
+    value: BodyContextValue
+  }, React.createElement(ResizeContext.Provider, {
+    value: ResizeContextValue
+  }, fullTable)));
+}
+
+Table.Column = Column;
+Table.ColumnGroup = ColumnGroup;
+Table.defaultProps = {
+  rowKey: 'key',
+  prefixCls: 'rc-table',
+  emptyText: function emptyText() {
+    return 'No Data';
+  }
+};
+export default Table;

web/node_modules/rc-table/es/context/BodyContext.d.ts

@@ -0,0 +1,22 @@
+import * as React from 'react';
+import { ColumnType, DefaultRecordType, ColumnsType, TableLayout, RenderExpandIcon, ExpandableType, RowClassName, TriggerEventHandler, ExpandedRowRender } from '../interface';
+export interface BodyContextProps<RecordType = DefaultRecordType> {
+    rowClassName: string | RowClassName<RecordType>;
+    expandedRowClassName: RowClassName<RecordType>;
+    columns: ColumnsType<RecordType>;
+    flattenColumns: ColumnType<RecordType>[];
+    componentWidth: number;
+    tableLayout: TableLayout;
+    fixHeader: boolean;
+    fixColumn: boolean;
+    horizonScroll: boolean;
+    indentSize: number;
+    expandableType: ExpandableType;
+    expandRowByClick: boolean;
+    expandedRowRender: ExpandedRowRender<RecordType>;
+    expandIcon: RenderExpandIcon<RecordType>;
+    onTriggerExpand: TriggerEventHandler<RecordType>;
+    expandIconColumnIndex: number;
+}
+declare const BodyContext: React.Context<BodyContextProps<Record<string, any>>>;
+export default BodyContext;

web/node_modules/rc-table/es/context/BodyContext.js

@@ -0,0 +1,3 @@
+import * as React from 'react';
+var BodyContext = React.createContext(null);
+export default BodyContext;

web/node_modules/rc-table/es/context/ResizeContext.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+interface ResizeContextProps {
+    onColumnResize: (columnKey: React.Key, width: number) => void;
+}
+declare const ResizeContext: React.Context<ResizeContextProps>;
+export default ResizeContext;

web/node_modules/rc-table/es/context/ResizeContext.js

@@ -0,0 +1,3 @@
+import * as React from 'react';
+var ResizeContext = React.createContext(null);
+export default ResizeContext;

web/node_modules/rc-table/es/context/TableContext.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import { GetComponent } from '../interface';
+export interface TableContextProps {
+    prefixCls: string;
+    getComponent: GetComponent;
+    scrollbarSize: number;
+    direction: 'ltr' | 'rtl';
+}
+declare const TableContext: React.Context<TableContextProps>;
+export default TableContext;

web/node_modules/rc-table/es/context/TableContext.js

@@ -0,0 +1,3 @@
+import * as React from 'react';
+var TableContext = React.createContext(null);
+export default TableContext;

web/node_modules/rc-table/es/hooks/useColumns.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import { ColumnsType, ColumnType, Key, GetRowKey, TriggerEventHandler, RenderExpandIcon } from '../interface';
+export declare function convertChildrenToColumns<RecordType>(children: React.ReactNode): ColumnsType<RecordType>;
+/**
+ * Parse `columns` & `children` into `columns`.
+ */
+declare function useColumns<RecordType>({ prefixCls, columns, children, expandable, expandedKeys, getRowKey, onTriggerExpand, expandIcon, rowExpandable, expandIconColumnIndex, direction, }: {
+    prefixCls?: string;
+    columns?: ColumnsType<RecordType>;
+    children?: React.ReactNode;
+    expandable: boolean;
+    expandedKeys: Set<Key>;
+    getRowKey: GetRowKey<RecordType>;
+    onTriggerExpand: TriggerEventHandler<RecordType>;
+    expandIcon?: RenderExpandIcon<RecordType>;
+    rowExpandable?: (record: RecordType) => boolean;
+    expandIconColumnIndex?: number;
+    direction?: 'ltr' | 'rtl';
+}, transformColumns: (columns: ColumnsType<RecordType>) => ColumnsType<RecordType>): [ColumnsType<RecordType>, ColumnType<RecordType>[]];
+export default useColumns;

web/node_modules/rc-table/es/hooks/useColumns.js

@@ -0,0 +1,199 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread 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(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+import * as React from 'react';
+import warning from "rc-util/es/warning";
+import toArray from "rc-util/es/Children/toArray";
+import { INTERNAL_COL_DEFINE } from '../utils/legacyUtil';
+export function convertChildrenToColumns(children) {
+  return toArray(children).filter(function (node) {
+    return React.isValidElement(node);
+  }).map(function (_ref) {
+    var key = _ref.key,
+        props = _ref.props;
+
+    var nodeChildren = props.children,
+        restProps = _objectWithoutProperties(props, ["children"]);
+
+    var column = _objectSpread({
+      key: key
+    }, restProps);
+
+    if (nodeChildren) {
+      column.children = convertChildrenToColumns(nodeChildren);
+    }
+
+    return column;
+  });
+}
+
+function flatColumns(columns) {
+  return columns.reduce(function (list, column) {
+    var fixed = column.fixed; // Convert `fixed='true'` to `fixed='left'` instead
+
+    var parsedFixed = fixed === true ? 'left' : fixed;
+    var subColumns = column.children;
+
+    if (subColumns && subColumns.length > 0) {
+      return [].concat(_toConsumableArray(list), _toConsumableArray(flatColumns(subColumns).map(function (subColum) {
+        return _objectSpread({
+          fixed: parsedFixed
+        }, subColum);
+      })));
+    }
+
+    return [].concat(_toConsumableArray(list), [_objectSpread({}, column, {
+      fixed: parsedFixed
+    })]);
+  }, []);
+}
+
+function warningFixed(flattenColumns) {
+  var allFixLeft = true;
+
+  for (var i = 0; i < flattenColumns.length; i += 1) {
+    var col = flattenColumns[i];
+
+    if (allFixLeft && col.fixed !== 'left') {
+      allFixLeft = false;
+    } else if (!allFixLeft && col.fixed === 'left') {
+      warning(false, "Index ".concat(i - 1, " of `columns` missing `fixed='left'` prop."));
+      break;
+    }
+  }
+
+  var allFixRight = true;
+
+  for (var _i = flattenColumns.length - 1; _i >= 0; _i -= 1) {
+    var _col = flattenColumns[_i];
+
+    if (allFixRight && _col.fixed !== 'right') {
+      allFixRight = false;
+    } else if (!allFixRight && _col.fixed === 'right') {
+      warning(false, "Index ".concat(_i + 1, " of `columns` missing `fixed='right'` prop."));
+      break;
+    }
+  }
+}
+
+function revertForRtl(columns) {
+  return columns.map(function (column) {
+    var fixed = column.fixed,
+        restProps = _objectWithoutProperties(column, ["fixed"]); // Convert `fixed='left'` to `fixed='right'` instead
+
+
+    var parsedFixed = fixed;
+
+    if (fixed === 'left') {
+      parsedFixed = 'right';
+    } else if (fixed === 'right') {
+      parsedFixed = 'left';
+    }
+
+    return _objectSpread({
+      fixed: parsedFixed
+    }, restProps);
+  });
+}
+/**
+ * Parse `columns` & `children` into `columns`.
+ */
+
+
+function useColumns(_ref2, transformColumns) {
+  var prefixCls = _ref2.prefixCls,
+      columns = _ref2.columns,
+      children = _ref2.children,
+      expandable = _ref2.expandable,
+      expandedKeys = _ref2.expandedKeys,
+      getRowKey = _ref2.getRowKey,
+      onTriggerExpand = _ref2.onTriggerExpand,
+      expandIcon = _ref2.expandIcon,
+      rowExpandable = _ref2.rowExpandable,
+      expandIconColumnIndex = _ref2.expandIconColumnIndex,
+      direction = _ref2.direction;
+  var baseColumns = React.useMemo(function () {
+    return columns || convertChildrenToColumns(children);
+  }, [columns, children]); // Add expand column
+
+  var withExpandColumns = React.useMemo(function () {
+    if (expandable) {
+      var _expandColumn;
+
+      var expandColIndex = expandIconColumnIndex || 0;
+      var prevColumn = baseColumns[expandColIndex];
+      var expandColumn = (_expandColumn = {}, _defineProperty(_expandColumn, INTERNAL_COL_DEFINE, {
+        className: "".concat(prefixCls, "-expand-icon-col")
+      }), _defineProperty(_expandColumn, "title", ''), _defineProperty(_expandColumn, "fixed", prevColumn ? prevColumn.fixed : null), _defineProperty(_expandColumn, "className", "".concat(prefixCls, "-row-expand-icon-cell")), _defineProperty(_expandColumn, "render", function render(_, record, index) {
+        var rowKey = getRowKey(record, index);
+        var expanded = expandedKeys.has(rowKey);
+        var recordExpandable = rowExpandable ? rowExpandable(record) : true;
+        return expandIcon({
+          prefixCls: prefixCls,
+          expanded: expanded,
+          expandable: recordExpandable,
+          record: record,
+          onExpand: onTriggerExpand
+        });
+      }), _expandColumn); // Insert expand column in the target position
+
+      var cloneColumns = baseColumns.slice();
+      cloneColumns.splice(expandColIndex, 0, expandColumn);
+      return cloneColumns;
+    }
+
+    return baseColumns;
+  }, [expandable, baseColumns, getRowKey, expandedKeys, expandIcon, direction]);
+  var mergedColumns = React.useMemo(function () {
+    var finalColumns = withExpandColumns;
+
+    if (transformColumns) {
+      finalColumns = transformColumns(finalColumns);
+    } // Always provides at least one column for table display
+
+
+    if (!finalColumns.length) {
+      finalColumns = [{
+        render: function render() {
+          return null;
+        }
+      }];
+    }
+
+    return finalColumns;
+  }, [transformColumns, withExpandColumns, direction]);
+  var flattenColumns = React.useMemo(function () {
+    if (direction === 'rtl') {
+      return revertForRtl(flatColumns(mergedColumns));
+    }
+
+    return flatColumns(mergedColumns);
+  }, [mergedColumns, direction]); // Only check out of production since it's waste for each render
+
+  if (process.env.NODE_ENV !== 'production') {
+    warningFixed(flattenColumns);
+  }
+
+  return [mergedColumns, flattenColumns];
+}
+
+export default useColumns;

web/node_modules/rc-table/es/hooks/useFrame.d.ts

@@ -0,0 +1,4 @@
+export declare type Updater<State> = (prev: State) => State;
+export declare function useFrameState<State>(defaultState: State): [State, (updater: Updater<State>) => void];
+/** Lock frame, when frame pass reset the lock. */
+export declare function useTimeoutLock<State>(defaultState?: State): [(state: State) => void, () => State];

web/node_modules/rc-table/es/hooks/useFrame.js

@@ -0,0 +1,74 @@
+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(n); 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(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import { useRef, useState, useEffect } from 'react';
+import raf from 'raf';
+export function useFrameState(defaultState) {
+  var stateRef = useRef(defaultState);
+
+  var _useState = useState({}),
+      _useState2 = _slicedToArray(_useState, 2),
+      forceUpdate = _useState2[1];
+
+  var timeoutRef = useRef(null);
+  var updateBatchRef = useRef([]);
+
+  function setFrameState(updater) {
+    if (timeoutRef.current === null) {
+      updateBatchRef.current = [];
+      timeoutRef.current = raf(function () {
+        updateBatchRef.current.forEach(function (batchUpdater) {
+          stateRef.current = batchUpdater(stateRef.current);
+        });
+        timeoutRef.current = null;
+        forceUpdate({});
+      });
+    }
+
+    updateBatchRef.current.push(updater);
+  }
+
+  useEffect(function () {
+    return function () {
+      raf.cancel(timeoutRef.current);
+    };
+  }, []);
+  return [stateRef.current, setFrameState];
+}
+/** Lock frame, when frame pass reset the lock. */
+
+export function useTimeoutLock(defaultState) {
+  var frameRef = useRef(defaultState);
+  var timeoutRef = useRef(null);
+
+  function cleanUp() {
+    window.clearTimeout(timeoutRef.current);
+  }
+
+  function setState(newState) {
+    frameRef.current = newState;
+    cleanUp();
+    timeoutRef.current = window.setTimeout(function () {
+      frameRef.current = null;
+      timeoutRef.current = null;
+    }, 100);
+  }
+
+  function getState() {
+    return frameRef.current;
+  }
+
+  useEffect(function () {
+    return cleanUp;
+  }, []);
+  return [setState, getState];
+}

web/node_modules/rc-table/es/hooks/useStickyOffsets.d.ts

@@ -0,0 +1,6 @@
+import { StickyOffsets } from '../interface';
+/**
+ * Get sticky column offset width
+ */
+declare function useStickyOffsets(colWidths: number[], columCount: number, direction: 'ltr' | 'rtl'): StickyOffsets;
+export default useStickyOffsets;

web/node_modules/rc-table/es/hooks/useStickyOffsets.js

@@ -0,0 +1,42 @@
+import { useMemo } from 'react';
+/**
+ * Get sticky column offset width
+ */
+
+function useStickyOffsets(colWidths, columCount, direction) {
+  var stickyOffsets = useMemo(function () {
+    var leftOffsets = [];
+    var rightOffsets = [];
+    var left = 0;
+    var right = 0;
+
+    for (var start = 0; start < columCount; start += 1) {
+      if (direction === 'rtl') {
+        // Left offset
+        rightOffsets[start] = right;
+        right += colWidths[start] || 0; // Right offset
+
+        var end = columCount - start - 1;
+        leftOffsets[end] = left;
+        left += colWidths[end] || 0;
+      } else {
+        // Left offset
+        leftOffsets[start] = left;
+        left += colWidths[start] || 0; // Right offset
+
+        var _end = columCount - start - 1;
+
+        rightOffsets[_end] = right;
+        right += colWidths[_end] || 0;
+      }
+    }
+
+    return {
+      left: leftOffsets,
+      right: rightOffsets
+    };
+  }, [colWidths, columCount, direction]);
+  return stickyOffsets;
+}
+
+export default useStickyOffsets;

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

@@ -0,0 +1,6 @@
+import Table from './Table';
+import Column from './sugar/Column';
+import ColumnGroup from './sugar/ColumnGroup';
+import { INTERNAL_COL_DEFINE } from './utils/legacyUtil';
+export { Column, ColumnGroup, INTERNAL_COL_DEFINE };
+export default Table;

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

@@ -0,0 +1,6 @@
+import Table from './Table';
+import Column from './sugar/Column';
+import ColumnGroup from './sugar/ColumnGroup';
+import { INTERNAL_COL_DEFINE } from './utils/legacyUtil';
+export { Column, ColumnGroup, INTERNAL_COL_DEFINE };
+export default Table;

web/node_modules/rc-table/es/interface.d.ts

@@ -0,0 +1,138 @@
+import * as React from 'react';
+/**
+ * ColumnType which applied in antd: https://ant.design/components/table-cn/#Column
+ * - defaultSortOrder
+ * - filterDropdown
+ * - filterDropdownVisible
+ * - filtered
+ * - filteredValue
+ * - filterIcon
+ * - filterMultiple
+ * - filters
+ * - sorter
+ * - sortOrder
+ * - sortDirections
+ * - onFilter
+ * - onFilterDropdownVisibleChange
+ */
+export declare type Key = React.Key;
+export declare type FixedType = 'left' | 'right' | boolean;
+export declare type DefaultRecordType = Record<string, any>;
+export declare type TableLayout = 'auto' | 'fixed';
+export declare type RowClassName<RecordType> = (record: RecordType, index: number, indent: number) => string;
+export interface CellType<RecordType> {
+    key?: Key;
+    className?: string;
+    style?: React.CSSProperties;
+    children?: React.ReactNode;
+    column?: ColumnsType<RecordType>[number];
+    colSpan?: number;
+    rowSpan?: number;
+    /** Only used for table header */
+    hasSubColumns?: boolean;
+    colStart?: number;
+    colEnd?: number;
+}
+export interface RenderedCell<RecordType> {
+    props?: CellType<RecordType>;
+    children?: React.ReactNode;
+}
+export declare type DataIndex = string | number | (string | number)[];
+interface ColumnSharedType<RecordType> {
+    title?: React.ReactNode;
+    key?: Key;
+    className?: string;
+    fixed?: FixedType;
+    onHeaderCell?: GetComponentProps<ColumnsType<RecordType>[number]>;
+    ellipsis?: boolean;
+    align?: AlignType;
+}
+export interface ColumnGroupType<RecordType> extends ColumnSharedType<RecordType> {
+    children: ColumnsType<RecordType>;
+}
+export declare type AlignType = 'left' | 'center' | 'right';
+export interface ColumnType<RecordType> extends ColumnSharedType<RecordType> {
+    colSpan?: number;
+    dataIndex?: DataIndex;
+    render?: (value: any, record: RecordType, index: number) => React.ReactNode | RenderedCell<RecordType>;
+    rowSpan?: number;
+    width?: number | string;
+    onCell?: GetComponentProps<RecordType>;
+    /** @deprecated Please use `onCell` instead */
+    onCellClick?: (record: RecordType, e: React.MouseEvent<HTMLElement>) => void;
+}
+export declare type ColumnsType<RecordType = unknown> = (ColumnGroupType<RecordType> | ColumnType<RecordType>)[];
+export declare type GetRowKey<RecordType> = (record: RecordType, index?: number) => Key;
+export interface StickyOffsets {
+    left: number[];
+    right: number[];
+}
+export declare type GetComponentProps<DataType> = (data: DataType, index?: number) => React.HTMLAttributes<HTMLElement>;
+declare type Component<P> = React.ComponentType<P> | React.ForwardRefExoticComponent<P> | React.FC<P> | keyof React.ReactHTML;
+export declare type CustomizeComponent = Component<any>;
+export declare type CustomizeScrollBody<RecordType> = (data: RecordType[], info: {
+    scrollbarSize: number;
+    ref: React.Ref<{
+        scrollLeft: number;
+    }>;
+    onScroll: (info: {
+        currentTarget?: HTMLElement;
+        scrollLeft?: number;
+    }) => void;
+}) => React.ReactNode;
+export interface TableComponents<RecordType> {
+    table?: CustomizeComponent;
+    header?: {
+        wrapper?: CustomizeComponent;
+        row?: CustomizeComponent;
+        cell?: CustomizeComponent;
+    };
+    body?: CustomizeScrollBody<RecordType> | {
+        wrapper?: CustomizeComponent;
+        row?: CustomizeComponent;
+        cell?: CustomizeComponent;
+    };
+}
+export declare type GetComponent = (path: string[], defaultComponent?: CustomizeComponent) => CustomizeComponent;
+export declare type ExpandableType = false | 'row' | 'nest';
+export interface LegacyExpandableProps<RecordType> {
+    /** @deprecated Use `expandable.expandedRowKeys` instead */
+    expandedRowKeys?: Key[];
+    /** @deprecated Use `expandable.defaultExpandedRowKeys` instead */
+    defaultExpandedRowKeys?: Key[];
+    /** @deprecated Use `expandable.expandedRowRender` instead */
+    expandedRowRender?: ExpandedRowRender<RecordType>;
+    /** @deprecated Use `expandable.expandRowByClick` instead */
+    expandRowByClick?: boolean;
+    /** @deprecated Use `expandable.expandIcon` instead */
+    expandIcon?: RenderExpandIcon<RecordType>;
+    /** @deprecated Use `expandable.onExpand` instead */
+    onExpand?: (expanded: boolean, record: RecordType) => void;
+    /** @deprecated Use `expandable.onExpandedRowsChange` instead */
+    onExpandedRowsChange?: (expandedKeys: Key[]) => void;
+    /** @deprecated Use `expandable.defaultExpandAllRows` instead */
+    defaultExpandAllRows?: boolean;
+    /** @deprecated Use `expandable.indentSize` instead */
+    indentSize?: number;
+    /** @deprecated Use `expandable.expandIconColumnIndex` instead */
+    expandIconColumnIndex?: number;
+    /** @deprecated Use `expandable.expandedRowClassName` instead */
+    expandedRowClassName?: RowClassName<RecordType>;
+    /** @deprecated Use `expandable.childrenColumnName` instead */
+    childrenColumnName?: string;
+}
+export declare type ExpandedRowRender<ValueType> = (record: ValueType, index: number, indent: number, expanded: boolean) => React.ReactNode;
+export interface RenderExpandIconProps<RecordType> {
+    prefixCls: string;
+    expanded: boolean;
+    record: RecordType;
+    expandable: boolean;
+    onExpand: TriggerEventHandler<RecordType>;
+}
+export declare type RenderExpandIcon<RecordType> = (props: RenderExpandIconProps<RecordType>) => React.ReactNode;
+export interface ExpandableConfig<RecordType> extends LegacyExpandableProps<RecordType> {
+    rowExpandable?: (record: RecordType) => boolean;
+}
+export declare type PanelRender<RecordType> = (data: RecordType[]) => React.ReactNode;
+export declare type TriggerEventHandler<RecordType> = (record: RecordType, event: React.MouseEvent<HTMLElement>) => void;
+export {};

web/node_modules/rc-table/es/sugar/Column.d.ts

@@ -0,0 +1,10 @@
+import { ColumnType } from '../interface';
+export interface ColumnProps<RecordType> extends ColumnType<RecordType> {
+    children?: null;
+}
+/**
+ * This is a syntactic sugar for `columns` prop.
+ * So HOC will not work on this.
+ */
+declare function Column<RecordType>(_: ColumnProps<RecordType>): any;
+export default Column;

web/node_modules/rc-table/es/sugar/Column.js

@@ -0,0 +1,12 @@
+/* istanbul ignore next */
+
+/**
+ * This is a syntactic sugar for `columns` prop.
+ * So HOC will not work on this.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function Column(_) {
+  return null;
+}
+
+export default Column;

web/node_modules/rc-table/es/sugar/ColumnGroup.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { ColumnProps } from './Column';
+import { ColumnType } from '../interface';
+export interface ColumnGroupProps<RecordType> extends Omit<ColumnType<RecordType>, 'children'> {
+    children: React.ReactElement<ColumnProps<RecordType>> | React.ReactElement<ColumnProps<RecordType>>[];
+}
+/**
+ * This is a syntactic sugar for `columns` prop.
+ * So HOC will not work on this.
+ */
+declare function ColumnGroup<RecordType>(_: ColumnGroupProps<RecordType>): any;
+export default ColumnGroup;

web/node_modules/rc-table/es/sugar/ColumnGroup.js

@@ -0,0 +1,12 @@
+/* istanbul ignore next */
+
+/**
+ * This is a syntactic sugar for `columns` prop.
+ * So HOC will not work on this.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function ColumnGroup(_) {
+  return null;
+}
+
+export default ColumnGroup;

web/node_modules/rc-table/es/utils/expandUtil.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { RenderExpandIconProps, Key, GetRowKey } from '../interface';
+export declare function renderExpandIcon<RecordType>({ prefixCls, record, onExpand, expanded, expandable, }: RenderExpandIconProps<RecordType>): JSX.Element;
+export declare function findAllChildrenKeys<RecordType>(data: RecordType[], getRowKey: GetRowKey<RecordType>, childrenColumnName: string): Key[];

web/node_modules/rc-table/es/utils/expandUtil.js

@@ -0,0 +1,43 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import * as React from 'react';
+import classNames from 'classnames';
+export function renderExpandIcon(_ref) {
+  var _classNames;
+
+  var prefixCls = _ref.prefixCls,
+      record = _ref.record,
+      onExpand = _ref.onExpand,
+      expanded = _ref.expanded,
+      expandable = _ref.expandable;
+  var expandClassName = "".concat(prefixCls, "-row-expand-icon");
+
+  if (!expandable) {
+    return React.createElement("span", {
+      className: classNames(expandClassName, "".concat(prefixCls, "-row-spaced"))
+    });
+  }
+
+  var onClick = function onClick(event) {
+    onExpand(record, event);
+    event.stopPropagation();
+  };
+
+  return React.createElement("span", {
+    className: classNames(expandClassName, (_classNames = {}, _defineProperty(_classNames, "".concat(prefixCls, "-row-expanded"), expanded), _defineProperty(_classNames, "".concat(prefixCls, "-row-collapsed"), !expanded), _classNames)),
+    onClick: onClick
+  });
+}
+export function findAllChildrenKeys(data, getRowKey, childrenColumnName) {
+  var keys = [];
+
+  function dig(list) {
+    (list || []).forEach(function (item, index) {
+      keys.push(getRowKey(item, index));
+      dig(item[childrenColumnName]);
+    });
+  }
+
+  dig(data);
+  return keys;
+}

web/node_modules/rc-table/es/utils/fixUtil.d.ts

@@ -0,0 +1,12 @@
+import { StickyOffsets, FixedType } from '../interface';
+export interface FixedInfo {
+    fixLeft: number | false;
+    fixRight: number | false;
+    lastFixLeft: boolean;
+    firstFixRight: boolean;
+    lastFixRight: boolean;
+    firstFixLeft: boolean;
+}
+export declare function getCellFixedInfo(colStart: number, colEnd: number, columns: {
+    fixed?: FixedType;
+}[], stickyOffsets: StickyOffsets, direction: 'ltr' | 'rtl'): FixedInfo;

web/node_modules/rc-table/es/utils/fixUtil.js

@@ -0,0 +1,44 @@
+export function getCellFixedInfo(colStart, colEnd, columns, stickyOffsets, direction) {
+  var startColumn = columns[colStart] || {};
+  var endColumn = columns[colEnd] || {};
+  var fixLeft;
+  var fixRight;
+
+  if (startColumn.fixed === 'left') {
+    fixLeft = stickyOffsets.left[colStart];
+  } else if (endColumn.fixed === 'right') {
+    fixRight = stickyOffsets.right[colEnd];
+  }
+
+  var lastFixLeft = false;
+  var firstFixRight = false;
+  var lastFixRight = false;
+  var firstFixLeft = false;
+  var nextColumn = columns[colEnd + 1];
+  var prevColumn = columns[colStart - 1];
+
+  if (direction === 'rtl') {
+    if (fixLeft !== undefined) {
+      var prevFixLeft = prevColumn && prevColumn.fixed === 'left';
+      firstFixLeft = !prevFixLeft;
+    } else if (fixRight !== undefined) {
+      var nextFixRight = nextColumn && nextColumn.fixed === 'right';
+      lastFixRight = !nextFixRight;
+    }
+  } else if (fixLeft !== undefined) {
+    var nextFixLeft = nextColumn && nextColumn.fixed === 'left';
+    lastFixLeft = !nextFixLeft;
+  } else if (fixRight !== undefined) {
+    var prevFixRight = prevColumn && prevColumn.fixed === 'right';
+    firstFixRight = !prevFixRight;
+  }
+
+  return {
+    fixLeft: fixLeft,
+    fixRight: fixRight,
+    lastFixLeft: lastFixLeft,
+    firstFixRight: firstFixRight,
+    lastFixRight: lastFixRight,
+    firstFixLeft: firstFixLeft
+  };
+}

web/node_modules/rc-table/es/utils/legacyUtil.d.ts

@@ -0,0 +1,10 @@
+import { ExpandableConfig, LegacyExpandableProps } from '../interface';
+export declare const INTERNAL_COL_DEFINE = "RC_TABLE_INTERNAL_COL_DEFINE";
+export declare function getExpandableProps<RecordType>(props: LegacyExpandableProps<RecordType> & {
+    expandable?: ExpandableConfig<RecordType>;
+}): ExpandableConfig<RecordType>;
+/**
+ * Returns only data- and aria- key/value pairs
+ * @param {object} props
+ */
+export declare function getDataAndAriaProps(props: object): {};

web/node_modules/rc-table/es/utils/legacyUtil.js

@@ -0,0 +1,44 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+import warning from "rc-util/es/warning";
+export var INTERNAL_COL_DEFINE = 'RC_TABLE_INTERNAL_COL_DEFINE';
+export function getExpandableProps(props) {
+  var expandable = props.expandable,
+      legacyExpandableConfig = _objectWithoutProperties(props, ["expandable"]);
+
+  if ('expandable' in props) {
+    return _objectSpread({}, legacyExpandableConfig, {}, expandable);
+  }
+
+  if (process.env.NODE_ENV !== 'production' && ['indentSize', 'expandedRowKeys', 'defaultExpandedRowKeys', 'defaultExpandAllRows', 'expandedRowRender', 'expandRowByClick', 'expandIcon', 'onExpand', 'onExpandedRowsChange', 'expandedRowClassName', 'expandIconColumnIndex'].some(function (prop) {
+    return prop in props;
+  })) {
+    warning(false, 'expanded related props have been moved into `expandable`.');
+  }
+
+  return legacyExpandableConfig;
+}
+/**
+ * Returns only data- and aria- key/value pairs
+ * @param {object} props
+ */
+
+export function getDataAndAriaProps(props) {
+  /* eslint-disable no-param-reassign */
+  return Object.keys(props).reduce(function (memo, key) {
+    if (key.substr(0, 5) === 'data-' || key.substr(0, 5) === 'aria-') {
+      memo[key] = props[key];
+    }
+
+    return memo;
+  }, {});
+  /* eslint-enable */
+}

web/node_modules/rc-table/es/utils/valueUtil.d.ts

@@ -0,0 +1,10 @@
+import { Key, DataIndex } from '../interface';
+export declare function getPathValue<ValueType, ObjectType extends object>(record: ObjectType, path: DataIndex): ValueType;
+interface GetColumnKeyColumn {
+    key?: Key;
+    dataIndex?: DataIndex;
+}
+export declare function getColumnsKey(columns: GetColumnKeyColumn[]): (string | number)[];
+export declare function mergeObject<ReturnObject extends object>(...objects: Partial<ReturnObject>[]): ReturnObject;
+export declare function validateValue<T>(val: T): boolean;
+export {};

web/node_modules/rc-table/es/utils/valueUtil.js

@@ -0,0 +1,84 @@
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+var INTERNAL_KEY_PREFIX = 'RC_TABLE_KEY';
+
+function toArray(arr) {
+  if (arr === undefined || arr === null) {
+    return [];
+  }
+
+  return Array.isArray(arr) ? arr : [arr];
+}
+
+export function getPathValue(record, path) {
+  // Skip if path is empty
+  if (!path && typeof path !== 'number') {
+    return record;
+  }
+
+  var pathList = toArray(path);
+  var current = record;
+
+  for (var i = 0; i < pathList.length; i += 1) {
+    if (!current) {
+      return null;
+    }
+
+    var prop = pathList[i];
+    current = current[prop];
+  }
+
+  return current;
+}
+export function getColumnsKey(columns) {
+  var columnKeys = [];
+  var keys = {};
+  columns.forEach(function (column) {
+    var _ref = column || {},
+        key = _ref.key,
+        dataIndex = _ref.dataIndex;
+
+    var mergedKey = key || toArray(dataIndex).join('-') || INTERNAL_KEY_PREFIX;
+
+    while (keys[mergedKey]) {
+      mergedKey = "".concat(mergedKey, "_next");
+    }
+
+    keys[mergedKey] = true;
+    columnKeys.push(mergedKey);
+  });
+  return columnKeys;
+}
+export function mergeObject() {
+  var merged = {};
+  /* eslint-disable no-param-reassign */
+
+  function fillProps(obj, clone) {
+    if (clone) {
+      Object.keys(clone).forEach(function (key) {
+        var value = clone[key];
+
+        if (value && _typeof(value) === 'object') {
+          obj[key] = obj[key] || {};
+          fillProps(obj[key], value);
+        } else {
+          obj[key] = value;
+        }
+      });
+    }
+  }
+  /* eslint-enable */
+
+
+  for (var _len = arguments.length, objects = new Array(_len), _key = 0; _key < _len; _key++) {
+    objects[_key] = arguments[_key];
+  }
+
+  objects.forEach(function (clone) {
+    fillProps(merged, clone);
+  });
+  return merged;
+}
+export function validateValue(val) {
+  return val !== null && val !== undefined;
+}