@apdesign/web-react 1.0.0

package/es/Table/tbody/index.d.ts

@@ -0,0 +1,3 @@
+import { TbodyProps } from '../interface';
+declare function TBody<T>(props: TbodyProps<T>): JSX.Element;
+export default TBody;

package/es/Table/tbody/index.js

@@ -0,0 +1,119 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import React, { forwardRef } from 'react';
+import { isArray } from '../../_util/is';
+import cs from '../../_util/classNames';
+import useComponent from '../hooks/useComponent';
+import VirtualList from '../../_class/VirtualList';
+import Tr from './tr';
+import { getOriginData } from '../utils';
+var DataRecordRenderer = forwardRef(function (_a, ref) {
+    var record = _a.record, index = _a.index, virtualized = _a.virtualized, tbodyProps = _a.tbodyProps;
+    var prefixCls = tbodyProps.prefixCls, columns = tbodyProps.columns, _b = tbodyProps.indentSize, indentSize = _b === void 0 ? 16 : _b, _c = tbodyProps.childrenColumnName, childrenColumnName = _c === void 0 ? 'children' : _c, _d = tbodyProps.expandProps, expandProps = _d === void 0 ? {} : _d, rowSelection = tbodyProps.rowSelection, hasFixedColumn = tbodyProps.hasFixedColumn, tableViewWidth = tbodyProps.tableViewWidth, getRowKey = tbodyProps.getRowKey, expandedRowKeys = tbodyProps.expandedRowKeys, expandedRowRender = tbodyProps.expandedRowRender;
+    var type;
+    if (rowSelection && 'type' in rowSelection) {
+        type = rowSelection.type;
+    }
+    else if (rowSelection && !('type' in rowSelection)) {
+        type = 'checkbox';
+    }
+    var er = expandedRowRender
+        ? function (r, i) { return expandedRowRender(getOriginData(r), i); }
+        : expandedRowRender;
+    var isChildrenNotEmpty = function (record) {
+        return isArray(record[childrenColumnName]) && record[childrenColumnName].length;
+    };
+    var shouldRowExpand = function (record, index) {
+        if ('rowExpandable' in expandProps && typeof expandProps.rowExpandable === 'function') {
+            return expandProps.rowExpandable(record);
+        }
+        return er && er(record, index) !== null;
+    };
+    var renderTreeTrs = function (record, index) {
+        var trList = [];
+        var trProps = __assign(__assign({}, tbodyProps), { type: type, shouldRowExpand: shouldRowExpand });
+        // 存在 record.children 时，仅使用第一个元素作为 ref 返回，此时虚拟列表获得元素高度可能不太准确，但大致可用
+        trList.push(React.createElement(Tr, __assign({ ref: ref, key: getRowKey(record) }, trProps, { record: record, level: 0, index: index })));
+        var travel = function (children, rowKey, level) {
+            if (level === void 0) { level = 0; }
+            if (isArray(children) && children.length) {
+                children.forEach(function (child, i) {
+                    if (expandedRowKeys.indexOf(rowKey) !== -1) {
+                        trList.push(React.createElement(Tr, __assign({}, trProps, { key: getRowKey(child), record: child, level: level + 1, index: i })));
+                        if (isChildrenNotEmpty(child)) {
+                            travel(child[childrenColumnName], getRowKey(child), level + 1);
+                        }
+                    }
+                });
+            }
+        };
+        if (!er) {
+            travel(record[childrenColumnName], getRowKey(record));
+        }
+        return trList;
+    };
+    var rowK = getRowKey(record);
+    var shouldRenderExpandIcon = shouldRowExpand(record, index) && expandedRowKeys.indexOf(rowK) !== -1;
+    var TRTagName = virtualized ? 'div' : 'tr';
+    var TDTagName = virtualized ? 'div' : 'td';
+    return (React.createElement(React.Fragment, { key: rowK },
+        renderTreeTrs(record, index),
+        shouldRenderExpandIcon && (React.createElement(TRTagName, { key: rowK + "-expanded", className: cs(prefixCls + "-tr", prefixCls + "-expand-content") },
+            React.createElement(TDTagName, { className: cs(prefixCls + "-td"), style: { paddingLeft: indentSize }, colSpan: columns.length }, hasFixedColumn ? (React.createElement("div", { className: prefixCls + "-expand-fixed-row", style: { width: tableViewWidth } }, er === null || er === void 0 ? void 0 : er(record, index))) : (er === null || er === void 0 ? void 0 : er(record, index)))))));
+});
+function TBody(props) {
+    var data = props.data, columns = props.columns, prefixCls = props.prefixCls, components = props.components, noDataElement = props.noDataElement, scroll = props.scroll, tableViewWidth = props.tableViewWidth, virtualized = props.virtualized, virtualListProps = props.virtualListProps, getRowKey = props.getRowKey, saveVirtualListRef = props.saveVirtualListRef;
+    var saveRef = function (node) {
+        var _a;
+        (_a = props.saveRef) === null || _a === void 0 ? void 0 : _a.call(props, node);
+    };
+    var ComponentTbody = useComponent(components).ComponentTbody;
+    var scrollStyleX = {};
+    var scrollStyleY = {};
+    if (scroll) {
+        if (scroll.x && (typeof scroll.x === 'number' || typeof scroll.x === 'string')) {
+            scrollStyleX = {
+                width: scroll.x,
+            };
+        }
+        if (scroll.y && (typeof scroll.y === 'number' || typeof scroll.y === 'string')) {
+            scrollStyleY = {
+                maxHeight: scroll.y,
+            };
+        }
+    }
+    var noElementProps = {
+        className: prefixCls + "-no-data",
+    };
+    if (tableViewWidth) {
+        noElementProps.className = prefixCls + "-no-data " + prefixCls + "-expand-fixed-row";
+        noElementProps.style = { width: tableViewWidth };
+    }
+    var noDataTr = (React.createElement("tr", { className: cs(prefixCls + "-tr", prefixCls + "-empty-row") },
+        React.createElement("td", { className: prefixCls + "-td", colSpan: columns.length },
+            React.createElement("div", __assign({}, noElementProps), noDataElement))));
+    var renderDataRecord = function (record, index) { return (React.createElement(DataRecordRenderer, { key: index, record: record, index: index, virtualized: virtualized, tbodyProps: props })); };
+    // https://github.com/arco-design/arco-design/issues/644
+    // except the real scroll container, all parent nodes should not have a overflow style.
+    if (virtualized) {
+        return data.length > 0 ? (React.createElement(VirtualList, __assign({ data: data, height: scrollStyleY.maxHeight, isStaticItemHeight: false, 
+            // position sticky works
+            outerStyle: __assign(__assign({}, scrollStyleX), { minWidth: '100%', overflow: 'visible' }), innerStyle: { right: 'auto', minWidth: '100%' }, className: prefixCls + "-body", ref: function (ref) {
+                saveVirtualListRef(ref);
+                saveRef(ref === null || ref === void 0 ? void 0 : ref.dom);
+            }, itemKey: getRowKey }, virtualListProps), renderDataRecord)) : (React.createElement("div", { className: prefixCls + "-body", ref: saveRef },
+            React.createElement("table", null,
+                React.createElement("tbody", null, noDataTr))));
+    }
+    return (React.createElement(ComponentTbody, { ref: saveRef }, data.length > 0 ? data.map(renderDataRecord) : noDataTr));
+}
+export default TBody;

