shineout 1.12.2 → 1.12.3

package/esm/Table/SimpleTable.d.ts

@@ -0,0 +1,36 @@
+import React from 'react';
+import { PureComponent } from '../component';
+import { ColumnItem, ColumnOrder, SimpleTableProps } from './Props';
+interface SimpleTableState {
+    colgroup?: number[];
+    overHeight: boolean;
+    overWidth: boolean;
+    resize: boolean;
+}
+declare class SimpleTable<DataItem, Value> extends PureComponent<SimpleTableProps<DataItem, Value>, SimpleTableState> {
+    bindHeader: (el: HTMLDivElement) => void;
+    bindBody: (el: HTMLDivElement) => void;
+    bindFooter: (el: HTMLDivElement) => void;
+    removeReiszeObserver: () => void;
+    body: HTMLDivElement;
+    header: HTMLDivElement;
+    footer: HTMLDivElement;
+    lastColGroup: number[];
+    constructor(props: SimpleTableProps<DataItem, Value>);
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: SimpleTableProps<DataItem, Value>): void;
+    componentWillUnmount(): void;
+    bindElement(key: 'header' | 'body' | 'footer', el: HTMLDivElement): void;
+    resetColGroup(): void;
+    scrollCheck(): void;
+    handleSortChange(finalOrder: ColumnOrder | undefined, sorter: ColumnItem<DataItem>['sorter'], index: number, cancelOrder: ColumnOrder, manual: boolean): void;
+    handleColgroup(tds: NodeListOf<HTMLTableCellElement>): void;
+    handleScroll({ currentTarget }: {
+        currentTarget: HTMLElement;
+    }): void;
+    renderHeader(): JSX.Element;
+    renderFooter(): JSX.Element | null;
+    renderBody(): JSX.Element;
+    render(): React.ReactNode[] | JSX.Element;
+}
+export default SimpleTable;

package/esm/Table/SimpleTable.js

