@alifd/next/lib/table/lock.js

'use strict';

exports.__esModule = true;

var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

var _typeof2 = require('babel-runtime/helpers/typeof');

var _typeof3 = _interopRequireDefault(_typeof2);

var _extends2 = require('babel-runtime/helpers/extends');

var _extends3 = _interopRequireDefault(_extends2);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

var _inherits2 = require('babel-runtime/helpers/inherits');

var _inherits3 = _interopRequireDefault(_inherits2);

exports.default = lock;

var _react = require('react');

var _react2 = _interopRequireDefault(_react);

var _reactDom = require('react-dom');

var _propTypes = require('prop-types');

var _propTypes2 = _interopRequireDefault(_propTypes);

var _classnames2 = require('classnames');

var _classnames3 = _interopRequireDefault(_classnames2);

var _shallowElementEquals = require('shallow-element-equals');

var _shallowElementEquals2 = _interopRequireDefault(_shallowElementEquals);

var _util = require('../util');

var _row = require('./lock/row');

var _row2 = _interopRequireDefault(_row);

var _body = require('./lock/body');

var _body2 = _interopRequireDefault(_body);

var _header = require('./lock/header');

var _header2 = _interopRequireDefault(_header);

var _wrapper = require('./fixed/wrapper');

var _wrapper2 = _interopRequireDefault(_wrapper);