package/es/Table/tbody/td.d.ts

@@ -0,0 +1,25 @@
+import React, { ReactNode } from 'react';
+import { ComponentsProps, InternalColumnProps, SorterInfo } from '../interface';
+declare type TdType = {
+    prefixCls?: string;
+    virtualized?: boolean;
+    stickyClassName?: string;
+    stickyOffset?: number;
+    components?: ComponentsProps;
+    InnerComponentTd?: any;
+    column?: InternalColumnProps;
+    columnIndex?: number;
+    currentSorter?: SorterInfo;
+    placeholder?: ReactNode;
+    indentSize?: number;
+    record?: any;
+    trIndex?: number;
+    level?: number;
+    haveTreeData?: boolean;
+    recordHaveChildren?: boolean;
+    rowKey?: string;
+    renderExpandIcon?: (record: any, rowKey: string) => ReactNode;
+};
+declare function Td(props: TdType): JSX.Element;
+declare const _default: React.MemoExoticComponent<typeof Td>;
+export default _default;

package/es/Table/tbody/td.js

@@ -0,0 +1,117 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React, { memo, useContext, useMemo } from 'react';
+import get from 'lodash/get';
+import pick from '../../_util/pick';
+import { isObject, isString } from '../../_util/is';
+import cs from '../../_util/classNames';
+import useComponent from '../hooks/useComponent';
+import { getOriginData } from '../utils';
+import { ConfigContext } from '../../ConfigProvider';
+function isInvalidRenderElement(element) {
+    return element && !React.isValidElement(element) && isObject(element);
+}
+function Td(props) {
+    var _a, _b;
+    var components = props.components, InnerComponentTd = props.InnerComponentTd, column = props.column, columnIndex = props.columnIndex, prefixCls = props.prefixCls, stickyClassName = props.stickyClassName, stickyOffset = props.stickyOffset, currentSorter = props.currentSorter, virtualized = props.virtualized, record = props.record, trIndex = props.trIndex, level = props.level, placeholder = props.placeholder, indentSize = props.indentSize, renderExpandIcon = props.renderExpandIcon, rowKey = props.rowKey, recordHaveChildren = props.recordHaveChildren, haveTreeData = props.haveTreeData;
+    var rtl = useContext(ConfigContext).rtl;
+    var ComponentBodyCell = useComponent(components).ComponentBodyCell;
+    var classNameTd = cs(prefixCls + "-td", stickyClassName, (_a = {},
+        _a[prefixCls + "-col-sorted"] = currentSorter && currentSorter.direction && currentSorter.field === column.dataIndex,
+        _a), column.className);
+    var tdProps = {};
+    var rowSpan;
+    var colSpan;
+    var styleTd = {};
+    if (column.fixed === 'left') {
+        styleTd[rtl ? 'right' : 'left'] = stickyOffset;
+    }
+    if (column.fixed === 'right') {
+        styleTd[rtl ? 'left' : 'right'] = stickyOffset;
+    }
+    if (isObject(column.cellStyle)) {
+        styleTd = __assign(__assign({}, styleTd), column.cellStyle);
+    }
+    if (isObject(column.bodyCellStyle)) {
+        styleTd = __assign(__assign({}, styleTd), column.bodyCellStyle);
+    }
+    if (column.align) {
+        styleTd.textAlign = column.align;
+    }
+    if (virtualized && column.width) {
+        styleTd.width = column.width;
+        styleTd.minWidth = column.width;
+        styleTd.maxWidth = column.width;
+    }
+    var _c = column.onCell
+        ? column.onCell(record, trIndex)
+        : { onHandleSave: function () { } }, onHandleSave = _c.onHandleSave, cellProps = __rest(_c, ["onHandleSave"]);
+    var renderElement = useMemo(function () {
+        return column.render && column.render(get(record, column.dataIndex), getOriginData(record), trIndex);
+    }, [record, column, trIndex]);
+    if (isInvalidRenderElement(renderElement)) {
+        tdProps = renderElement.props;
+        rowSpan = tdProps.rowSpan;
+        colSpan = tdProps.colSpan;
+        renderElement = renderElement.children;
+    }
+    if (rowSpan === 0 || colSpan === 0) {
+        return null;
+    }
+    var v = get(record, column.dataIndex);
+    var cellChildren = column.render
+        ? renderElement
+        : v === undefined || (typeof v === 'string' && v.trim() === '') || v === null
+            ? column.placeholder === undefined
+                ? placeholder
+                : column.placeholder
+            : v;
+    var titleProps = column.ellipsis && typeof cellChildren === 'string' ? { title: cellChildren } : {};
+    var hasInlineExpandIcon = haveTreeData && column.$$isFirstColumn;
+    var needRenderExpandIcon = hasInlineExpandIcon && recordHaveChildren;
+    var paddingLeft = hasInlineExpandIcon && level > 0 ? indentSize * level : 0;
+    if (hasInlineExpandIcon && !recordHaveChildren) {
+        // expand icon width and margin-right
+        paddingLeft += 16 + 4;
+    }
+    var content = (React.createElement(React.Fragment, null,
+        needRenderExpandIcon ? (React.createElement("span", { className: prefixCls + "-cell-expand-icon" }, renderExpandIcon(record, rowKey))) : null,
+        isString(ComponentBodyCell) ? (React.createElement(ComponentBodyCell, { className: prefixCls + "-cell-wrap-value" }, cellChildren)) : (React.createElement(ComponentBodyCell, __assign({ rowData: getOriginData(record), className: prefixCls + "-cell-wrap-value", column: column, onHandleSave: onHandleSave }, cellProps), cellChildren))));
+    return (React.createElement(InnerComponentTd, __assign({ className: classNameTd, key: column.key || column.dataIndex || columnIndex, style: styleTd }, pick(cellProps, [
+        'onClick',
+        'onDoubleClick',
+        'onContextMenu',
+        'onMouseOver',
+        'onMouseEnter',
+        'onMouseLeave',
+        'onMouseMove',
+        'onMouseDown',
+        'onMouseUp',
+    ]), tdProps),
+        React.createElement("div", __assign({ className: cs(prefixCls + "-cell", (_b = {},
+                _b[prefixCls + "-cell-text-ellipsis"] = column.ellipsis,
+                _b)) }, titleProps),
+            paddingLeft ? (React.createElement("span", { className: prefixCls + "-cell-indent", style: { paddingLeft: paddingLeft } })) : null,
+            content)));
+}
+export default memo(Td);