@@ -0,0 +1,315 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+import _extends from "@babel/runtime/helpers/extends";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import React from 'react';
+import { PureComponent } from '../component';
+import { tableClass } from './styles';
+import { range, split } from '../utils/numbers';
+import Colgroup from './Colgroup';
+import Tbody from './Tbody';
+import Thead from './Thead';
+import Tfoot from './Tfoot';
+import { compareColumns } from '../utils/shallowEqual';
+import Sticky from '../Sticky';
+import { addResizeObserver } from '../utils/dom/element';
+
+function setScrollLeft(target, scrollLeft) {
+  if (target && target.scrollLeft !== scrollLeft) target.scrollLeft = scrollLeft;
+}
+
+var SimpleTable =
+/*#__PURE__*/
+function (_PureComponent) {
+  _inheritsLoose(SimpleTable, _PureComponent);
+
+  function SimpleTable(props) {
+    var _this;
+
+    _this = _PureComponent.call(this, props) || this;
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "bindHeader", void 0);
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "bindBody", void 0);
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "bindFooter", void 0);
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "removeReiszeObserver", void 0);
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "body", void 0);
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "header", void 0);
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "footer", void 0);
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "lastColGroup", void 0);
+
+    _this.state = {
+      colgroup: undefined,
+      overHeight: false,
+      overWidth: false,
+      resize: false
+    };
+    _this.handleSortChange = _this.handleSortChange.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.bindHeader = _this.bindElement.bind(_assertThisInitialized(_assertThisInitialized(_this)), 'header');
+    _this.bindBody = _this.bindElement.bind(_assertThisInitialized(_assertThisInitialized(_this)), 'body');
+    _this.bindFooter = _this.bindElement.bind(_assertThisInitialized(_assertThisInitialized(_this)), 'footer');
+    _this.handleScroll = _this.handleScroll.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleColgroup = _this.handleColgroup.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.resetColGroup = _this.resetColGroup.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    return _this;
+  }
+
+  var _proto = SimpleTable.prototype;
+
+  _proto.componentDidMount = function componentDidMount() {
+    this.scrollCheck();
+  };
+
+  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
+    this.scrollCheck();
+    var resize = prevProps.data.length === 0 && this.props.data.length; // when resize
+
+    if (resize && this.body) this.handleScroll({
+      currentTarget: this.body
+    });
+    var shouldResetColgroup = this.props.dataChangeResize && this.props.data !== prevProps.data;
+
+    if (resize || shouldResetColgroup || !compareColumns(prevProps.columns, this.props.columns)) {
+      // eslint-disable-next-line react/no-did-update-set-state
+      this.setState({
+        colgroup: undefined,
+        resize: true
+      });
+    }
+  };
+
+  _proto.componentWillUnmount = function componentWillUnmount() {
+    if (this.body) this.body.removeEventListener('wheel', this.handleScroll);
+    if (this.removeReiszeObserver) this.removeReiszeObserver();
+  };
+
+  _proto.bindElement = function bindElement(key, el) {
+    this[key] = el; // this.body will be undefined on componentDidMount when columns length is 0
+
+    if (key === 'body' && el) {
+      el.addEventListener('wheel', this.handleScroll, {
+        passive: false
+      });
+      this.removeReiszeObserver = addResizeObserver(el, this.resetColGroup, {
+        direction: 'x'
+      });
+    }
+  };
+
+  _proto.resetColGroup = function resetColGroup() {
+    this.lastColGroup = this.state.colgroup || this.lastColGroup;
+    this.setState({
+      colgroup: undefined,
+      resize: true
+    });
+  };
+
+  _proto.scrollCheck = function scrollCheck() {
+    if (!this.body) return;
+    var overHeight = this.body.scrollHeight > this.body.clientHeight;
+    var overWidth = this.body.scrollWidth > this.body.clientWidth;
+    if (overWidth !== this.state.overWidth) this.setState({
+      overWidth: overWidth
+    });
+    if (overHeight !== this.state.overHeight) this.setState({
+      overHeight: overHeight
+    });
+  };
+
+  _proto.handleSortChange = function handleSortChange(finalOrder, sorter, index, cancelOrder, // 是否是自动触发
+  manual) {
+    if (this.body) this.body.scrollTop = 0;
+    this.props.onSortChange(finalOrder, sorter, index, cancelOrder, manual);
+  };
+
+  _proto.handleColgroup = function handleColgroup(tds) {
+    var columns = this.props.columns;
+    var colgroup = [];
+
+    var _loop = function _loop(i, count) {
+      var _tds$i$getBoundingCli = tds[i].getBoundingClientRect(),
+          width = _tds$i$getBoundingCli.width;
+
+      var colSpan = parseInt(tds[i].getAttribute('colspan') || '', 10);
+
+      if (colSpan > 1) {
+        split(width, range(colSpan).map(function (j) {
+          return columns[i + j].width;
+        })).forEach(function (w) {
+          return colgroup.push(w);
+        });
+      } else {
+        colgroup.push(width);
+      }
+    };
+
+    for (var i = 0, count = tds.length; i < count; i++) {
+      _loop(i, count);
+    }
+
+    this.setState({
+      colgroup: colgroup,
+      resize: false
+    });
+  };
+
+  _proto.handleScroll = function handleScroll(_ref) {
+    var currentTarget = _ref.currentTarget;
+    var scrollLeft = currentTarget.scrollLeft;
+    setScrollLeft(this.header, scrollLeft);
+    setScrollLeft(this.body, scrollLeft);
+    setScrollLeft(this.footer, scrollLeft);
+  };
+
+  _proto.renderHeader = function renderHeader() {
+    var _this$props = this.props,
+        columns = _this$props.columns,
+        width = _this$props.width,
+        data = _this$props.data,
+        onResize = _this$props.onResize,
+        columnResizable = _this$props.columnResizable,
+        sticky = _this$props.sticky,
+        bordered = _this$props.bordered;
+    var _this$state = this.state,
+        colgroup = _this$state.colgroup,
+        overHeight = _this$state.overHeight;
+    var inner = React.createElement("table", {
+      style: {
+        width: width
+      },
+      className: tableClass(bordered && 'table-bordered')
+    }, React.createElement(Colgroup, {
+      colgroup: colgroup || this.lastColGroup,
+      columns: columns,
+      resizable: columnResizable
+    }), React.createElement(Thead, _extends({}, this.props, {
+      colgroup: colgroup,
+      onSortChange: this.handleSortChange,
+      onColChange: onResize
+    })));
+    var empty = data.length === 0;
+    var headerStyle = {};
+    if (!empty) headerStyle.overflowY = overHeight ? 'scroll' : 'hidden';
+    var header = React.createElement("div", {
+      key: "head",
+      style: headerStyle,
+      className: tableClass('head', 'simple-head', empty && 'empty-head'),
+      ref: this.bindHeader
+    }, inner);
+
+    if (sticky) {
+      var stickyProps = Object.assign({
+        top: 0
+      }, sticky);
+      return React.createElement(Sticky, _extends({}, stickyProps, {
+        key: "head"
+      }), header);
+    }
+
+    return header;
+  };
+
+  _proto.renderFooter = function renderFooter() {
+    var _this$props2 = this.props,
+        columns = _this$props2.columns,
+        width = _this$props2.width,
+        data = _this$props2.data,
+        columnResizable = _this$props2.columnResizable,
+        bordered = _this$props2.bordered,
+        summary = _this$props2.summary;
+    var _this$state2 = this.state,
+        colgroup = _this$state2.colgroup,
+        overHeight = _this$state2.overHeight,
+        overWidth = _this$state2.overWidth;
+    if (!(data && data.length)) return null;
+    if (!(summary && summary.length)) return null;
+    var inner = React.createElement("table", {
+      style: {
+        width: width
+      },
+      className: tableClass(bordered && 'table-bordered')
+    }, React.createElement(Colgroup, {
+      colgroup: colgroup || this.lastColGroup,
+      columns: columns,
+      resizable: columnResizable
+    }), React.createElement(Tfoot, this.props));
+    var footStyle = {};
+    footStyle.overflowY = overHeight ? 'scroll' : 'hidden';
+    var footer = React.createElement("div", {
+      key: "foot",
+      style: footStyle,
+      className: tableClass('foot', overWidth && 'foot-scroll-x', 'simple-foot'),
+      ref: this.bindFooter,
+      onScroll: this.handleScroll
+    }, inner);
+    return footer;
+  };
+
+  _proto.renderBody = function renderBody() {
+    var _this$props3 = this.props,
+        columns = _this$props3.columns,
+        width = _this$props3.width,
+        fixed = _this$props3.fixed,
+        columnResizable = _this$props3.columnResizable,
+        bordered = _this$props3.bordered,
+        others = _objectWithoutPropertiesLoose(_this$props3, ["columns", "width", "fixed", "columnResizable", "bordered"]);
+
+    var _this$state3 = this.state,
+        colgroup = _this$state3.colgroup,
+        resize = _this$state3.resize;
+    var minWidthSup = columns.find(function (d) {
+      return d.minWidth;
+    });
+    return React.createElement("div", {
+      key: "body",
+      className: tableClass('simple-body'),
+      ref: this.bindBody,
+      onScroll: this.handleScroll
+    }, React.createElement("table", {
+      style: {
+        width: width
+      },
+      className: tableClass(!colgroup && minWidthSup && 'init', bordered && 'table-bordered')
+    }, React.createElement(Colgroup, {
+      colgroup: colgroup,
+      columns: columns,
+      resizable: columnResizable
+    }), React.createElement(Tbody, _extends({
+      colgroup: colgroup,
+      lazy: false,
+      index: 0,
+      columns: columns,
+      onBodyRender: this.handleColgroup,
+      resize: resize,
+      bordered: bordered,
+      columnResizable: columnResizable
+    }, others))));
+  };
+
+  _proto.render = function render() {
+    var _this$props4 = this.props,
+        columns = _this$props4.columns,
+        width = _this$props4.width,
+        children = _this$props4.children,
+        hideHeader = _this$props4.hideHeader,
+        bordered = _this$props4.bordered;
+    if (!columns || columns.length === 0) return React.createElement("table", {
+      style: {
+        width: width
+      },
+      className: tableClass(bordered && 'table-bordered')
+    }, children);
+    return [hideHeader ? null : this.renderHeader(), this.renderBody(), this.renderFooter(), children];
+  };
+
+  return SimpleTable;
+}(PureComponent);
+
+export default SimpleTable;