var _util2 = require('./util');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var ieVersion = _util.env.ieVersion;
function lock(BaseComponent) {
    var _class, _temp;

    /** Table */
    var LockTable = (_temp = _class = function (_React$Component) {
        (0, _inherits3.default)(LockTable, _React$Component);

        function LockTable(props, context) {
            (0, _classCallCheck3.default)(this, LockTable);

            var _this = (0, _possibleConstructorReturn3.default)(this, _React$Component.call(this, props, context));

            _this.state = {};

            _this.getTableInstance = function (type, instance) {
                type = type ? type.charAt(0).toUpperCase() + type.substr(1) : '';
                _this['table' + type + 'Inc'] = instance;
            };

            _this.getNode = function (type, node, lockType) {
                lockType = lockType ? lockType.charAt(0).toUpperCase() + lockType.substr(1) : '';
                _this['' + type + lockType + 'Node'] = node;
                if (type === 'header' && !_this.innerHeaderNode && !lockType) {
                    _this.innerHeaderNode = _this.headerNode.querySelector('div');
                }
            };

            _this.onRowMouseEnter = function (record, index) {
                if (_this.isLock()) {
                    var row = _this.getRowNode(index);
                    var leftRow = _this.getRowNode(index, 'left');
                    var rightRow = _this.getRowNode(index, 'right');
                    [row, leftRow, rightRow].forEach(function (row) {
                        row && _util.dom.addClass(row, 'hovered');
                    });
                }
            };

            _this.onRowMouseLeave = function (record, index) {
                if (_this.isLock()) {
                    var row = _this.getRowNode(index);
                    var leftRow = _this.getRowNode(index, 'left');
                    var rightRow = _this.getRowNode(index, 'right');
                    [row, leftRow, rightRow].forEach(function (row) {
                        row && _util.dom.removeClass(row, 'hovered');
                    });
                }
            };

            _this.onLockBodyScrollTop = function (event) {
                // set scroll top for lock columns & main body
                var target = event.target;
                if (event.currentTarget !== target) {
                    return;
                }
                var distScrollTop = target.scrollTop;

                if (_this.isLock() && distScrollTop !== _this.lastScrollTop) {
                    var lockRightBody = _this.bodyRightNode,
                        lockLeftBody = _this.bodyLeftNode,
                        bodyNode = _this.bodyNode;

                    var arr = [lockLeftBody, lockRightBody, bodyNode];

                    arr.forEach(function (node) {
                        if (node && node.scrollTop !== distScrollTop) {
                            node.scrollTop = distScrollTop;
                        }
                    });

                    _this.lastScrollTop = distScrollTop;
                }
            };

            _this.onLockBodyScrollLeft = function () {
                // add shadow class for lock columns
                if (_this.isLock()) {
                    var rtl = _this.props.rtl;

                    var lockRightTable = rtl ? _this.getWrapperNode('left') : _this.getWrapperNode('right'),
                        lockLeftTable = rtl ? _this.getWrapperNode('right') : _this.getWrapperNode('left'),
                        shadowClassName = 'shadow';

                    var x = _this.bodyNode.scrollLeft;

                    if (x === 0) {
                        lockLeftTable && _util.dom.removeClass(lockLeftTable, shadowClassName);
                        lockRightTable && _util.dom.addClass(lockRightTable, shadowClassName);
                    } else if (x === _this.bodyNode.scrollWidth - _this.bodyNode.clientWidth) {
                        lockLeftTable && _util.dom.addClass(lockLeftTable, shadowClassName);
                        lockRightTable && _util.dom.removeClass(lockRightTable, shadowClassName);
                    } else {
                        lockLeftTable && _util.dom.addClass(lockLeftTable, shadowClassName);
                        lockRightTable && _util.dom.addClass(lockRightTable, shadowClassName);
                    }
                }
            };

            _this.onLockBodyScroll = function (event) {
                _this.onLockBodyScrollTop(event);
                _this.onLockBodyScrollLeft();
            };

            _this.adjustSize = function () {
                if (!_this.adjustIfTableNotNeedLock()) {
                    _this.adjustHeaderSize();
                    _this.adjustBodySize();
                    _this.adjustRowHeight();
                    _this.onLockBodyScrollLeft();
                }
            };

            _this.getFlatenChildrenLength = function () {
                var children = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];

                var loop = function loop(arr) {
                    var newArray = [];
                    arr.forEach(function (child) {
                        if (child && child.children) {
                            newArray.push.apply(newArray, loop(child.children));
                        } else {
                            newArray.push(child);
                        }
                    });
                    return newArray;
                };

                return loop(children).length;
            };

            _this.saveLockLeftRef = function (ref) {
                _this.lockLeftEl = ref;
            };

            _this.saveLockRightRef = function (ref) {
                _this.lockRightEl = ref;
            };

            _this.lockLeftChildren = [];
            _this.lockRightChildren = [];
            return _this;
        }

        LockTable.prototype.getChildContext = function getChildContext() {
            return {
                getTableInstance: this.getTableInstance,
                getLockNode: this.getNode,
                onLockBodyScroll: this.onLockBodyScroll,
                onRowMouseEnter: this.onRowMouseEnter,
                onRowMouseLeave: this.onRowMouseLeave
            };
        };

        LockTable.prototype.componentDidMount = function componentDidMount() {
            _util.events.on(window, 'resize', this.adjustSize);

            this.scroll();
            this.adjustSize();
            this.forceUpdate();
        };

        LockTable.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps, nextState, nextContext) {
            if (nextProps.pure) {
                var isEqual = (0, _shallowElementEquals2.default)(nextProps, this.props);
                return !(isEqual && _util.obj.shallowEqual(nextContext, this.context));
            }

            return true;
        };

        LockTable.prototype.componentDidUpdate = function componentDidUpdate() {
            this.adjustSize();
            this._isLock = false;
        };

        LockTable.prototype.componentWillUnmount = function componentWillUnmount() {
            _util.events.off(window, 'resize', this.adjustSize);
        };

        LockTable.prototype.normalizeChildrenState = function normalizeChildrenState(props) {
            var columns = this.normalizeChildren(props);
            var splitChildren = this.splitFromNormalizeChildren(columns);
            var lockLeftChildren = splitChildren.lockLeftChildren,
                lockRightChildren = splitChildren.lockRightChildren;

            return {
                lockLeftChildren: lockLeftChildren,
                lockRightChildren: lockRightChildren,
                children: this.mergeFromSplitLockChildren(splitChildren)
            };
        };

        // 将React结构化数据提取props转换成数组


        LockTable.prototype.normalizeChildren = function normalizeChildren(props) {
            var children = props.children,
                columns = props.columns;

            var isLock = false,
                ret = void 0;
            var checkLock = function checkLock(col) {
                if ([true, 'left', 'right'].indexOf(col.lock) > -1) {
                    if (!('width' in col)) {
                        _util.log.warning('Should config width for lock column named [ ' + col.dataIndex + ' ].');
                    }
                    isLock = true;
                }
            };
            if (columns && !children) {
                ret = columns;

                var getColumns = function getColumns(cols) {
                    cols.forEach(function () {
                        var col = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

                        checkLock(col);

                        if (col.children) {
                            getColumns(col.children);
                        }
                    });
                };

                getColumns(columns);
            } else {
                var getChildren = function getChildren(children) {
                    var ret = [];
                    _react.Children.forEach(children, function (child) {
                        if (child) {
                            var _props = (0, _extends3.default)({}, child.props);
                            checkLock(_props);
                            ret.push(_props);
                            if (child.props.children) {
                                _props.children = getChildren(child.props.children);
                            }
                        }
                    });
                    return ret;
                };

                ret = getChildren(children);
            }

            ret.forEach(function (child) {
                // 为自定义的列特殊处理
                if (child.__normalized && isLock) {
                    // users can set lock type for column selection now, so its origin lock type comes first
                    child.lock = child.lock || 'left';
                    delete child.__normalized;
                }
            });
            this._isLock = isLock;
            return ret;
        };

        //从数组中分离出lock的列和正常的列


        LockTable.prototype.splitFromNormalizeChildren = function splitFromNormalizeChildren(children) {
            var originChildren = deepCopy(children);
            var lockLeftChildren = deepCopy(children);
            var lockRightChildren = deepCopy(children);
            var loop = function loop(lockChildren, condition) {
                var ret = [];
                lockChildren.forEach(function (child) {
                    if (child.children) {
                        var res = loop(child.children, condition);
                        if (!res.length) {
                            ret.push(child);
                        }
                    } else {
                        var order = condition(child);
                        if (!order) {
                            ret.push(child);
                        }
                    }
                });
                ret.forEach(function (res) {
                    var index = lockChildren.indexOf(res);
                    lockChildren.splice(index, 1);
                });
                return lockChildren;
            };
            loop(lockLeftChildren, function (child) {
                if (child.lock === true || child.lock === 'left') {
                    return 'left';
                }
            });
            loop(lockRightChildren, function (child) {
                if (child.lock === 'right') {
                    return 'right';
                }
            });
            loop(originChildren, function (child) {
                return child.lock !== true && child.lock !== 'left' && child.lock !== 'right';
            });
            return {
                lockLeftChildren: lockLeftChildren,
                lockRightChildren: lockRightChildren,
                originChildren: originChildren
            };
        };

        //将左侧的锁列树和中间的普通树及右侧的锁列树进行合并


        LockTable.prototype.mergeFromSplitLockChildren = function mergeFromSplitLockChildren(splitChildren) {
            var lockLeftChildren = splitChildren.lockLeftChildren,
                lockRightChildren = splitChildren.lockRightChildren;
            var originChildren = splitChildren.originChildren;

            Array.prototype.unshift.apply(originChildren, lockLeftChildren);
            originChildren = originChildren.concat(lockRightChildren);
            return originChildren;
        };

        LockTable.prototype.scroll = function scroll() {
            var _props2 = this.props,
                _props2$scrollToCol = _props2.scrollToCol,
                scrollToCol = _props2$scrollToCol === undefined ? 0 : _props2$scrollToCol,
                _props2$scrollToRow = _props2.scrollToRow,
                scrollToRow = _props2$scrollToRow === undefined ? 0 : _props2$scrollToRow;

            if (!scrollToCol && !scrollToRow || !this.bodyNode) {
                return;
            }
            var colCellNode = this.getCellNode(0, scrollToCol);
            var rowCellNode = this.getCellNode(scrollToRow, 0);
            var bodyNodeOffset = this.bodyNode.getBoundingClientRect() || {};
            if (colCellNode) {
                var cellNodeoffset = colCellNode.getBoundingClientRect();
                var scrollLeft = cellNodeoffset.left - bodyNodeOffset.left;
                this.bodyNode.scrollLeft = scrollLeft;
            }
            if (rowCellNode) {
                var _cellNodeoffset = rowCellNode.getBoundingClientRect();
                var scrollTop = _cellNodeoffset.top - bodyNodeOffset.top;
                this.bodyNode.scrollTop = scrollTop;
            }
        };

        // Table处理过后真实的lock状态
        LockTable.prototype.isLock = function isLock() {
            return this.lockLeftChildren.length || this.lockRightChildren.length;
        };

        // 用户设置的lock状态


        LockTable.prototype.isOriginLock = function isOriginLock() {
            return this._isLock;
        };

        LockTable.prototype.removeLockTable = function removeLockTable() {
            var lockLeftLen = this.lockLeftChildren.length;
            var lockRightLen = this.lockRightChildren.length;

            if (lockLeftLen) {
                this._notNeedAdjustLockLeft = true;
            }
            if (lockRightLen) {
                this._notNeedAdjustLockRight = true;
            }
            if (lockRightLen || lockLeftLen) {
                this.forceUpdate();
                return true;
            }
        };

        LockTable.prototype.adjustIfTableNotNeedLock = function adjustIfTableNotNeedLock() {
            var _this2 = this;

            if (this.isOriginLock()) {
                var widthObj = this.tableInc.flatChildren.map(function (item, index) {
                    var cell = _this2.getCellNode(0, index) || {};
                    var headerCell = _this2.getHeaderCellNode(0, index) || {};

                    // fix https://codesandbox.io/s/fusion-next-template-d9bu8
                    // close #1832
                    try {
                        return {
                            cellWidths: parseFloat(getComputedStyle(cell).width) || 0,
                            headerWidths: parseFloat(getComputedStyle(headerCell).width) || 0
                        };
                    } catch (error) {
                        return {
                            cellWidths: cell.clientWidth || 0,
                            headerWidths: headerCell.clientWidth || 0
                        };
                    }
                }).reduce(function (a, b) {
                    return {
                        cellWidths: a.cellWidths + b.cellWidths,
                        headerWidths: a.headerWidths + b.headerWidths
                    };
                }, {
                    cellWidths: 0,
                    headerWidths: 0
                });

                var node = void 0,
                    width = void 0;

                try {
                    node = (0, _reactDom.findDOMNode)(this);
                    width = node.clientWidth;
                } catch (err) {
                    node = null;
                    width = 0;
                }

                // if the table doesn't exist, there is no need to adjust
                if (width === 0) {
                    return true;
                }

                var configWidths = parseInt(widthObj.cellWidths) || parseInt(widthObj.headerWidths);

                if (configWidths <= width && configWidths > 0) {
                    this.removeLockTable();
                } else if (this._notNeedAdjustLockLeft || this._notNeedAdjustLockRight) {
                    this._notNeedAdjustLockLeft = this._notNeedAdjustLockRight = false;
                    this.forceUpdate();
                } else {
                    this._notNeedAdjustLockLeft = this._notNeedAdjustLockRight = false;
                    return false;
                }
            }

            return false;
        };

        LockTable.prototype.adjustBodySize = function adjustBodySize() {
            var _style;

            var _props3 = this.props,
                rtl = _props3.rtl,
                hasHeader = _props3.hasHeader;

            var header = this.headerNode;
            var paddingName = rtl ? 'paddingLeft' : 'paddingRight';
            var marginName = rtl ? 'marginLeft' : 'marginRight';
            var scrollBarSize = +_util.dom.scrollbar().width || 0;
            var style = (_style = {}, _style[paddingName] = scrollBarSize, _style[marginName] = scrollBarSize, _style);
            var body = this.bodyNode,
                hasVerScroll = body && body.scrollHeight > body.clientHeight;

            if (this.isLock()) {
                var lockLeftBody = this.bodyLeftNode,
                    lockRightBody = this.bodyRightNode,
                    lockRightBodyWrapper = this.getWrapperNode('right'),
                    bodyHeight = body.offsetHeight,
                    width = hasVerScroll ? scrollBarSize : 0,
                    lockBodyHeight = bodyHeight - scrollBarSize;

                if (!hasVerScroll) {
                    style[paddingName] = 0;
                    style[marginName] = 0;
                }
                if (+scrollBarSize) {
                    style.marginBottom = -scrollBarSize;
                    style.paddingBottom = scrollBarSize;
                } else {
                    style.marginBottom = -20;
                    style.paddingBottom = 20;
                }

                var lockStyle = {
                    'max-height': lockBodyHeight
                };
                if (!hasHeader && !+scrollBarSize) {
                    lockStyle[marginName] = 0;
                }
                if (+scrollBarSize) {
                    lockStyle[marginName] = -scrollBarSize;
                }
                lockLeftBody && _util.dom.setStyle(lockLeftBody, lockStyle);
                lockRightBody && _util.dom.setStyle(lockRightBody, lockStyle);
                lockRightBodyWrapper && +scrollBarSize && _util.dom.setStyle(lockRightBodyWrapper, rtl ? 'left' : 'right', width + 'px');
            } else {
                style.marginBottom = -scrollBarSize;
                style.paddingBottom = scrollBarSize;
                style[marginName] = 0;
                if (!hasVerScroll) {
                    style[paddingName] = 0;
                }
            }

            header && _util.dom.setStyle(header, style);
        };

        LockTable.prototype.adjustHeaderSize = function adjustHeaderSize() {
            var _this3 = this;

            if (this.isLock()) {
                this.tableInc.groupChildren.forEach(function (child, index) {
                    var lastIndex = _this3.tableInc.groupChildren[index].length - 1;
                    var headerRightRow = _this3.getHeaderCellNode(index, lastIndex),
                        headerLeftRow = _this3.getHeaderCellNode(index, 0),
                        headerRightLockRow = _this3.getHeaderCellNode(index, 0, 'right'),
                        headerLeftLockRow = _this3.getHeaderCellNode(index, 0, 'left');

                    if (headerRightRow && headerRightLockRow) {
                        var maxRightRowHeight = headerRightRow.offsetHeight;

                        _util.dom.setStyle(headerRightLockRow, 'height', maxRightRowHeight);

                        setTimeout(function () {
                            var affixRef = _this3.tableRightInc.affixRef;
                            // if rendered then update postion of affix
                            return affixRef && affixRef.getInstance() && affixRef.getInstance().updatePosition();
                        });
                    }

                    if (headerLeftRow && headerLeftLockRow) {
                        var maxLeftRowHeight = headerLeftRow.offsetHeight;

                        _util.dom.setStyle(headerLeftLockRow, 'height', maxLeftRowHeight);

                        setTimeout(function () {
                            var affixRef = _this3.tableLeftInc.affixRef;
                            // if rendered then update postion of affix
                            return affixRef && affixRef.getInstance() && affixRef.getInstance().updatePosition();
                        });
                    }
                });
            }
        };

        LockTable.prototype.adjustRowHeight = function adjustRowHeight() {
            var _this4 = this;

            if (this.isLock()) {
                this.tableInc.props.dataSource.forEach(function (item, index) {
                    // record may be a string
                    var rowIndex = '' + ((typeof item === 'undefined' ? 'undefined' : (0, _typeof3.default)(item)) === 'object' && '__rowIndex' in item ? item.__rowIndex : index) + (item.__expanded ? '_expanded' : '');

                    // 同步左侧的锁列
                    _this4.setRowHeight(rowIndex, 'left');
                    // 同步右侧的锁列
                    _this4.setRowHeight(rowIndex, 'right');
                });
            }
        };

        LockTable.prototype.setRowHeight = function setRowHeight(rowIndex, dir) {
            var lockRow = this.getRowNode(rowIndex, dir),
                row = this.getRowNode(rowIndex),
                rowHeight = (ieVersion ? row && row.offsetHeight : row && parseFloat(getComputedStyle(row).height)) || 'auto',
                lockHeight = (ieVersion ? lockRow && lockRow.offsetHeight : lockRow && parseFloat(getComputedStyle(lockRow).height)) || 'auto';

            if (lockRow && rowHeight !== lockHeight) {
                _util.dom.setStyle(lockRow, 'height', rowHeight);
            }
        };

        LockTable.prototype.getWrapperNode = function getWrapperNode(type) {
            type = type ? type.charAt(0).toUpperCase() + type.substr(1) : '';
            try {
                // in case of finding an unmounted component due to cached data
                // need to clear refs of table when dataSource Changed
                // use try catch for temporary
                return (0, _reactDom.findDOMNode)(this['lock' + type + 'El']);
            } catch (error) {
                return null;
            }
        };

        // remove this in next major version, keep this for temperary incase of using it
        // getFirstNormalCellNode(index) {
        //     let i = 0;
        //     let row;
        //     do {
        //         row = this.getCellNode(index, i);
        //         i++;
        //     } while (
        //         (!row || (row && row.rowSpan && row.rowSpan > 1)) &&
        //         this.tableInc.flatChildren.length > i
        //     );

        //     return row;
        // }

        LockTable.prototype.getRowNode = function getRowNode(index, type) {
            type = type ? type.charAt(0).toUpperCase() + type.substr(1) : '';
            var table = this['table' + type + 'Inc'];

            try {
                // in case of finding an unmounted component due to cached data
                // need to clear refs of table when dataSource Changed
                // use try catch for temporary
                return (0, _reactDom.findDOMNode)(table.getRowRef(index));
            } catch (error) {
                return null;
            }
        };

        LockTable.prototype.getHeaderCellNode = function getHeaderCellNode(index, i, type) {
            type = type ? type.charAt(0).toUpperCase() + type.substr(1) : '';
            var table = this['table' + type + 'Inc'];

            try {
                // in case of finding an unmounted component due to cached data
                // need to clear refs of table when dataSource Changed
                // use try catch for temporary
                return (0, _reactDom.findDOMNode)(table.getHeaderCellRef(index, i));
            } catch (error) {
                return null;
            }
        };

        LockTable.prototype.getCellNode = function getCellNode(index, i, type) {
            type = type ? type.charAt(0).toUpperCase() + type.substr(1) : '';
            var table = this['table' + type + 'Inc'];

            try {
                // in case of finding an unmounted component due to cached data
                // need to clear refs of table when dataSource Changed
                // use try catch for temporary
                return (0, _reactDom.findDOMNode)(table.getCellRef(index, i));
            } catch (error) {
                return null;
            }
        };

        LockTable.prototype.render = function render() {
            /* eslint-disable no-unused-vars, prefer-const */
            var _props4 = this.props,
                children = _props4.children,
                columns = _props4.columns,
                prefix = _props4.prefix,
                components = _props4.components,
                className = _props4.className,
                dataSource = _props4.dataSource,
                tableWidth = _props4.tableWidth,
                others = (0, _objectWithoutProperties3.default)(_props4, ['children', 'columns', 'prefix', 'components', 'className', 'dataSource', 'tableWidth']);

            var _normalizeChildrenSta = this.normalizeChildrenState(this.props),
                lockLeftChildren = _normalizeChildrenSta.lockLeftChildren,
                lockRightChildren = _normalizeChildrenSta.lockRightChildren,
                normalizedChildren = _normalizeChildrenSta.children;

            var leftLen = this.getFlatenChildrenLength(lockLeftChildren);
            var rightLen = this.getFlatenChildrenLength(lockRightChildren);
            var originLen = this.getFlatenChildrenLength(normalizedChildren);

            var lengths = {
                left: leftLen,
                right: rightLen,
                origin: originLen
            };
            if (this._notNeedAdjustLockLeft) {
                lockLeftChildren = [];
            }
            if (this._notNeedAdjustLockRight) {
                lockRightChildren = [];
            }
            this.lockLeftChildren = lockLeftChildren;
            this.lockRightChildren = lockRightChildren;

            if (this.isOriginLock()) {
                var _classnames;

                components = (0, _extends3.default)({}, components);
                components.Body = components.Body || _body2.default;
                components.Header = components.Header || _header2.default;
                components.Wrapper = components.Wrapper || _wrapper2.default;
                components.Row = components.Row || _row2.default;
                className = (0, _classnames3.default)((_classnames = {}, _classnames[prefix + 'table-lock'] = true, _classnames[prefix + 'table-wrap-empty'] = !dataSource.length, _classnames[className] = className, _classnames));
                var content = [_react2.default.createElement(BaseComponent, (0, _extends3.default)({}, others, {
                    dataSource: dataSource,
                    key: 'lock-left',
                    columns: lockLeftChildren,
                    className: prefix + 'table-lock-left',
                    lengths: lengths,
                    prefix: prefix,
                    lockType: 'left',
                    components: components,
                    ref: this.saveLockLeftRef,
                    loading: false,
                    'aria-hidden': true
                })), _react2.default.createElement(BaseComponent, (0, _extends3.default)({}, others, {
                    dataSource: dataSource,
                    key: 'lock-right',
                    columns: lockRightChildren,
                    className: prefix + 'table-lock-right',
                    lengths: lengths,
                    prefix: prefix,
                    lockType: 'right',
                    components: components,
                    ref: this.saveLockRightRef,
                    loading: false,
                    'aria-hidden': true
                }))];
                return _react2.default.createElement(BaseComponent, (0, _extends3.default)({}, others, {
                    tableWidth: tableWidth,
                    dataSource: dataSource,
                    columns: normalizedChildren,
                    prefix: prefix,
                    lengths: lengths,
                    wrapperContent: content,
                    components: components,
                    className: className
                }));
            }
            return _react2.default.createElement(BaseComponent, this.props);
        };

        return LockTable;
    }(_react2.default.Component), _class.LockRow = _row2.default, _class.LockBody = _body2.default, _class.LockHeader = _header2.default, _class.propTypes = (0, _extends3.default)({
        scrollToCol: _propTypes2.default.number,
        /**
         * 指定滚动到某一行，仅在`useVirtual`的时候生效
         */
        scrollToRow: _propTypes2.default.number
    }, BaseComponent.propTypes), _class.defaultProps = (0, _extends3.default)({}, BaseComponent.defaultProps), _class.childContextTypes = {
        getTableInstance: _propTypes2.default.func,
        getLockNode: _propTypes2.default.func,
        onLockBodyScroll: _propTypes2.default.func,
        onRowMouseEnter: _propTypes2.default.func,
        onRowMouseLeave: _propTypes2.default.func
    }, _temp);
    LockTable.displayName = 'LockTable';

    (0, _util2.statics)(LockTable, BaseComponent);
    return LockTable;
}

function deepCopy(arr) {
    var copy = function copy(arr) {
        return arr.map(function (item) {
            var newItem = (0, _extends3.default)({}, item);
            if (item.children) {
                item.children = copy(item.children);
            }
            return newItem;
        });
    };
    return copy(arr);
}
module.exports = exports['default'];