package/es/Table/tbody/tr.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { TbodyProps } from '../interface';
+declare type TrType<T = any> = TbodyProps<T> & {
+    record?: T;
+    shouldRowExpand?: (record: any, index: any) => boolean;
+    index?: number;
+    type?: string;
+    level?: number;
+};
+interface ForwardRefTrType extends React.ForwardRefExoticComponent<React.PropsWithoutRef<TrType> & React.RefAttributes<unknown>> {
+    <T = any>(props: React.PropsWithChildren<TrType<T>> & {
+        ref?: React.Ref<unknown>;
+    }): React.ReactElement;
+}
+declare const _default: ForwardRefTrType;
+export default _default;

package/es/Table/tbody/tr.js

@@ -0,0 +1,140 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React, { forwardRef, useContext } from 'react';
+import Checkbox from '../../Checkbox';
+import Radio from '../../Radio';
+import { isString, isArray } from '../../_util/is';
+import { getOriginData } from '../utils';
+import cs from '../../_util/classNames';
+import useComponent from '../hooks/useComponent';
+import IconPlus from '../../../icon/react-icon/IconPlus';
+import IconMinus from '../../../icon/react-icon/IconMinus';
+import { INTERNAL_EXPAND_KEY, INTERNAL_SELECTION_KEY } from '../constant';
+import { ConfigContext } from '../../ConfigProvider';
+import Td from './td';
+function Tr(props, ref) {
+    var _a;
+    var expandedRowRender = props.expandedRowRender, onClickExpandBtn = props.onClickExpandBtn, columns = props.columns, components = props.components, onCheck = props.onCheck, onCheckRadio = props.onCheckRadio, prefixCls = props.prefixCls, selectedRowKeys = props.selectedRowKeys, indeterminateKeys = props.indeterminateKeys, rowClassName = props.rowClassName, onRow = props.onRow, rowSelection = props.rowSelection, _b = props.indentSize, indentSize = _b === void 0 ? 16 : _b, activeSorters = props.activeSorters, virtualized = props.virtualized, stickyOffsets = props.stickyOffsets, stickyClassNames = props.stickyClassNames, getRowKey = props.getRowKey, placeholder = props.placeholder, _c = props.expandProps, expandProps = _c === void 0 ? { strictTreeData: true } : _c, data = props.data, expandedRowKeys = props.expandedRowKeys, childrenColumnName = props.childrenColumnName, record = props.record, index = props.index, type = props.type, shouldRowExpand = props.shouldRowExpand, level = props.level;
+    var rtl = useContext(ConfigContext).rtl;
+    var originRecord = getOriginData(record);
+    var rowProps = __rest((onRow && onRow(originRecord, index)) || {}, []);
+    var rowK = getRowKey(record);
+    var usedSelectedRowKeys = type === 'radio' ? selectedRowKeys.slice(0, 1) : selectedRowKeys;
+    var trKey = rowK || index;
+    var checked = usedSelectedRowKeys.indexOf(rowK) > -1;
+    var expanded = expandedRowKeys.indexOf(rowK) > -1;
+    var indeterminate = indeterminateKeys.indexOf(rowK) > -1;
+    var classNameTr = cs(prefixCls + "-tr", (_a = {},
+        _a[prefixCls + "-row-checked"] = checked,
+        _a[prefixCls + "-row-expanded"] = expanded,
+        _a), rowClassName && rowClassName(originRecord, index));
+    var checkboxProps = rowSelection && typeof rowSelection.checkboxProps === 'function'
+        ? rowSelection.checkboxProps(originRecord)
+        : {};
+    var operationClassName = cs(prefixCls + "-td", prefixCls + "-operation");
+    var getPrefixColClassName = function (name) {
+        var _a;
+        return cs(operationClassName, prefixCls + "-" + name, (_a = {},
+            _a[prefixCls + "-selection-col"] = (virtualized && type === 'checkbox') || type === 'radio',
+            _a[prefixCls + "-expand-icon-col"] = virtualized && expandedRowRender,
+            _a));
+    };
+    function isChildrenNotEmpty(record) {
+        return expandProps.strictTreeData
+            ? isArray(record[childrenColumnName]) && record[childrenColumnName].length
+            : record[childrenColumnName] !== undefined;
+    }
+    // tree data
+    function isDataHaveChildren() {
+        return data.find(function (d) { return isChildrenNotEmpty(d); });
+    }
+    var shouldRenderExpandRow = shouldRowExpand(record, index);
+    var recordHaveChildren = isChildrenNotEmpty(record);
+    var haveTreeData = isDataHaveChildren() && !expandedRowRender;
+    var shouldRenderTreeDataExpandRow = haveTreeData && recordHaveChildren;
+    var expandRowByClick = expandProps.expandRowByClick;
+    var rowClickProps = expandRowByClick && (shouldRenderExpandRow || shouldRenderTreeDataExpandRow)
+        ? {
+            onClick: function (e) {
+                onClickExpandBtn(rowK);
+                rowProps && rowProps.onClick && rowProps.onClick(e);
+            },
+        }
+        : {};
+    var _d = useComponent(components), ComponentBodyRow = _d.ComponentBodyRow, ComponentTd = _d.ComponentTd, getBodyComponentOperations = _d.getBodyComponentOperations;
+    var InnerComponentBodyRow = virtualized ? 'div' : ComponentBodyRow;
+    var InnerComponentTd = virtualized ? 'div' : ComponentTd;
+    var baseTrProps = __assign(__assign({ className: classNameTr, key: trKey }, rowProps), rowClickProps);
+    var trProps = isString(ComponentBodyRow) ? baseTrProps : __assign(__assign({}, baseTrProps), { record: record, index: index });
+    function renderExpandIcon(record, rowK) {
+        var expandIcon = expandProps.icon;
+        var expanded = !!~expandedRowKeys.indexOf(rowK);
+        var onClickProps = {
+            onClick: function (e) {
+                e.stopPropagation();
+                onClickExpandBtn(rowK);
+            },
+        };
+        return typeof expandIcon === 'function' ? (expandIcon(__assign({ expanded: expanded, record: record }, onClickProps))) : (React.createElement("button", __assign({}, onClickProps, { type: "button" }), expanded ? React.createElement(IconMinus, null) : React.createElement(IconPlus, null)));
+    }
+    var expandNode = expandedRowRender && (React.createElement(InnerComponentTd, { className: getPrefixColClassName('expand-icon-cell') }, shouldRenderExpandRow && renderExpandIcon(record, rowK)));
+    var renderSelectionCell = rowSelection && rowSelection.renderCell;
+    var selectionNode;
+    var checkboxNode = (React.createElement(Checkbox, __assign({ value: rowK, onChange: function (check) { return onCheck(check, record); }, checked: checked, indeterminate: indeterminate }, checkboxProps)));
+    var radioNode = (React.createElement(Radio, __assign({ onChange: function () { return onCheckRadio(rowK, record); }, value: rowK, checked: checked }, checkboxProps)));
+    if (type === 'checkbox') {
+        selectionNode = (React.createElement(InnerComponentTd, { className: getPrefixColClassName('checkbox') }, renderSelectionCell
+            ? renderSelectionCell(checkboxNode, checked, originRecord)
+            : checkboxNode));
+    }
+    if (type === 'radio') {
+        selectionNode = (React.createElement(InnerComponentTd, { className: getPrefixColClassName('radio') }, renderSelectionCell ? renderSelectionCell(radioNode, checked, originRecord) : radioNode));
+    }
+    var bodyOperations = getBodyComponentOperations({ selectionNode: selectionNode, expandNode: expandNode });
+    return (React.createElement(InnerComponentBodyRow, __assign({}, trProps, { ref: ref }), columns.map(function (col, colIndex) {
+        var _a;
+        var _b, _c, _d, _e;
+        var stickyOffset = stickyOffsets[colIndex];
+        var stickyClassName = stickyClassNames[colIndex];
+        if (col.$$isOperation) {
+            var node = col.node;
+            var isExtraOperation = true;
+            if (col.title === INTERNAL_SELECTION_KEY) {
+                node = (_b = bodyOperations.find(function (o) { return o.name === 'selectionNode'; })) === null || _b === void 0 ? void 0 : _b.node;
+                isExtraOperation = false;
+            }
+            if (col.title === INTERNAL_EXPAND_KEY) {
+                node = (_c = bodyOperations.find(function (o) { return o.name === 'expandNode'; })) === null || _c === void 0 ? void 0 : _c.node;
+                isExtraOperation = false;
+            }
+            var operationNode = typeof node === 'function' ? node(record) : node;
+            return React.cloneElement(operationNode, __assign(__assign({ key: col.key || colIndex }, operationNode.props), { className: cs(isExtraOperation ? operationClassName : '', (_d = operationNode === null || operationNode === void 0 ? void 0 : operationNode.props) === null || _d === void 0 ? void 0 : _d.className, stickyClassName), style: __assign(__assign(__assign({}, (_e = operationNode === null || operationNode === void 0 ? void 0 : operationNode.props) === null || _e === void 0 ? void 0 : _e.style), (col.fixed === 'left'
+                    ? (_a = {},
+                        _a[rtl ? 'right' : 'left'] = stickyOffset,
+                        _a) : {})), { width: col.width, minWidth: col.width }) }));
+        }
+        return (React.createElement(Td, { key: colIndex, prefixCls: prefixCls, virtualized: virtualized, components: components, currentSorter: activeSorters.find(function (item) { return item.field === col.key; }), placeholder: placeholder, indentSize: indentSize, stickyClassName: stickyClassName, stickyOffset: stickyOffset, InnerComponentTd: InnerComponentTd, column: col, columnIndex: colIndex, record: record, trIndex: index, level: level, haveTreeData: haveTreeData, recordHaveChildren: recordHaveChildren, rowKey: rowK, renderExpandIcon: renderExpandIcon }));
+    })));
+}
+var ForwardRefTr = forwardRef(Tr);
+export default ForwardRefTr;