package/esm/Table/Sorter.d.ts

@@ -0,0 +1,13 @@
+import { PureComponent } from 'react';
+import { ColumnOrder, SorterProps } from './Props';
+declare class Sorter<DataItem, Value> extends PureComponent<SorterProps<DataItem, Value>> {
+    constructor(props: SorterProps<DataItem, Value>);
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    defaultSorterOrder(): void;
+    handleChange(order: ColumnOrder, manual?: boolean): void;
+    handleAsc(): void;
+    handleDesc(): void;
+    render(): JSX.Element;
+}
+export default Sorter;

package/esm/Table/Sorter.js

@@ -0,0 +1,100 @@
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import React, { PureComponent } from 'react';
+import { tableClass } from './styles';
+
+var Sorter =
+/*#__PURE__*/
+function (_PureComponent) {
+  _inheritsLoose(Sorter, _PureComponent);
+
+  function Sorter(props) {
+    var _this;
+
+    _this = _PureComponent.call(this, props) || this;
+    _this.handleAsc = _this.handleAsc.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleDesc = _this.handleDesc.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    return _this;
+  }
+
+  var _proto = Sorter.prototype;
+
+  _proto.componentDidMount = function componentDidMount() {
+    this.defaultSorterOrder();
+  };
+
+  _proto.componentDidUpdate = function componentDidUpdate() {
+    this.defaultSorterOrder();
+  };
+
+  _proto.defaultSorterOrder = function defaultSorterOrder() {
+    var _this$props = this.props,
+        defaultOrder = _this$props.defaultOrder,
+        _this$props$current = _this$props.current,
+        current = _this$props$current === void 0 ? [] : _this$props$current,
+        index = _this$props.index;
+    if (current.length !== 1) return;
+    var item = current[0];
+    var changed = index === item.index && defaultOrder === item.order;
+    if (defaultOrder && !changed && !item.manual) this.handleChange(defaultOrder, false);
+  };
+
+  _proto.handleChange = function handleChange(order, manual) {
+    if (manual === void 0) {
+      manual = true;
+    }
+
+    var _this$props2 = this.props,
+        sorter = _this$props2.sorter,
+        index = _this$props2.index,
+        onChange = _this$props2.onChange,
+        _this$props2$current = _this$props2.current,
+        current = _this$props2$current === void 0 ? [] : _this$props2$current;
+    var item = current.find(function (v) {
+      return v.index === index;
+    });
+    var isCancel = !!item && order === item.order;
+    var finalOrder = isCancel ? undefined : order;
+    onChange(finalOrder, sorter, index, order, manual);
+  };
+
+  _proto.handleAsc = function handleAsc() {
+    this.handleChange('asc');
+  };
+
+  _proto.handleDesc = function handleDesc() {
+    this.handleChange('desc');
+  };
+
+  _proto.render = function render() {
+    var _this$props3 = this.props,
+        _this$props3$current = _this$props3.current,
+        current = _this$props3$current === void 0 ? [] : _this$props3$current,
+        index = _this$props3.index,
+        renderSorter = _this$props3.renderSorter;
+    var item = current.find(function (v) {
+      return v.index === index;
+    });
+    var active = !!item;
+    var isCustomRender = renderSorter && typeof renderSorter === 'function';
+    return React.createElement("div", {
+      className: tableClass('sorter-container')
+    }, isCustomRender ? renderSorter({
+      status: active ? item.order : undefined,
+      triggerAsc: this.handleAsc,
+      triggerDesc: this.handleDesc
+    }) : React.createElement(React.Fragment, null, React.createElement("a", {
+      key: "asc",
+      className: tableClass(active && item.order === 'asc' && 'sorter-active', 'sorter-asc'),
+      onClick: this.handleAsc
+    }, "\xA0"), React.createElement("a", {
+      key: "desc",
+      className: tableClass(active && item.order === 'desc' && 'sorter-active', 'sorter-desc'),
+      onClick: this.handleDesc
+    }, "\xA0")));
+  };
+
+  return Sorter;
+}(PureComponent);
+
+export default Sorter;

