text: import _extends from "@babel/runtime/helpers/extends";
  import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
  import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
  import _createClass from "@babel/runtime/helpers/createClass";
  import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
  import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
  import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
  import _inherits from "@babel/runtime/helpers/inherits";
  import _defineProperty from "@babel/runtime/helpers/defineProperty";
  
  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(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
  
  import PropTypes from 'prop-types';
  import * as React from 'react';
  import { polyfill } from 'react-lifecycles-compat';
  import CellMeasurerCacheDecorator from './CellMeasurerCacheDecorator';
  import Grid from '../Grid';
  var SCROLLBAR_SIZE_BUFFER = 20;
  /**
   * Renders 1, 2, or 4 Grids depending on configuration.
   * A main (body) Grid will always be rendered.
   * Optionally, 1-2 Grids for sticky header rows will also be rendered.
   * If no sticky columns, only 1 sticky header Grid will be rendered.
   * If sticky columns, 2 sticky header Grids will be rendered.
   */
  
  var MultiGrid = /*#__PURE__*/function (_React$PureComponent) {
    _inherits(MultiGrid, _React$PureComponent);
  
    function MultiGrid(props, context) {
      var _this;
  
      _classCallCheck(this, MultiGrid);
  
      _this = _possibleConstructorReturn(this, _getPrototypeOf(MultiGrid).call(this, props, context));
  
      _defineProperty(_assertThisInitialized(_this), "state", {
        scrollLeft: 0,
        scrollTop: 0,
        scrollbarSize: 0,
        showHorizontalScrollbar: false,
        showVerticalScrollbar: false
      });
  
      _defineProperty(_assertThisInitialized(_this), "_deferredInvalidateColumnIndex", null);
  
      _defineProperty(_assertThisInitialized(_this), "_deferredInvalidateRowIndex", null);
  
      _defineProperty(_assertThisInitialized(_this), "_bottomLeftGridRef", function (ref) {
        _this._bottomLeftGrid = ref;
      });
  
      _defineProperty(_assertThisInitialized(_this), "_bottomRightGridRef", function (ref) {
        _this._bottomRightGrid = ref;
      });
  
      _defineProperty(_assertThisInitialized(_this), "_cellRendererBottomLeftGrid", function (_ref) {
        var rowIndex = _ref.rowIndex,
            rest = _objectWithoutProperties(_ref, ["rowIndex"]);
  
        var _this$props = _this.props,
            cellRenderer = _this$props.cellRenderer,
            fixedRowCount = _this$props.fixedRowCount,
            rowCount = _this$props.rowCount;
  
        if (rowIndex === rowCount - fixedRowCount) {
          return React.createElement("div", {
            key: rest.key,
            style: _objectSpread({}, rest.style, {
              height: SCROLLBAR_SIZE_BUFFER
            })
          });
        } else {
          return cellRenderer(_objectSpread({}, rest, {
            parent: _assertThisInitialized(_this),
            rowIndex: rowIndex + fixedRowCount
          }));
        }
      });
  
      _defineProperty(_assertThisInitialized(_this), "_cellRendererBottomRightGrid", function (_ref2) {
        var columnIndex = _ref2.columnIndex,
            rowIndex = _ref2.rowIndex,
            rest = _objectWithoutProperties(_ref2, ["columnIndex", "rowIndex"]);
  
        var _this$props2 = _this.props,
            cellRenderer = _this$props2.cellRenderer,
            fixedColumnCount = _this$props2.fixedColumnCount,
            fixedRowCount = _this$props2.fixedRowCount;
        return cellRenderer(_objectSpread({}, rest, {
          columnIndex: columnIndex + fixedColumnCount,
          parent: _assertThisInitialized(_this),
          rowIndex: rowIndex + fixedRowCount
        }));
      });
  
      _defineProperty(_assertThisInitialized(_this), "_cellRendererTopRightGrid", function (_ref3) {
        var columnIndex = _ref3.columnIndex,
            rest = _objectWithoutProperties(_ref3, ["columnIndex"]);
  
        var _this$props3 = _this.props,
            cellRenderer = _this$props3.cellRenderer,
            columnCount = _this$props3.columnCount,
            fixedColumnCount = _this$props3.fixedColumnCount;
  
        if (columnIndex === columnCount - fixedColumnCount) {
          return React.createElement("div", {
            key: rest.key,
            style: _objectSpread({}, rest.style, {
              width: SCROLLBAR_SIZE_BUFFER
            })
          });
        } else {
          return cellRenderer(_objectSpread({}, rest, {
            columnIndex: columnIndex + fixedColumnCount,
            parent: _assertThisInitialized(_this)
          }));
        }
      });
  
      _defineProperty(_assertThisInitialized(_this), "_columnWidthRightGrid", function (_ref4) {
        var index = _ref4.index;
        var _this$props4 = _this.props,
            columnCount = _this$props4.columnCount,
            fixedColumnCount = _this$props4.fixedColumnCount,
            columnWidth = _this$props4.columnWidth;
        var _this$state = _this.state,
            scrollbarSize = _this$state.scrollbarSize,
            showHorizontalScrollbar = _this$state.showHorizontalScrollbar; // An extra cell is added to the count
        // This gives the smaller Grid extra room for offset,
        // In case the main (bottom right) Grid has a scrollbar
        // If no scrollbar, the extra space is overflow:hidden anyway
  
        if (showHorizontalScrollbar && index === columnCount - fixedColumnCount) {
          return scrollbarSize;
        }
  
        return typeof columnWidth === 'function' ? columnWidth({
          index: index + fixedColumnCount
        }) : columnWidth;
      });
  
      _defineProperty(_assertThisInitialized(_this), "_onScroll", function (scrollInfo) {
        var scrollLeft = scrollInfo.scrollLeft,
            scrollTop = scrollInfo.scrollTop;
  
        _this.setState({
          scrollLeft: scrollLeft,
          scrollTop: scrollTop
        });
  
        var onScroll = _this.props.onScroll;
  
        if (onScroll) {
          onScroll(scrollInfo);
        }
      });
  
      _defineProperty(_assertThisInitialized(_this), "_onScrollbarPresenceChange", function (_ref5) {
        var horizontal = _ref5.horizontal,
            size = _ref5.size,
            vertical = _ref5.vertical;
        var _this$state2 = _this.state,
            showHorizontalScrollbar = _this$state2.showHorizontalScrollbar,
            showVerticalScrollbar = _this$state2.showVerticalScrollbar;
  
        if (horizontal !== showHorizontalScrollbar || vertical !== showVerticalScrollbar) {
          _this.setState({
            scrollbarSize: size,
            showHorizontalScrollbar: horizontal,
            showVerticalScrollbar: vertical
          });
  
          var onScrollbarPresenceChange = _this.props.onScrollbarPresenceChange;
  
          if (typeof onScrollbarPresenceChange === 'function') {
            onScrollbarPresenceChange({
              horizontal: horizontal,
              size: size,
              vertical: vertical
            });
          }
        }
      });
  
      _defineProperty(_assertThisInitialized(_this), "_onScrollLeft", function (scrollInfo) {
        var scrollLeft = scrollInfo.scrollLeft;
  
        _this._onScroll({
          scrollLeft: scrollLeft,
          scrollTop: _this.state.scrollTop
        });
      });
  
      _defineProperty(_assertThisInitialized(_this), "_onScrollTop", function (scrollInfo) {
        var scrollTop = scrollInfo.scrollTop;
  
        _this._onScroll({
          scrollTop: scrollTop,
          scrollLeft: _this.state.scrollLeft
        });
      });
  
      _defineProperty(_assertThisInitialized(_this), "_rowHeightBottomGrid", function (_ref6) {
        var index = _ref6.index;
        var _this$props5 = _this.props,
            fixedRowCount = _this$props5.fixedRowCount,
            rowCount = _this$props5.rowCount,
            rowHeight = _this$props5.rowHeight;
        var _this$state3 = _this.state,
            scrollbarSize = _this$state3.scrollbarSize,
            showVerticalScrollbar = _this$state3.showVerticalScrollbar; // An extra cell is added to the count
        // This gives the smaller Grid extra room for offset,
        // In case the main (bottom right) Grid has a scrollbar
        // If no scrollbar, the extra space is overflow:hidden anyway
  
        if (showVerticalScrollbar && index === rowCount - fixedRowCount) {
          return scrollbarSize;
        }
  
        return typeof rowHeight === 'function' ? rowHeight({
          index: index + fixedRowCount
        }) : rowHeight;
      });
  
      _defineProperty(_assertThisInitialized(_this), "_topLeftGridRef", function (ref) {
        _this._topLeftGrid = ref;
      });
  
      _defineProperty(_assertThisInitialized(_this), "_topRightGridRef", function (ref) {
        _this._topRightGrid = ref;
      });
  
      var deferredMeasurementCache = props.deferredMeasurementCache,
          _fixedColumnCount = props.fixedColumnCount,
          _fixedRowCount = props.fixedRowCount;
  
      _this._maybeCalculateCachedStyles(true);
  
      if (deferredMeasurementCache) {
        _this._deferredMeasurementCacheBottomLeftGrid = _fixedRowCount > 0 ? new CellMeasurerCacheDecorator({
          cellMeasurerCache: deferredMeasurementCache,
          columnIndexOffset: 0,
          rowIndexOffset: _fixedRowCount
        }) : deferredMeasurementCache;
        _this._deferredMeasurementCacheBottomRightGrid = _fixedColumnCount > 0 || _fixedRowCount > 0 ? new CellMeasurerCacheDecorator({
          cellMeasurerCache: deferredMeasurementCache,
          columnIndexOffset: _fixedColumnCount,
          rowIndexOffset: _fixedRowCount
        }) : deferredMeasurementCache;
        _this._deferredMeasurementCacheTopRightGrid = _fixedColumnCount > 0 ? new CellMeasurerCacheDecorator({
          cellMeasurerCache: deferredMeasurementCache,
          columnIndexOffset: _fixedColumnCount,
          rowIndexOffset: 0
        }) : deferredMeasurementCache;
      }
  
      return _this;
    }
  
    _createClass(MultiGrid, [{
      key: "forceUpdateGrids",
      value: function forceUpdateGrids() {
        this._bottomLeftGrid && this._bottomLeftGrid.forceUpdate();
        this._bottomRightGrid && this._bottomRightGrid.forceUpdate();
        this._topLeftGrid && this._topLeftGrid.forceUpdate();
        this._topRightGrid && this._topRightGrid.forceUpdate();
      }
      /** See Grid#invalidateCellSizeAfterRender */
  
    }, {
      key: "invalidateCellSizeAfterRender",
      value: function invalidateCellSizeAfterRender() {
        var _ref7 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
            _ref7$columnIndex = _ref7.columnIndex,
            columnIndex = _ref7$columnIndex === void 0 ? 0 : _ref7$columnIndex,
            _ref7$rowIndex = _ref7.rowIndex,
            rowIndex = _ref7$rowIndex === void 0 ? 0 : _ref7$rowIndex;
  
        this._deferredInvalidateColumnIndex = typeof this._deferredInvalidateColumnIndex === 'number' ? Math.min(this._deferredInvalidateColumnIndex, columnIndex) : columnIndex;
        this._deferredInvalidateRowIndex = typeof this._deferredInvalidateRowIndex === 'number' ? Math.min(this._deferredInvalidateRowIndex, rowIndex) : rowIndex;
      }
      /** See Grid#measureAllCells */
  
    }, {
      key: "measureAllCells",
      value: function measureAllCells() {
        this._bottomLeftGrid && this._bottomLeftGrid.measureAllCells();
        this._bottomRightGrid && this._bottomRightGrid.measureAllCells();
        this._topLeftGrid && this._topLeftGrid.measureAllCells();
        this._topRightGrid && this._topRightGrid.measureAllCells();
      }
      /** See Grid#recomputeGridSize */
  
    }, {
      key: "recomputeGridSize",
      value: function recomputeGridSize() {
        var _ref8 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
            _ref8$columnIndex = _ref8.columnIndex,
            columnIndex = _ref8$columnIndex === void 0 ? 0 : _ref8$columnIndex,
            _ref8$rowIndex = _ref8.rowIndex,
            rowIndex = _ref8$rowIndex === void 0 ? 0 : _ref8$rowIndex;
  
        var _this$props6 = this.props,
            fixedColumnCount = _this$props6.fixedColumnCount,
            fixedRowCount = _this$props6.fixedRowCount;
        var adjustedColumnIndex = Math.max(0, columnIndex - fixedColumnCount);
        var adjustedRowIndex = Math.max(0, rowIndex - fixedRowCount);
        this._bottomLeftGrid && this._bottomLeftGrid.recomputeGridSize({
          columnIndex: columnIndex,
          rowIndex: adjustedRowIndex
        });
        this._bottomRightGrid && this._bottomRightGrid.recomputeGridSize({
          columnIndex: adjustedColumnIndex,
          rowIndex: adjustedRowIndex
        });
        this._topLeftGrid && this._topLeftGrid.recomputeGridSize({
          columnIndex: columnIndex,
          rowIndex: rowIndex
        });
        this._topRightGrid && this._topRightGrid.recomputeGridSize({
          columnIndex: adjustedColumnIndex,
          rowIndex: rowIndex
        });
        this._leftGridWidth = null;
        this._topGridHeight = null;
  
        this._maybeCalculateCachedStyles(true);
      }
    }, {
      key: "componentDidMount",
      value: function componentDidMount() {
        var _this$props7 = this.props,
            scrollLeft = _this$props7.scrollLeft,
            scrollTop = _this$props7.scrollTop;
  
        if (scrollLeft > 0 || scrollTop > 0) {
          var newState = {};
  
          if (scrollLeft > 0) {
            newState.scrollLeft = scrollLeft;
          }
  
          if (scrollTop > 0) {
            newState.scrollTop = scrollTop;
          }
  
          this.setState(newState);
        }
  
        this._handleInvalidatedGridSize();
      }
    }, {
      key: "componentDidUpdate",
      value: function componentDidUpdate() {
        this._handleInvalidatedGridSize();
      }
    }, {
      key: "render",
      value: function render() {
        var _this$props8 = this.props,
            onScroll = _this$props8.onScroll,
            onSectionRendered = _this$props8.onSectionRendered,
            onScrollbarPresenceChange = _this$props8.onScrollbarPresenceChange,
            scrollLeftProp = _this$props8.scrollLeft,
            scrollToColumn = _this$props8.scrollToColumn,
            scrollTopProp = _this$props8.scrollTop,
            scrollToRow = _this$props8.scrollToRow,
            rest = _objectWithoutProperties(_this$props8, ["onScroll", "onSectionRendered", "onScrollbarPresenceChange", "scrollLeft", "scrollToColumn", "scrollTop", "scrollToRow"]);
  
        this._prepareForRender(); // Don't render any of our Grids if there are no cells.
        // This mirrors what Grid does,
        // And prevents us from recording inaccurage measurements when used with CellMeasurer.
  
  
        if (this.props.width === 0 || this.props.height === 0) {
          return null;
        } // scrollTop and scrollLeft props are explicitly filtered out and ignored
  
  
        var _this$state4 = this.state,
            scrollLeft = _this$state4.scrollLeft,
            scrollTop = _this$state4.scrollTop;
        return React.createElement("div", {
          style: this._containerOuterStyle
        }, React.createElement("div", {
          style: this._containerTopStyle
        }, this._renderTopLeftGrid(rest), this._renderTopRightGrid(_objectSpread({}, rest, {
          onScroll: onScroll,
          scrollLeft: scrollLeft
        }))), React.createElement("div", {
          style: this._containerBottomStyle
        }, this._renderBottomLeftGrid(_objectSpread({}, rest, {
          onScroll: onScroll,
          scrollTop: scrollTop
        })), this._renderBottomRightGrid(_objectSpread({}, rest, {
          onScroll: onScroll,
          onSectionRendered: onSectionRendered,
          scrollLeft: scrollLeft,
          scrollToColumn: scrollToColumn,
          scrollToRow: scrollToRow,
          scrollTop: scrollTop
        }))));
      }
    }, {
      key: "_getBottomGridHeight",
      value: function _getBottomGridHeight(props) {
        var height = props.height;
  
        var topGridHeight = this._getTopGridHeight(props);
  
        return height - topGridHeight;
      }
    }, {
      key: "_getLeftGridWidth",
      value: function _getLeftGridWidth(props) {
        var fixedColumnCount = props.fixedColumnCount,
            columnWidth = props.columnWidth;
  
        if (this._leftGridWidth == null) {
          if (typeof columnWidth === 'function') {
            var leftGridWidth = 0;
  
            for (var index = 0; index < fixedColumnCount; index++) {
              leftGridWidth += columnWidth({
                index: index
              });
            }
  
            this._leftGridWidth = leftGridWidth;
          } else {
            this._leftGridWidth = columnWidth * fixedColumnCount;
          }
        }
  
        return this._leftGridWidth;
      }
    }, {
      key: "_getRightGridWidth",
      value: function _getRightGridWidth(props) {
        var width = props.width;
  
        var leftGridWidth = this._getLeftGridWidth(props);
  
        return width - leftGridWidth;
      }
    }, {
      key: "_getTopGridHeight",
      value: function _getTopGridHeight(props) {
        var fixedRowCount = props.fixedRowCount,
            rowHeight = props.rowHeight;
  
        if (this._topGridHeight == null) {
          if (typeof rowHeight === 'function') {
            var topGridHeight = 0;
  
            for (var index = 0; index < fixedRowCount; index++) {
              topGridHeight += rowHeight({
                index: index
              });
            }
  
            this._topGridHeight = topGridHeight;
          } else {
            this._topGridHeight = rowHeight * fixedRowCount;
          }
        }
  
        return this._topGridHeight;
      }
    }, {
      key: "_handleInvalidatedGridSize",
      value: function _handleInvalidatedGridSize() {
        if (typeof this._deferredInvalidateColumnIndex === 'number') {
          var columnIndex = this._deferredInvalidateColumnIndex;
          var rowIndex = this._deferredInvalidateRowIndex;
          this._deferredInvalidateColumnIndex = null;
          this._deferredInvalidateRowIndex = null;
          this.recomputeGridSize({
            columnIndex: columnIndex,
            rowIndex: rowIndex
          });
          this.forceUpdate();
        }
      }
      /**
       * Avoid recreating inline styles each render; this bypasses Grid's shallowCompare.
       * This method recalculates styles only when specific props change.
       */
  
    }, {
      key: "_maybeCalculateCachedStyles",
      value: function _maybeCalculateCachedStyles(resetAll) {
        var _this$props9 = this.props,
            columnWidth = _this$props9.columnWidth,
            enableFixedColumnScroll = _this$props9.enableFixedColumnScroll,
            enableFixedRowScroll = _this$props9.enableFixedRowScroll,
            height = _this$props9.height,
            fixedColumnCount = _this$props9.fixedColumnCount,
            fixedRowCount = _this$props9.fixedRowCount,
            rowHeight = _this$props9.rowHeight,
            style = _this$props9.style,
            styleBottomLeftGrid = _this$props9.styleBottomLeftGrid,
            styleBottomRightGrid = _this$props9.styleBottomRightGrid,
            styleTopLeftGrid = _this$props9.styleTopLeftGrid,
            styleTopRightGrid = _this$props9.styleTopRightGrid,
            width = _this$props9.width;
        var sizeChange = resetAll || height !== this._lastRenderedHeight || width !== this._lastRenderedWidth;
        var leftSizeChange = resetAll || columnWidth !== this._lastRenderedColumnWidth || fixedColumnCount !== this._lastRenderedFixedColumnCount;
        var topSizeChange = resetAll || fixedRowCount !== this._lastRenderedFixedRowCount || rowHeight !== this._lastRenderedRowHeight;
  
        if (resetAll || sizeChange || style !== this._lastRenderedStyle) {
          this._containerOuterStyle = _objectSpread({
            height: height,
            overflow: 'visible',
            // Let :focus outline show through
            width: width
          }, style);
        }
  
        if (resetAll || sizeChange || topSizeChange) {
          this._containerTopStyle = {
            height: this._getTopGridHeight(this.props),
            position: 'relative',
            width: width
          };
          this._containerBottomStyle = {
            height: height - this._getTopGridHeight(this.props),
            overflow: 'visible',
            // Let :focus outline show through
            position: 'relative',
            width: width
          };
        }
  
        if (resetAll || styleBottomLeftGrid !== this._lastRenderedStyleBottomLeftGrid) {
          this._bottomLeftGridStyle = _objectSpread({
            left: 0,
            overflowX: 'hidden',
            overflowY: enableFixedColumnScroll ? 'auto' : 'hidden',
            position: 'absolute'
          }, styleBottomLeftGrid);
        }
  
        if (resetAll || leftSizeChange || styleBottomRightGrid !== this._lastRenderedStyleBottomRightGrid) {
          this._bottomRightGridStyle = _objectSpread({
            left: this._getLeftGridWidth(this.props),
            position: 'absolute'
          }, styleBottomRightGrid);
        }
  
        if (resetAll || styleTopLeftGrid !== this._lastRenderedStyleTopLeftGrid) {
          this._topLeftGridStyle = _objectSpread({
            left: 0,
            overflowX: 'hidden',
            overflowY: 'hidden',
            position: 'absolute',
            top: 0
          }, styleTopLeftGrid);
        }
  
        if (resetAll || leftSizeChange || styleTopRightGrid !== this._lastRenderedStyleTopRightGrid) {
          this._topRightGridStyle = _objectSpread({
            left: this._getLeftGridWidth(this.props),
            overflowX: enableFixedRowScroll ? 'auto' : 'hidden',
            overflowY: 'hidden',
            position: 'absolute',
            top: 0
          }, styleTopRightGrid);
        }
  
        this._lastRenderedColumnWidth = columnWidth;
        this._lastRenderedFixedColumnCount = fixedColumnCount;
        this._lastRenderedFixedRowCount = fixedRowCount;
        this._lastRenderedHeight = height;
        this._lastRenderedRowHeight = rowHeight;
        this._lastRenderedStyle = style;
        this._lastRenderedStyleBottomLeftGrid = styleBottomLeftGrid;
        this._lastRenderedStyleBottomRightGrid = styleBottomRightGrid;
        this._lastRenderedStyleTopLeftGrid = styleTopLeftGrid;
        this._lastRenderedStyleTopRightGrid = styleTopRightGrid;
        this._lastRenderedWidth = width;
      }
    }, {
      key: "_prepareForRender",
      value: function _prepareForRender() {
        if (this._lastRenderedColumnWidth !== this.props.columnWidth || this._lastRenderedFixedColumnCount !== this.props.fixedColumnCount) {
          this._leftGridWidth = null;
        }
  
        if (this._lastRenderedFixedRowCount !== this.props.fixedRowCount || this._lastRenderedRowHeight !== this.props.rowHeight) {
          this._topGridHeight = null;
        }
  
        this._maybeCalculateCachedStyles();
  
        this._lastRenderedColumnWidth = this.props.columnWidth;
        this._lastRenderedFixedColumnCount = this.props.fixedColumnCount;
        this._lastRenderedFixedRowCount = this.props.fixedRowCount;
        this._lastRenderedRowHeight = this.props.rowHeight;
      }
    }, {
      key: "_renderBottomLeftGrid",
      value: function _renderBottomLeftGrid(props) {
        var enableFixedColumnScroll = props.enableFixedColumnScroll,
            fixedColumnCount = props.fixedColumnCount,
            fixedRowCount = props.fixedRowCount,
            rowCount = props.rowCount,
            hideBottomLeftGridScrollbar = props.hideBottomLeftGridScrollbar;
        var showVerticalScrollbar = this.state.showVerticalScrollbar;
  
        if (!fixedColumnCount) {
          return null;
        }
  
        var additionalRowCount = showVerticalScrollbar ? 1 : 0,
            height = this._getBottomGridHeight(props),
            width = this._getLeftGridWidth(props),
            scrollbarSize = this.state.showVerticalScrollbar ? this.state.scrollbarSize : 0,
            gridWidth = hideBottomLeftGridScrollbar ? width + scrollbarSize : width;
  
        var bottomLeftGrid = React.createElement(Grid, _extends({}, props, {
          cellRenderer: this._cellRendererBottomLeftGrid,
          className: this.props.classNameBottomLeftGrid,
          columnCount: fixedColumnCount,
          deferredMeasurementCache: this._deferredMeasurementCacheBottomLeftGrid,
          height: height,
          onScroll: enableFixedColumnScroll ? this._onScrollTop : undefined,
          ref: this._bottomLeftGridRef,
          rowCount: Math.max(0, rowCount - fixedRowCount) + additionalRowCount,
          rowHeight: this._rowHeightBottomGrid,
          style: this._bottomLeftGridStyle,
          tabIndex: null,
          width: gridWidth
        }));
  
        if (hideBottomLeftGridScrollbar) {
          return React.createElement("div", {
            className: "BottomLeftGrid_ScrollWrapper",
            style: _objectSpread({}, this._bottomLeftGridStyle, {
              height: height,
              width: width,
              overflowY: 'hidden'
            })
          }, bottomLeftGrid);
        }
  
        return bottomLeftGrid;
      }
    }, {
      key: "_renderBottomRightGrid",
      value: function _renderBottomRightGrid(props) {
        var columnCount = props.columnCount,
            fixedColumnCount = props.fixedColumnCount,
            fixedRowCount = props.fixedRowCount,
            rowCount = props.rowCount,
            scrollToColumn = props.scrollToColumn,
            scrollToRow = props.scrollToRow;
        return React.createElement(Grid, _extends({}, props, {
          cellRenderer: this._cellRendererBottomRightGrid,
          className: this.props.classNameBottomRightGrid,
          columnCount: Math.max(0, columnCount - fixedColumnCount),
          columnWidth: this._columnWidthRightGrid,
          deferredMeasurementCache: this._deferredMeasurementCacheBottomRightGrid,
          height: this._getBottomGridHeight(props),
          onScroll: this._onScroll,
          onScrollbarPresenceChange: this._onScrollbarPresenceChange,
          ref: this._bottomRightGridRef,
          rowCount: Math.max(0, rowCount - fixedRowCount),
          rowHeight: this._rowHeightBottomGrid,
          scrollToColumn: scrollToColumn - fixedColumnCount,
          scrollToRow: scrollToRow - fixedRowCount,
          style: this._bottomRightGridStyle,
          width: this._getRightGridWidth(props)
        }));
      }
    }, {
      key: "_renderTopLeftGrid",
      value: function _renderTopLeftGrid(props) {
        var fixedColumnCount = props.fixedColumnCount,
            fixedRowCount = props.fixedRowCount;
  
        if (!fixedColumnCount || !fixedRowCount) {
          return null;
        }
  
        return React.createElement(Grid, _extends({}, props, {
          className: this.props.classNameTopLeftGrid,
          columnCount: fixedColumnCount,
          height: this._getTopGridHeight(props),
          ref: this._topLeftGridRef,
          rowCount: fixedRowCount,
          style: this._topLeftGridStyle,
          tabIndex: null,
          width: this._getLeftGridWidth(props)
        }));
      }
    }, {
      key: "_renderTopRightGrid",
      value: function _renderTopRightGrid(props) {
        var columnCount = props.columnCount,
            enableFixedRowScroll = props.enableFixedRowScroll,
            fixedColumnCount = props.fixedColumnCount,
            fixedRowCount = props.fixedRowCount,
            scrollLeft = props.scrollLeft,
            hideTopRightGridScrollbar = props.hideTopRightGridScrollbar;
        var _this$state5 = this.state,
            showHorizontalScrollbar = _this$state5.showHorizontalScrollbar,
            scrollbarSize = _this$state5.scrollbarSize;
  
        if (!fixedRowCount) {
          return null;
        }
  
        var additionalColumnCount = showHorizontalScrollbar ? 1 : 0,
            height = this._getTopGridHeight(props),
            width = this._getRightGridWidth(props),
            additionalHeight = showHorizontalScrollbar ? scrollbarSize : 0;
  
        var gridHeight = height,
            style = this._topRightGridStyle;
  
        if (hideTopRightGridScrollbar) {
          gridHeight = height + additionalHeight;
          style = _objectSpread({}, this._topRightGridStyle, {
            left: 0
          });
        }
  
        var topRightGrid = React.createElement(Grid, _extends({}, props, {
          cellRenderer: this._cellRendererTopRightGrid,
          className: this.props.classNameTopRightGrid,
          columnCount: Math.max(0, columnCount - fixedColumnCount) + additionalColumnCount,
          columnWidth: this._columnWidthRightGrid,
          deferredMeasurementCache: this._deferredMeasurementCacheTopRightGrid,
          height: gridHeight,
          onScroll: enableFixedRowScroll ? this._onScrollLeft : undefined,
          ref: this._topRightGridRef,
          rowCount: fixedRowCount,
          scrollLeft: scrollLeft,
          style: style,
          tabIndex: null,
          width: width
        }));
  
        if (hideTopRightGridScrollbar) {
          return React.createElement("div", {
            className: "TopRightGrid_ScrollWrapper",
            style: _objectSpread({}, this._topRightGridStyle, {
              height: height,
              width: width,
              overflowX: 'hidden'
            })
          }, topRightGrid);
        }
  
        return topRightGrid;
      }
    }], [{
      key: "getDerivedStateFromProps",
      value: function getDerivedStateFromProps(nextProps, prevState) {
        if (nextProps.scrollLeft !== prevState.scrollLeft || nextProps.scrollTop !== prevState.scrollTop) {
          return {
            scrollLeft: nextProps.scrollLeft != null && nextProps.scrollLeft >= 0 ? nextProps.scrollLeft : prevState.scrollLeft,
            scrollTop: nextProps.scrollTop != null && nextProps.scrollTop >= 0 ? nextProps.scrollTop : prevState.scrollTop
          };
        }
  
        return null;
      }
    }]);
  
    return MultiGrid;
  }(React.PureComponent);
  
  _defineProperty(MultiGrid, "defaultProps", {
    classNameBottomLeftGrid: '',
    classNameBottomRightGrid: '',
    classNameTopLeftGrid: '',
    classNameTopRightGrid: '',
    enableFixedColumnScroll: false,
    enableFixedRowScroll: false,
    fixedColumnCount: 0,
    fixedRowCount: 0,
    scrollToColumn: -1,
    scrollToRow: -1,
    style: {},
    styleBottomLeftGrid: {},
    styleBottomRightGrid: {},
    styleTopLeftGrid: {},
    styleTopRightGrid: {},
    hideTopRightGridScrollbar: false,
    hideBottomLeftGridScrollbar: false
  });
  
  MultiGrid.propTypes = process.env.NODE_ENV !== "production" ? {
    classNameBottomLeftGrid: PropTypes.string.isRequired,
    classNameBottomRightGrid: PropTypes.string.isRequired,
    classNameTopLeftGrid: PropTypes.string.isRequired,
    classNameTopRightGrid: PropTypes.string.isRequired,
    enableFixedColumnScroll: PropTypes.bool.isRequired,
    enableFixedRowScroll: PropTypes.bool.isRequired,
    fixedColumnCount: PropTypes.number.isRequired,
    fixedRowCount: PropTypes.number.isRequired,
    onScrollbarPresenceChange: PropTypes.func,
    style: PropTypes.object.isRequired,
    styleBottomLeftGrid: PropTypes.object.isRequired,
    styleBottomRightGrid: PropTypes.object.isRequired,
    styleTopLeftGrid: PropTypes.object.isRequired,
    styleTopRightGrid: PropTypes.object.isRequired,
    hideTopRightGridScrollbar: PropTypes.bool,
    hideBottomLeftGridScrollbar: PropTypes.bool
  } : {};
  polyfill(MultiGrid);
  export default MultiGrid;