package/es/Table/tfoot/index.d.ts

@@ -0,0 +1,3 @@
+import { TfootProps } from '../interface';
+declare function Tfoot<T>(props: TfootProps<T>): JSX.Element;
+export default Tfoot;

package/es/Table/tfoot/index.js

@@ -0,0 +1,9 @@
+import React from 'react';
+import { SummaryContext } from '../summary/context';
+import { getOriginData } from '../utils';
+function Tfoot(props) {
+    var summary = props.summary, data = props.data, prefixCls = props.prefixCls, columns = props.columns, stickyOffsets = props.stickyOffsets, stickyClassNames = props.stickyClassNames;
+    return (React.createElement("tfoot", { className: prefixCls + "-tfoot" },
+        React.createElement(SummaryContext.Provider, { value: { columns: columns, stickyOffsets: stickyOffsets, stickyClassNames: stickyClassNames, prefixCls: prefixCls } }, summary(getOriginData(data)))));
+}
+export default Tfoot;

package/es/Table/thead/column.d.ts

@@ -0,0 +1,3 @@
+import { ColumnComponentProps } from '../interface';
+declare function Column<T>({ onSort, onFilter, onHandleFilter, onHandleFilterReset, currentFilters, currentSorter, _key, dataIndex, title, sorter, sortDirections, filters, columnFixedStyle, className, cellStyle, headerCellStyle, rowSpan, colSpan, headerCellProps, prefixCls, align, components, filterIcon, filterDropdown, filterMultiple, ellipsis, filterDropdownProps, onFilterDropdownVisibleChange, column, showSorterTooltip, index, }: ColumnComponentProps<T>): JSX.Element;
+export default Column;