package/esm/Table/Table.d.ts

@@ -0,0 +1,2 @@
+declare const _default: typeof import("./Props").Table;
+export default _default;

package/esm/Table/Table.js

@@ -0,0 +1,173 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _extends from "@babel/runtime/helpers/extends";
+import React from 'react';
+import classnames from 'classnames';
+import { isRTL } from '../config';
+import { Component } from '../component';
+import { getLocale } from '../locale';
+import { compose } from '../utils/func';
+import { getDirectionClass } from '../utils/classname';
+import { tableClass } from './styles';
+import fixedAuto from './fixedAuto';
+import Datum from '../Datum';
+import Spin from '../Spin';
+import resizableHOC from './resizable';
+import { consumer as hideableConsumer } from '../hoc/hidable';
+import SeperateTable from './SeperateTable';
+import SimpleTable from './SimpleTable';
+import { ROW_HEIGHT_UPDATE_EVENT } from './Tr';
+import { RENDER_COL_GROUP_EVENT } from './Tbody';
+import select from './select';
+var ResizeSeperateTable = resizableHOC(SeperateTable);
+var ResizeSimpleTable = resizableHOC(SimpleTable);
+
+var RadioWrapper = function RadioWrapper(Origin) {
+  return function (props) {
+    return React.createElement(Origin, _extends({}, props, {
+      distinct: true,
+      limit: props.radio ? 1 : 0
+    }));
+  };
+};
+
+var DefaultProps = {
+  hover: true,
+  rowsInView: 20,
+  verticalAlign: 'top',
+  columns: [],
+  size: 'default'
+};
+
+var Table =
+/*#__PURE__*/
+function (_Component) {
+  _inheritsLoose(Table, _Component);
+
+  function Table(props) {
+    var _this;
+
+    _this = _Component.call(this, props) || this;
+
+    _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "table", void 0);
+
+    _this.state = {
+      scrollLeft: 0,
+      scrollRight: 0
+    };
+    _this.bindTable = _this.bindTable.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    return _this;
+  }
+
+  var _proto = Table.prototype;
+
+  _proto.componentDidUpdate = function componentDidUpdate(preProps) {
+    var _this$props = this.props,
+        datum = _this$props.datum,
+        treeCheckAll = _this$props.treeCheckAll;
+    datum.dispatch(ROW_HEIGHT_UPDATE_EVENT);
+    datum.dispatch(RENDER_COL_GROUP_EVENT);
+
+    if (treeCheckAll && this.props.data !== preProps.data) {
+      datum.cleanDataCache();
+    }
+  };
+
+  _proto.getRowsInView = function getRowsInView() {
+    var _this$props2 = this.props,
+        _this$props2$rowsInVi = _this$props2.rowsInView,
+        rowsInView = _this$props2$rowsInVi === void 0 ? DefaultProps.rowsInView : _this$props2$rowsInVi,
+        data = _this$props2.data,
+        fixed = _this$props2.fixed;
+    var dataLength = data.length;
+    if (rowsInView <= 0 || rowsInView > dataLength || fixed === 'x') return dataLength;
+    return parseInt(String(rowsInView), 10);
+  };
+
+  _proto.bindTable = function bindTable(el) {
+    var bindWrapper = this.props.bindWrapper;
+    this.table = el;
+    if (el && bindWrapper) bindWrapper(el);
+  };
+
+  _proto.render = function render() {
+    var _this$props3 = this.props,
+        striped = _this$props3.striped,
+        bordered = _this$props3.bordered,
+        size = _this$props3.size,
+        hover = _this$props3.hover,
+        height = _this$props3.height,
+        columns = _this$props3.columns,
+        children = _this$props3.children,
+        empty = _this$props3.empty,
+        data = _this$props3.data,
+        style = _this$props3.style,
+        fixed = _this$props3.fixed,
+        width = _this$props3.width,
+        loading = _this$props3.loading,
+        verticalAlign = _this$props3.verticalAlign,
+        columnResizable = _this$props3.columnResizable,
+        events = _this$props3.events,
+        others = _objectWithoutPropertiesLoose(_this$props3, ["striped", "bordered", "size", "hover", "height", "columns", "children", "empty", "data", "style", "fixed", "width", "loading", "verticalAlign", "columnResizable", "events"]);
+
+    var _this$state = this.state,
+        scrollLeft = _this$state.scrollLeft,
+        scrollRight = _this$state.scrollRight;
+    var className = classnames(tableClass('_', size, hover && 'hover', bordered && 'bordered', fixed && 'fixed', scrollLeft > 0 && 'left-float', scrollRight < 0 && 'right-float', "vertical-" + verticalAlign, columnResizable && 'resize', others.sticky && 'sticky', isRTL() && 'rtl'), this.props.className);
+
+    var props = _objectSpread({}, others, {
+      children: children,
+      fixed: fixed,
+      rowsInView: this.getRowsInView(),
+      loading: loading,
+      height: height,
+      width: width,
+      data: data,
+      columns: columns,
+      striped: striped,
+      bordered: bordered,
+      columnResizable: columnResizable
+    });
+
+    var isEmpty = (!data || data.length === 0) && !children;
+    var useSeparate = fixed && !isEmpty;
+    var ResizeSepTable = columnResizable ? ResizeSeperateTable : SeperateTable;
+    var ResizeSimTable = columnResizable ? ResizeSimpleTable : SimpleTable;
+    var RenderTable = useSeparate ? ResizeSepTable : ResizeSimTable;
+    var newStyle = Object.assign({}, style);
+    if (height) newStyle.height = height;
+    if (useSeparate && !newStyle.height) newStyle.height = '100%';
+    if (loading) newStyle.overflow = 'hidden';
+    return React.createElement("div", _extends({
+      className: className,
+      ref: this.bindTable,
+      style: newStyle
+    }, events), React.createElement(RenderTable, _extends({}, props, {
+      bordered: bordered
+    })), loading && React.createElement("div", {
+      className: tableClass('loading')
+    }, typeof loading === 'boolean' ? React.createElement(Spin, {
+      size: 40
+    }) : loading), isEmpty && React.createElement("div", {
+      className: tableClass(getDirectionClass('empty')),
+      style: {
+        visibility: loading ? 'hidden' : 'visible'
+      }
+    }, React.createElement("span", null, empty || getLocale('noData'))));
+  };
+
+  return Table;
+}(Component);
+
+_defineProperty(Table, "defaultProps", DefaultProps);
+
+var bindKeys = ['disabled', 'format', 'prediction', 'limit', 'distinct'];
+export default compose(RadioWrapper, Datum.hoc({
+  bindProps: bindKeys,
+  ignoreUndefined: true,
+  setValueType: null,
+  pure: false
+}), fixedAuto, hideableConsumer, select)(Table);

