Latest updates from IceHrmPro

web/node_modules/rc-table/HISTORY.md

@@ -0,0 +1,171 @@
+# History
+----
+
+## 6.9.0 / 2019-10-18
+
+- Rewrite in typescript
+- Fix `scroll={{ x: 'max-content' }}` not working.
+
+## 6.8.0 / 2019-09-03
+
+- Add `tableLayout`, could be set to `fixed`: https://developer.mozilla.org/en-US/docs/Web/CSS/table-layout
+- Add `column.ellipsis` to ellipsize cell content.
+
+## 6.7.0 / 2019-07-22
+
+- Show icon if using `expandIcon` even if `expandRowByClick` is set
+
+## 6.6.0 / 2019-06-04
+
+- Fixed Table header extra vertial scrollbar style.
+
+## 6.5.0 / 2019-04-20
+
+- Add internal interface for col definition.
+
+## 6.4.0 / 2018-10-15
+
+- Render data- and aria- props [#227](https://github.com/react-component/table/pull/227)
+- onCell add row index [#222](https://github.com/react-component/table/pull/222)
+- Add expandIcon [#236](https://github.com/react-component/table/pull/236)
+
+## 6.3.1 / 2018-08-02
+
+- Revert [112346](https://github.com/react-component/table/commit/112346ca75e8057771cf70fc8fde4bf5f63ce2e8) since too many edge cases.
+
+## 6.3.0 / 2018-08-02
+
+- Fixed header will read cell width from body.
+
+## 6.2.0 / 2018-05-09
+
+- Add `expanded` as the fourth parameter to `expandedRowRender`.
+
+## 6.0.0 / 2017-11-14
+
+- Refactor.
+- Allow override default examples.
+- Add Table[onRow] and column[onCell].
+- Add column[align].
+
+## 5.6.0 / 2017-08-27
+
+- Better empty data style for fixed-columns Table.
+
+## 5.5.0 / 2017-08-17
+
+- Add `onRowContextMenu`
+
+## 5.4.0 / 2017-05-23
+
+- Add `onRowMouseEnter`, `onRowMouseLeave`.
+
+## 5.3.0 / 2017-04-06
+
+- `emptyText` support React.Node
+
+## 5.0.0 / 2016-09-07
+
+- Remove props `columnsPageSize` and `columnsPageRange`, use fixed columns instead.
+- Add prop `onRowDoubleClick`.
+- Improve perfermance when expand row.
+
+## 4.6.0 / 2016-08-29
+
+Add prop `emptyText`.
+
+## 4.5.3 / 2016-08-24
+
+[#76](https://github.com/react-component/table/pull/76)
+
+## 4.5.2 / 2016-08-23
+
+Add `indent` as third argument to `rowClassName` `rowRef` `expandRowClassName`。
+
+## 4.5.1 / 2016-08-19
+
+Add original event param for `onRowClick`
+
+## 4.5.0 / 2016-08-17
+
+Add `expandRowByClicky` prop, allow expanding the row by clicking it.
+
+## 4.4.7 / 2016-08-16
+
+Fix https://github.com/ant-design/ant-design/issues/2729
+
+## 4.4.6 / 2016-08-05
+
+Fix https://github.com/ant-design/ant-design/issues/2625
+
+## 4.4.2 / 2016-08-01
+
+- Improve row and cell render perfermance.
+
+## 4.4.1 / 2016-07-24
+
+-  Fix row expand of key 0 record. (ant-design/ant-design#2471)
+
+## 4.4.0 / 2016-07-19
+
+- Add `title` prop [demo](http://react-component.github.io/table/examples/title-and-footer.html)
+- Add `getBodyWrapper` prop [demo](http://react-component.github.io/table/examples/animation.html)
+- Use `maxHeight` for fixed-header Table [#65](https://github.com/react-component/table/issues/65)
+
+## 4.3.0 / 2016-06-20
+
+- support `rowKey="uid"`
+
+## 4.2.0 / 2016-06-16
+
+- Header can be scroll in fixed-columns Table
+
+## 4.1.0 / 2016-06-01
+
+- Support nested string of `dataIndex`
+- Fix fixed Table with expand row
+
+## 4.0.0 / 2016-04-18
+
+- Support fixed columns
+- Add `scroll` prop
+- Add `defaultExpandAllRows` prop
+- Add `onExpand` prop
+- Add `rowRef` prop
+
+## 3.11.0 / 2016-02-25
+
+- Add prop `showHeader`
+- support render footer via `footer={() => <div>xxx</div>}`
+
+## 3.10.0 / 2016-02-22
+
+- Add prop expandIconColumnIndex
+
+## 3.9.0 / 2016-01-19
+
+- support pinned and paging columns.
+
+## 3.8.0
+
+- Add `onRowClick`
+
+## 3.7.0
+
+- Add `childenIndent`
+
+## 3.6.0 / 2015-11-11
+
+- add defaultExpandedRowKeys/expandedRowKeys/onExpandedRowsChange prop
+
+## 3.5.0 / 2015-11-03
+
+- Add colSpan and rowSpan support
+
+## 3.3.0 / 2015-10-27
+
+- support react 0.14
+
+## 3.2.0 / 2015-09-09
+
+- add expandIconAsCell prop

web/node_modules/rc-table/LICENSE.md

@@ -0,0 +1,22 @@
+MIT LICENSE
+
+Copyright (c) 2015-present Alipay.com, https://www.alipay.com/
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

web/node_modules/rc-table/README.md

@@ -0,0 +1,128 @@
+# rc-table
+
+React table component with useful functions.
+
+[![NPM version][npm-image]][npm-url] [![build status][travis-image]][travis-url] [![Test coverage][codecov-image]][codecov-url] [![npm download][download-image]][download-url]
+
+[npm-image]: http://img.shields.io/npm/v/rc-table.svg?style=flat-square
+[npm-url]: http://npmjs.org/package/rc-table
+[travis-image]: https://img.shields.io/travis/react-component/table.svg?style=flat-square
+[travis-url]: https://travis-ci.org/react-component/table
+[codecov-image]: https://img.shields.io/codecov/c/github/react-component/table/master.svg?style=flat-square
+[codecov-url]: https://codecov.io/gh/react-component/table/branch/master
+[download-image]: https://img.shields.io/npm/dm/rc-table.svg?style=flat-square
+[download-url]: https://npmjs.org/package/rc-table
+
+## install
+
+[![rc-table](https://nodei.co/npm/rc-table.png)](https://npmjs.org/package/rc-table)
+
+## Development
+
+```
+npm install
+npm start
+```
+
+## Example
+
+http://react-component.github.io/table/examples/
+
+## Usage
+
+```js
+import Table from 'rc-table';
+
+const columns = [
+  {
+    title: 'Name',
+    dataIndex: 'name',
+    key: 'name',
+    width: 100,
+  },
+  {
+    title: 'Age',
+    dataIndex: 'age',
+    key: 'age',
+    width: 100,
+  },
+  {
+    title: 'Address',
+    dataIndex: 'address',
+    key: 'address',
+    width: 200,
+  },
+  {
+    title: 'Operations',
+    dataIndex: '',
+    key: 'operations',
+    render: () => <a href="#">Delete</a>,
+  },
+];
+
+const data = [
+  { name: 'Jack', age: 28, address: 'some where', key: '1' },
+  { name: 'Rose', age: 36, address: 'some where', key: '2' },
+];
+
+React.render(<Table columns={columns} data={data} />, mountNode);
+```
+
+## API
+
+### Properties
+
+| Name | Type | Default | Description |
+| --- | --- | --- | --- |
+| tableLayout | `auto` \| `fixed` | `auto` \| `fixed` for any columns is fixed or ellipsis or header is fixed | https://developer.mozilla.org/en-US/docs/Web/CSS/table-layout |
+| prefixCls | String | rc-table |  |
+| className | String |  | additional className |
+| id | String |  | identifier of the container div |
+| useFixedHeader | Boolean | false | whether use separator table for header. better set width for columns |
+| scroll | Object | {x: false, y: false} | whether table can be scroll in x/y direction, `x` or `y` can be a number that indicated the width and height of table body |
+| expandable | Object |  | Config expand props |
+| expandable.defaultExpandAllRows | Boolean | false | Expand All Rows initially |
+| expandable.defaultExpandedRowKeys | String[] | [] | initial expanded rows keys |
+| expandable.expandedRowKeys | String[] |  | current expanded rows keys |
+| expandable.expandedRowRender | Function(recode, index, indent, expanded):ReactNode |  | Content render to expanded row |
+| expandable.expandedRowClassName | Function(recode, index, indent):string |  | get expanded row's className |
+| expandable.expandRowByClick | boolean |  | Support expand by click row |
+| expandable.expandIconColumnIndex | Number | 0 | The index of expandIcon which column will be inserted when expandIconAsCell is false |
+| expandable.expandIcon | props => ReactNode |  | Customize expand icon |
+| expandable.indentSize | Number | 15 | indentSize for every level of data.i.children, better using with column.width specified |
+| expandable.rowExpandable | (record) => boolean |  | Config row support expandable |
+| expandable.onExpand | Function(expanded, record) |  | function to call when click expand icon |
+| expandable.onExpandedRowsChange | Function(expandedRows) |  | function to call when the expanded rows change |
+| rowKey | string or Function(record):string | 'key' | If rowKey is string, `record[rowKey]` will be used as key. If rowKey is function, the return value of `rowKey(record)` will be use as key. |
+| rowClassName | string or Function(record, index, indent):string |  | get row's className |
+| rowRef | Function(record, index, indent):string |  | get row's ref key |
+| data | Object[] |  | data record array to be rendered |
+| onRow | Function(record, index) |  | Set custom props per each row. |
+| onHeaderRow | Function(record, index) |  | Set custom props per each header row. |
+| showHeader | Boolean | true | whether table head is shown |
+| title | Function(currentData) |  | table title render function |
+| footer | Function(currentData) |  | table footer render function |
+| emptyText | React.Node or Function | `No Data` | Display text when data is empty |
+| columns | Object[] |  | The columns config of table, see table below |
+| components | Object |  | Override table elements, see [#171](https://github.com/react-component/table/pull/171) for more details |
+
+## Column Props
+
+| Name | Type | Default | Description |
+| --- | --- | --- | --- |
+| key | String |  | key of this column |
+| className | String |  | className of this column |
+| colSpan | Number |  | thead colSpan of this column |
+| title | React Node |  | title of this column |
+| dataIndex | String |  | display field of the data record |
+| width | String \| Number |  | width of the specific proportion calculation according to the width of the columns |
+| fixed | String \| Boolean |  | this column will be fixed when table scroll horizontally: true or 'left' or 'right' |
+| align | String |  | specify how cell content is aligned |
+| ellipsis | Boolean |  | specify whether cell content be ellipsized |
+| onCell | Function(record, index) |  | Set custom props per each cell. |
+| onHeaderCell | Function(record) |  | Set custom props per each header cell. |
+| render | Function(value, row, index) |  | The render function of cell, has three params: the text of this cell, the record of this row, the index of this row, it's return an object:{ children: value, props: { colSpan: 1, rowSpan:1 } } ==> 'children' is the text of this cell, props is some setting of this cell, eg: 'colspan' set td colspan, 'rowspan' set td rowspan |
+
+## License
+
+rc-table is released under the MIT license.

web/node_modules/rc-table/assets/bordered.css

@@ -0,0 +1,55 @@
+.move-enter,
+.move-appear {
+  opacity: 0;
+  animation-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1);
+  animation-duration: 2.5s;
+  animation-fill-mode: both;
+  animation-play-state: paused;
+}
+.move-leave {
+  animation-timing-function: cubic-bezier(0.55, 0.055, 0.675, 0.19);
+  animation-duration: 0.5s;
+  animation-fill-mode: both;
+  animation-play-state: paused;
+}
+.move-enter.move-enter-active,
+.move-appear.move-enter-active {
+  animation-name: moveLeftIn;
+  animation-play-state: running;
+}
+.move-leave.move-leave-active {
+  animation-name: moveRightOut;
+  animation-play-state: running;
+}
+@keyframes moveLeftIn {
+  0% {
+    transform-origin: 0 0;
+    transform: translateX(30px);
+    opacity: 0;
+    background: #fff6de;
+  }
+  20% {
+    transform-origin: 0 0;
+    transform: translateX(0);
+    opacity: 1;
+  }
+  80% {
+    background: #fff6de;
+  }
+  100% {
+    background: transparent;
+    opacity: 1;
+  }
+}
+@keyframes moveRightOut {
+  0% {
+    transform-origin: 0 0;
+    transform: translateX(0);
+    opacity: 1;
+  }
+  100% {
+    transform-origin: 0 0;
+    transform: translateX(-30px);
+    opacity: 0;
+  }
+}

web/node_modules/rc-table/assets/index.css

@@ -0,0 +1,210 @@
+.rc-table {
+  font-size: 12px;
+  color: #666;
+  line-height: 1.5;
+  box-sizing: border-box;
+  position: relative;
+}
+.rc-table-rtl {
+  direction: rtl;
+}
+.rc-table table {
+  border-spacing: 0px;
+  width: 100%;
+}
+.rc-table th,
+.rc-table td {
+  padding: 0;
+  position: relative;
+  border: 1px solid red;
+  border-top: 0;
+  border-left: 0;
+  transition: box-shadow 0.3s;
+  padding: 16px 8px;
+  box-sizing: border-box;
+  white-space: normal;
+  word-break: break-word;
+}
+.rc-table-rtl.rc-table th,
+.rc-table-rtl.rc-table td {
+  border-left: 1px solid red;
+  border-right: 0;
+}
+.rc-table-cell-fix-left,
+.rc-table-cell-fix-right {
+  z-index: 1;
+}
+.rc-table-cell-fix-right:last-child {
+  border-right-color: transparent;
+}
+.rc-table-rtl .rc-table-cell-fix-right:last-child {
+  border-right-color: red;
+}
+.rc-table-rtl .rc-table-cell-fix-left:last-child {
+  border-left-color: transparent;
+}
+.rc-table-rtl .rc-table-cell-fix-left-first {
+  box-shadow: 1px 0 0 red;
+}
+.rc-table-cell-fix-left-first::after,
+.rc-table-cell-fix-left-last::after {
+  pointer-events: none;
+  content: '';
+  transition: box-shadow 0.3s;
+  position: absolute;
+  top: 0;
+  bottom: -1px;
+  width: 20px;
+  right: -1px;
+  transform: translateX(100%);
+}
+.rc-table-cell-fix-right-first,
+.rc-table-cell-fix-right-last {
+  box-shadow: -1px 0 0 red;
+}
+.rc-table-rtl .rc-table-cell-fix-right-first,
+.rc-table-rtl .rc-table-cell-fix-right-last {
+  box-shadow: none;
+}
+.rc-table-cell-fix-right-first::after,
+.rc-table-cell-fix-right-last::after {
+  pointer-events: none;
+  content: '';
+  transition: box-shadow 0.3s;
+  position: absolute;
+  top: 0;
+  bottom: -1px;
+  width: 20px;
+  left: -1px;
+  transform: translateX(-100%);
+}
+.rc-table-cell.rc-table-cell-ellipsis {
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.rc-table-cell.rc-table-cell-ellipsis.rc-table-cell-fix-left-first,
+.rc-table-cell.rc-table-cell-ellipsis.rc-table-cell-fix-left-last,
+.rc-table-cell.rc-table-cell-ellipsis.rc-table-cell-fix-right-first .rc-table-cell.rc-table-cell-ellipsis.rc-table-cell-fix-right-last {
+  overflow: visible;
+}
+.rc-table-cell.rc-table-cell-ellipsis.rc-table-cell-fix-left-first .rc-table-cell-content,
+.rc-table-cell.rc-table-cell-ellipsis.rc-table-cell-fix-left-last .rc-table-cell-content,
+.rc-table-cell.rc-table-cell-ellipsis.rc-table-cell-fix-right-first .rc-table-cell.rc-table-cell-ellipsis.rc-table-cell-fix-right-last .rc-table-cell-content {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  display: block;
+}
+.rc-table-ping-left .rc-table-cell-fix-left-first::after,
+.rc-table-ping-left .rc-table-cell-fix-left-last::after {
+  box-shadow: inset 10px 0 8px -8px green;
+}
+.rc-table-ping-right .rc-table-cell-fix-right-first::after,
+.rc-table-ping-right .rc-table-cell-fix-right-last::after {
+  box-shadow: inset -10px 0 8px -8px green;
+}
+.rc-table-expand-icon-col {
+  width: 60px;
+}
+.rc-table-row-expand-icon-cell {
+  text-align: center;
+}
+.rc-table thead td,
+.rc-table thead th {
+  background: #f7f7f7;
+  text-align: center;
+}
+.rc-table thead .rc-table-cell-scrollbar::after {
+  position: absolute;
+  content: '';
+  top: 0;
+  bottom: 0;
+  left: -1px;
+  width: 1px;
+  background: #f7f7f7;
+}
+.rc-table-rtl.rc-table thead .rc-table-cell-scrollbar::after {
+  right: -1px;
+  left: auto;
+}
+.rc-table-header {
+  border: 1px solid red;
+  border-right: 0;
+  border-bottom: 0;
+}
+.rc-table-placeholder {
+  text-align: center;
+}
+.rc-table tbody tr td,
+.rc-table tbody tr th {
+  background: #fff;
+}
+.rc-table-content {
+  border: 1px solid red;
+  border-right: 0;
+  border-bottom: 0;
+  border-radius: 5px 0 0 0;
+}
+.rc-table-body {
+  border: 1px solid red;
+  border-right: 0;
+  border-bottom: 0;
+  border-top: 0;
+}
+.rc-table-fixed-column .rc-table-body::after {
+  content: '';
+  position: absolute;
+  right: 0;
+  top: 0;
+  bottom: 0;
+  border-right: 1px solid red;
+  z-index: 1;
+}
+.rc-table-expanded-row .rc-table-cell {
+  box-shadow: inset 0 8px 8px -8px green;
+}
+.rc-table-expanded-row-fixed {
+  box-sizing: border-box;
+  margin: -16px -8px;
+  padding: 16px 8px;
+  margin-right: -10px;
+}
+.rc-table-expanded-row-fixed::after {
+  content: '';
+  position: absolute;
+  width: 0;
+  top: 0;
+  bottom: 0;
+  right: 1px;
+  border-right: 1px solid red;
+}
+.rc-table-row-expand-icon {
+  display: inline-block;
+  width: 16px;
+  height: 16px;
+  border: 1px solid currentColor;
+  color: #aaa;
+  vertical-align: middle;
+  text-align: center;
+  cursor: pointer;
+  line-height: 16px;
+}
+.rc-table-row-expand-icon.rc-table-row-expanded::after {
+  content: '-';
+}
+.rc-table-row-expand-icon.rc-table-row-collapsed::after {
+  content: '+';
+}
+.rc-table-row-expand-icon.rc-table-row-spaced {
+  visibility: hidden;
+}
+.rc-table-title {
+  border: 1px solid red;
+  border-bottom: 0;
+  padding: 16px 8px;
+}
+.rc-table-footer {
+  border: 1px solid red;
+  border-top: 0;
+  padding: 16px 8px;
+}

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;
+}

web/node_modules/rc-table/lib/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/lib/Body/BodyRow.js

@@ -0,0 +1,232 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _Cell = _interopRequireDefault(require("../Cell"));
+
+var _TableContext = _interopRequireDefault(require("../context/TableContext"));
+
+var _BodyContext = _interopRequireDefault(require("../context/BodyContext"));
+
+var _valueUtil = require("../utils/valueUtil");
+
+var _fixUtil = require("../utils/fixUtil");
+
+var _ExpandedRow = _interopRequireDefault(require("./ExpandedRow"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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; }
+
+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.default),
+      prefixCls = _React$useContext.prefixCls,
+      direction = _React$useContext.direction;
+
+  var _React$useContext2 = React.useContext(_BodyContext.default),
+      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 (0, _fixUtil.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 = (0, _valueUtil.getColumnsKey)(flattenColumns);
+  var baseRowNode = React.createElement(RowComponent, Object.assign({}, additionalProps, {
+    "data-row-key": rowKey,
+    className: (0, _classnames.default)(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.default, 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.default, {
+      expanded: expanded,
+      className: (0, _classnames.default)("".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';
+var _default = BodyRow;
+exports.default = _default;

web/node_modules/rc-table/lib/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/lib/Body/ExpandedRow.js

@@ -0,0 +1,68 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _Cell = _interopRequireDefault(require("../Cell"));
+
+var _TableContext = _interopRequireDefault(require("../context/TableContext"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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.default),
+      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.default, {
+      component: cellComponent,
+      prefixCls: prefixCls,
+      colSpan: colSpan
+    }, contentNode));
+  }, [children, Component, fixHeader, horizonScroll, className, expanded, componentWidth, colSpan, scrollbarSize]);
+}
+
+var _default = ExpandedRow;
+exports.default = _default;

web/node_modules/rc-table/lib/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/lib/Body/index.js

@@ -0,0 +1,126 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _rcResizeObserver = _interopRequireDefault(require("rc-resize-observer"));
+
+var _BodyRow = _interopRequireDefault(require("./BodyRow"));
+
+var _TableContext = _interopRequireDefault(require("../context/TableContext"));
+
+var _ExpandedRow = _interopRequireDefault(require("./ExpandedRow"));
+
+var _BodyContext = _interopRequireDefault(require("../context/BodyContext"));
+
+var _valueUtil = require("../utils/valueUtil");
+
+var _ResizeContext = _interopRequireDefault(require("../context/ResizeContext"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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.default),
+      onColumnResize = _React$useContext.onColumnResize;
+
+  var _React$useContext2 = React.useContext(_TableContext.default),
+      prefixCls = _React$useContext2.prefixCls,
+      getComponent = _React$useContext2.getComponent;
+
+  var _React$useContext3 = React.useContext(_BodyContext.default),
+      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.default, {
+          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.default, {
+        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 = (0, _valueUtil.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(_rcResizeObserver.default, {
+        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';
+var _default = MemoBody;
+exports.default = _default;

web/node_modules/rc-table/lib/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/lib/Cell/index.js

@@ -0,0 +1,170 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _ref3 = require("rc-util/lib/ref");
+
+var _valueUtil = require("../utils/valueUtil");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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); }
+
+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 (0, _ref3.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 = (0, _valueUtil.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: (0, _classnames.default)(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';
+var _default = RefCell;
+exports.default = _default;

web/node_modules/rc-table/lib/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/lib/ColGroup.js

@@ -0,0 +1,49 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _legacyUtil = require("./utils/legacyUtil");
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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[_legacyUtil.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);
+}
+
+var _default = ColGroup;
+exports.default = _default;

web/node_modules/rc-table/lib/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/lib/Footer/index.js

@@ -0,0 +1,22 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function Footer(_ref) {
+  var children = _ref.children;
+  return React.createElement("tfoot", null, children);
+}
+
+var _default = Footer;
+exports.default = _default;

web/node_modules/rc-table/lib/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/lib/Header/FixedHeader.js

@@ -0,0 +1,113 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _Header = _interopRequireDefault(require("./Header"));
+
+var _ColGroup = _interopRequireDefault(require("../ColGroup"));
+
+var _TableContext = _interopRequireDefault(require("../context/TableContext"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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; }
+
+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.default),
+      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.default, {
+    colWidths: [].concat(_toConsumableArray(colWidths), [scrollbarSize]),
+    columCount: columCount + 1
+  }), React.createElement(_Header.default, Object.assign({}, props, {
+    stickyOffsets: headerStickyOffsets,
+    columns: columnsWithScrollbar,
+    flattenColumns: flattenColumnsWithScrollbar
+  })));
+}
+
+var _default = FixedHeader;
+exports.default = _default;

web/node_modules/rc-table/lib/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/lib/Header/Header.js

@@ -0,0 +1,120 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _HeaderRow = _interopRequireDefault(require("./HeaderRow"));
+
+var _TableContext = _interopRequireDefault(require("../context/TableContext"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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.default),
+      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.default, {
+      key: rowIndex,
+      flattenColumns: flattenColumns,
+      cells: row,
+      stickyOffsets: stickyOffsets,
+      rowComponent: trComponent,
+      cellComponent: thComponent,
+      onHeaderRow: onHeaderRow,
+      index: rowIndex
+    });
+    return rowNode;
+  }));
+}
+
+var _default = Header;
+exports.default = _default;

web/node_modules/rc-table/lib/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/lib/Header/HeaderRow.js

@@ -0,0 +1,73 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _Cell = _interopRequireDefault(require("../Cell"));
+
+var _TableContext = _interopRequireDefault(require("../context/TableContext"));
+
+var _fixUtil = require("../utils/fixUtil");
+
+var _valueUtil = require("../utils/valueUtil");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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.default),
+      prefixCls = _React$useContext.prefixCls,
+      direction = _React$useContext.direction;
+
+  var rowProps;
+
+  if (onHeaderRow) {
+    rowProps = onHeaderRow(cells.map(function (cell) {
+      return cell.column;
+    }), index);
+  }
+
+  var columnsKey = (0, _valueUtil.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 = (0, _fixUtil.getCellFixedInfo)(cell.colStart, cell.colEnd, flattenColumns, stickyOffsets, direction);
+    var additionalProps;
+
+    if (column && column.onHeaderCell) {
+      additionalProps = cell.column.onHeaderCell(column);
+    }
+
+    return React.createElement(_Cell.default, Object.assign({}, cell, {
+      ellipsis: column.ellipsis,
+      align: column.align,
+      component: CellComponent,
+      prefixCls: prefixCls,
+      key: columnsKey[cellIndex]
+    }, fixedInfo, {
+      additionalProps: additionalProps
+    }));
+  }));
+}
+
+HeaderRow.displayName = 'HeaderRow';
+var _default = HeaderRow;
+exports.default = _default;

web/node_modules/rc-table/lib/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/lib/Panel/index.js

@@ -0,0 +1,25 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function Panel(_ref) {
+  var className = _ref.className,
+      children = _ref.children;
+  return React.createElement("div", {
+    className: className
+  }, children);
+}
+
+var _default = Panel;
+exports.default = _default;

web/node_modules/rc-table/lib/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/lib/Table.js

@@ -0,0 +1,613 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.INTERNAL_HOOKS = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _shallowequal = _interopRequireDefault(require("shallowequal"));
+
+var _warning = _interopRequireDefault(require("rc-util/lib/warning"));
+
+var _rcResizeObserver = _interopRequireDefault(require("rc-resize-observer"));
+
+var _getScrollBarSize = _interopRequireDefault(require("rc-util/lib/getScrollBarSize"));
+
+var _ColumnGroup = _interopRequireDefault(require("./sugar/ColumnGroup"));
+
+var _Column = _interopRequireDefault(require("./sugar/Column"));
+
+var _FixedHeader = _interopRequireDefault(require("./Header/FixedHeader"));
+
+var _Header = _interopRequireDefault(require("./Header/Header"));
+
+var _TableContext = _interopRequireDefault(require("./context/TableContext"));
+
+var _BodyContext = _interopRequireDefault(require("./context/BodyContext"));
+
+var _Body = _interopRequireDefault(require("./Body"));
+
+var _useColumns3 = _interopRequireDefault(require("./hooks/useColumns"));
+
+var _useFrame = require("./hooks/useFrame");
+
+var _valueUtil = require("./utils/valueUtil");
+
+var _ResizeContext = _interopRequireDefault(require("./context/ResizeContext"));
+
+var _useStickyOffsets = _interopRequireDefault(require("./hooks/useStickyOffsets"));
+
+var _ColGroup = _interopRequireDefault(require("./ColGroup"));
+
+var _legacyUtil = require("./utils/legacyUtil");
+
+var _Panel = _interopRequireDefault(require("./Panel"));
+
+var _Footer = _interopRequireDefault(require("./Footer"));
+
+var _expandUtil = require("./utils/expandUtil");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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; }
+
+// Used for conditions cache
+var EMPTY_DATA = []; // Used for customize scroll
+
+var EMPTY_SCROLL_TARGET = {};
+var INTERNAL_HOOKS = 'rc-table-internal-hook';
+exports.INTERNAL_HOOKS = INTERNAL_HOOKS;
+var MemoTableContent = React.memo(function (_ref) {
+  var children = _ref.children;
+  return children;
+}, function (prev, next) {
+  if (!(0, _shallowequal.default)(prev.props, next.props)) {
+    return false;
+  } // No additional render when pinged status change.
+  // This is not a bug.
+
+
+  return prev.pingLeft !== next.pingLeft || prev.pingRight !== next.pingRight;
+});
+
+function Table(props) {
+  var _classNames;
+
+  var prefixCls = props.prefixCls,
+      className = props.className,
+      rowClassName = props.rowClassName,
+      style = props.style,
+      data = props.data,
+      rowKey = props.rowKey,
+      scroll = props.scroll,
+      tableLayout = props.tableLayout,
+      direction = props.direction,
+      title = props.title,
+      footer = props.footer,
+      summary = props.summary,
+      id = props.id,
+      showHeader = props.showHeader,
+      components = props.components,
+      emptyText = props.emptyText,
+      onRow = props.onRow,
+      onHeaderRow = props.onHeaderRow,
+      internalHooks = props.internalHooks,
+      transformColumns = props.transformColumns,
+      internalRefs = props.internalRefs;
+  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((0, _getScrollBarSize.default)());
+  }); // ===================== Warning ======================
+
+  if (process.env.NODE_ENV !== 'production') {
+    ['onRowClick', 'onRowDoubleClick', 'onRowContextMenu', 'onRowMouseEnter', 'onRowMouseLeave'].forEach(function (name) {
+      (0, _warning.default)(props[name] === undefined, "`".concat(name, "` is removed, please use `onRow` instead."));
+    });
+    (0, _warning.default)(!('getBodyWrapper' in props), '`getBodyWrapper` is deprecated, please use custom `components` instead.');
+  } // ==================== Customize =====================
+
+
+  var mergedComponents = React.useMemo(function () {
+    return (0, _valueUtil.mergeObject)(components, {});
+  }, [components]);
+  var getComponent = React.useCallback(function (path, defaultComponent) {
+    return (0, _valueUtil.getPathValue)(mergedComponents, path) || defaultComponent;
+  }, [mergedComponents]);
+  var getRowKey = React.useMemo(function () {
+    if (typeof rowKey === 'function') {
+      return rowKey;
+    }
+
+    return function (record) {
+      var key = record[rowKey];
+
+      if (process.env.NODE_ENV !== 'production') {
+        (0, _warning.default)(key !== undefined, 'Each record in table should have a unique `key` prop, or set `rowKey` to an unique primary key.');
+      }
+
+      return key;
+    };
+  }, [rowKey]); // ====================== Expand ======================
+
+  var expandableConfig = (0, _legacyUtil.getExpandableProps)(props);
+  var expandIcon = expandableConfig.expandIcon,
+      expandedRowKeys = expandableConfig.expandedRowKeys,
+      defaultExpandedRowKeys = expandableConfig.defaultExpandedRowKeys,
+      defaultExpandAllRows = expandableConfig.defaultExpandAllRows,
+      expandedRowRender = expandableConfig.expandedRowRender,
+      onExpand = expandableConfig.onExpand,
+      onExpandedRowsChange = expandableConfig.onExpandedRowsChange,
+      expandRowByClick = expandableConfig.expandRowByClick,
+      rowExpandable = expandableConfig.rowExpandable,
+      expandIconColumnIndex = expandableConfig.expandIconColumnIndex,
+      expandedRowClassName = expandableConfig.expandedRowClassName,
+      childrenColumnName = expandableConfig.childrenColumnName,
+      indentSize = expandableConfig.indentSize;
+  var mergedExpandIcon = expandIcon || _expandUtil.renderExpandIcon;
+  var mergedChildrenColumnName = childrenColumnName || 'children';
+  var expandableType = React.useMemo(function () {
+    if (expandedRowRender) {
+      return 'row';
+    }
+    /* eslint-disable no-underscore-dangle */
+
+    /**
+     * Fix https://github.com/ant-design/ant-design/issues/21154
+     * This is a workaround to not to break current behavior.
+     * We can remove follow code after final release.
+     *
+     * To other developer:
+     *  Do not use `__PARENT_RENDER_ICON__` in prod since we will remove this when refactor
+     */
+
+
+    if (props.expandable && internalHooks === INTERNAL_HOOKS && props.expandable.__PARENT_RENDER_ICON__ || mergedData.some(function (record) {
+      return mergedChildrenColumnName in record;
+    })) {
+      return 'nest';
+    }
+    /* eslint-enable */
+
+
+    return false;
+  }, [!!expandedRowRender, mergedData]);
+
+  var _React$useState3 = React.useState(function () {
+    if (defaultExpandedRowKeys) {
+      return defaultExpandedRowKeys;
+    }
+
+    if (defaultExpandAllRows) {
+      return (0, _expandUtil.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 = (0, _useColumns3.default)(_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 = (0, _useFrame.useFrameState)(new Map()),
+      _useFrameState2 = _slicedToArray(_useFrameState, 2),
+      colsWidths = _useFrameState2[0],
+      updateColsWidths = _useFrameState2[1]; // Convert map to number width
+
+
+  var colsKeys = (0, _valueUtil.getColumnsKey)(flattenColumns);
+  var pureColWidths = colsKeys.map(function (columnKey) {
+    return colsWidths.get(columnKey);
+  });
+  var colWidths = React.useMemo(function () {
+    return pureColWidths;
+  }, [pureColWidths.join('_')]);
+  var stickyOffsets = (0, _useStickyOffsets.default)(colWidths, flattenColumns.length, direction);
+  var fixHeader = hasData && scroll && (0, _valueUtil.validateValue)(scroll.y);
+  var horizonScroll = scroll && (0, _valueUtil.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 = (0, _useFrame.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.default, {
+    data: mergedData,
+    measureColumnWidth: fixHeader || horizonScroll,
+    stickyOffsets: stickyOffsets,
+    expandedKeys: mergedExpandedKeys,
+    rowExpandable: rowExpandable,
+    getRowKey: getRowKey,
+    onRow: onRow,
+    emptyNode: emptyNode,
+    childrenColumnName: mergedChildrenColumnName
+  });
+  var bodyColGroup = React.createElement(_ColGroup.default, {
+    colWidths: flattenColumns.map(function (_ref6) {
+      var width = _ref6.width;
+      return width;
+    }),
+    columns: flattenColumns
+  });
+  var footerTable = summary && React.createElement(_Footer.default, null, summary(mergedData));
+  var customizeScrollBody = getComponent(['body']);
+
+  if (process.env.NODE_ENV !== 'production' && typeof customizeScrollBody === 'function' && hasData && !fixHeader) {
+    (0, _warning.default)(false, '`components.body` with render props is only work on `scroll.y`.');
+  }
+
+  if (fixHeader) {
+    var bodyContent;
+
+    if (typeof customizeScrollBody === 'function') {
+      bodyContent = customizeScrollBody(mergedData, {
+        scrollbarSize: scrollbarSize,
+        ref: scrollBodyRef,
+        onScroll: onScroll
+      });
+      headerProps.colWidths = flattenColumns.map(function (_ref7, index) {
+        var width = _ref7.width;
+        var colWidth = index === columns.length - 1 ? width - scrollbarSize : width;
+
+        if (typeof colWidth === 'number' && !Number.isNaN(colWidth)) {
+          return colWidth;
+        }
+
+        (0, _warning.default)(false, 'When use `components.body` with render props. Each column should have a fixed value.');
+        return 0;
+      });
+    } else {
+      bodyContent = React.createElement("div", {
+        style: _objectSpread({}, scrollXStyle, {}, scrollYStyle),
+        onScroll: onScroll,
+        ref: scrollBodyRef,
+        className: (0, _classnames.default)("".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: (0, _classnames.default)("".concat(prefixCls, "-header"))
+    }, React.createElement(_FixedHeader.default, Object.assign({}, headerProps, columnContext, {
+      direction: direction
+    }))), bodyContent);
+  } else {
+    groupTableNode = React.createElement("div", {
+      style: _objectSpread({}, scrollXStyle, {}, scrollYStyle),
+      className: (0, _classnames.default)("".concat(prefixCls, "-content")),
+      onScroll: onScroll,
+      ref: scrollBodyRef
+    }, React.createElement(TableComponent, {
+      style: _objectSpread({}, scrollTableStyle, {
+        tableLayout: mergedTableLayout
+      })
+    }, bodyColGroup, showHeader !== false && React.createElement(_Header.default, Object.assign({}, headerProps, columnContext)), bodyTable, footerTable));
+  }
+
+  var ariaProps = (0, _legacyUtil.getDataAndAriaProps)(props);
+  var fullTable = React.createElement("div", Object.assign({
+    className: (0, _classnames.default)(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.default, {
+    className: "".concat(prefixCls, "-title")
+  }, title(mergedData)), React.createElement("div", {
+    className: "".concat(prefixCls, "-container")
+  }, groupTableNode), footer && React.createElement(_Panel.default, {
+    className: "".concat(prefixCls, "-footer")
+  }, footer(mergedData))));
+
+  if (horizonScroll) {
+    fullTable = React.createElement(_rcResizeObserver.default, {
+      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.default.Provider, {
+    value: TableContextValue
+  }, React.createElement(_BodyContext.default.Provider, {
+    value: BodyContextValue
+  }, React.createElement(_ResizeContext.default.Provider, {
+    value: ResizeContextValue
+  }, fullTable)));
+}
+
+Table.Column = _Column.default;
+Table.ColumnGroup = _ColumnGroup.default;
+Table.defaultProps = {
+  rowKey: 'key',
+  prefixCls: 'rc-table',
+  emptyText: function emptyText() {
+    return 'No Data';
+  }
+};
+var _default = Table;
+exports.default = _default;

web/node_modules/rc-table/lib/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/lib/context/BodyContext.js

@@ -0,0 +1,18 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var BodyContext = React.createContext(null);
+var _default = BodyContext;
+exports.default = _default;

web/node_modules/rc-table/lib/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/lib/context/ResizeContext.js

@@ -0,0 +1,18 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var ResizeContext = React.createContext(null);
+var _default = ResizeContext;
+exports.default = _default;

web/node_modules/rc-table/lib/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/lib/context/TableContext.js

@@ -0,0 +1,18 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var TableContext = React.createContext(null);
+var _default = TableContext;
+exports.default = _default;

web/node_modules/rc-table/lib/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/lib/hooks/useColumns.js

@@ -0,0 +1,220 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertChildrenToColumns = convertChildrenToColumns;
+exports.default = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _warning = _interopRequireDefault(require("rc-util/lib/warning"));
+
+var _toArray = _interopRequireDefault(require("rc-util/lib/Children/toArray"));
+
+var _legacyUtil = require("../utils/legacyUtil");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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; }
+
+function convertChildrenToColumns(children) {
+  return (0, _toArray.default)(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') {
+      (0, _warning.default)(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') {
+      (0, _warning.default)(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, _legacyUtil.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];
+}
+
+var _default = useColumns;
+exports.default = _default;

web/node_modules/rc-table/lib/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/lib/hooks/useFrame.js

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useFrameState = useFrameState;
+exports.useTimeoutLock = useTimeoutLock;
+
+var _react = require("react");
+
+var _raf = _interopRequireDefault(require("raf"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: 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; }
+
+function useFrameState(defaultState) {
+  var stateRef = (0, _react.useRef)(defaultState);
+
+  var _useState = (0, _react.useState)({}),
+      _useState2 = _slicedToArray(_useState, 2),
+      forceUpdate = _useState2[1];
+
+  var timeoutRef = (0, _react.useRef)(null);
+  var updateBatchRef = (0, _react.useRef)([]);
+
+  function setFrameState(updater) {
+    if (timeoutRef.current === null) {
+      updateBatchRef.current = [];
+      timeoutRef.current = (0, _raf.default)(function () {
+        updateBatchRef.current.forEach(function (batchUpdater) {
+          stateRef.current = batchUpdater(stateRef.current);
+        });
+        timeoutRef.current = null;
+        forceUpdate({});
+      });
+    }
+
+    updateBatchRef.current.push(updater);
+  }
+
+  (0, _react.useEffect)(function () {
+    return function () {
+      _raf.default.cancel(timeoutRef.current);
+    };
+  }, []);
+  return [stateRef.current, setFrameState];
+}
+/** Lock frame, when frame pass reset the lock. */
+
+
+function useTimeoutLock(defaultState) {
+  var frameRef = (0, _react.useRef)(defaultState);
+  var timeoutRef = (0, _react.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;
+  }
+
+  (0, _react.useEffect)(function () {
+    return cleanUp;
+  }, []);
+  return [setState, getState];
+}

web/node_modules/rc-table/lib/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/lib/hooks/useStickyOffsets.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = require("react");
+
+/**
+ * Get sticky column offset width
+ */
+function useStickyOffsets(colWidths, columCount, direction) {
+  var stickyOffsets = (0, _react.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;
+}
+
+var _default = useStickyOffsets;
+exports.default = _default;

web/node_modules/rc-table/lib/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/lib/index.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Column", {
+  enumerable: true,
+  get: function get() {
+    return _Column.default;
+  }
+});
+Object.defineProperty(exports, "ColumnGroup", {
+  enumerable: true,
+  get: function get() {
+    return _ColumnGroup.default;
+  }
+});
+Object.defineProperty(exports, "INTERNAL_COL_DEFINE", {
+  enumerable: true,
+  get: function get() {
+    return _legacyUtil.INTERNAL_COL_DEFINE;
+  }
+});
+exports.default = void 0;
+
+var _Table = _interopRequireDefault(require("./Table"));
+
+var _Column = _interopRequireDefault(require("./sugar/Column"));
+
+var _ColumnGroup = _interopRequireDefault(require("./sugar/ColumnGroup"));
+
+var _legacyUtil = require("./utils/legacyUtil");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = _Table.default;
+exports.default = _default;

web/node_modules/rc-table/lib/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/lib/interface.js

@@ -0,0 +1 @@
+"use strict";

web/node_modules/rc-table/lib/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/lib/sugar/Column.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+/* 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;
+}
+
+var _default = Column;
+exports.default = _default;

web/node_modules/rc-table/lib/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/lib/sugar/ColumnGroup.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+/* 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;
+}
+
+var _default = ColumnGroup;
+exports.default = _default;

web/node_modules/rc-table/lib/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/lib/utils/expandUtil.js

@@ -0,0 +1,62 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.renderExpandIcon = renderExpandIcon;
+exports.findAllChildrenKeys = findAllChildrenKeys;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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 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: (0, _classnames.default)(expandClassName, "".concat(prefixCls, "-row-spaced"))
+    });
+  }
+
+  var onClick = function onClick(event) {
+    onExpand(record, event);
+    event.stopPropagation();
+  };
+
+  return React.createElement("span", {
+    className: (0, _classnames.default)(expandClassName, (_classNames = {}, _defineProperty(_classNames, "".concat(prefixCls, "-row-expanded"), expanded), _defineProperty(_classNames, "".concat(prefixCls, "-row-collapsed"), !expanded), _classNames)),
+    onClick: onClick
+  });
+}
+
+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/lib/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;