package/esm/Table/Tbody.d.ts

@@ -0,0 +1,29 @@
+import React, { ReactNode } from 'react';
+import { PureComponent } from '../component';
+import { TbodyProps, Row } from './Props';
+import { KeygenResult } from '../@types/common';
+export declare const RENDER_COL_GROUP_EVENT = "RENDER_COL_GROUP_EVENT";
+interface RowData<DataItem> extends Row<DataItem> {
+    ignoreBorderRight: boolean;
+    content?: ReactNode;
+}
+interface TbodyState {
+    expand: Record<string, boolean>;
+}
+declare class Tbody<DataItem, Value> extends PureComponent<TbodyProps<DataItem, Value>, TbodyState> {
+    colgroupSetted: boolean;
+    keys: Record<string, boolean>;
+    body: HTMLTableSectionElement;
+    constructor(props: TbodyProps<DataItem, Value>);
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: TbodyProps<DataItem, Value>): void;
+    bodyRender(): void;
+    bindBody(el: HTMLTableSectionElement): void;
+    handleExpand(key: KeygenResult, render: ReactNode): void;
+    findExpandFunc(key: KeygenResult, i: number): React.ReactNode;
+    renderTr(row: Row<DataItem>[], i: number): JSX.Element;
+    renderPlaceholderTr(): JSX.Element;
+    renderTrs(rows: RowData<DataItem>[][]): JSX.Element[];
+    render(): JSX.Element;
+}
+export default Tbody;