@depup/react-virtualized 9.22.6-depup.0

package/dist/es/Masonry/Masonry.js

@@ -0,0 +1,421 @@
+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 _inherits from "@babel/runtime/helpers/inherits";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+import clsx from 'clsx';
+import * as React from 'react';
+import { polyfill } from 'react-lifecycles-compat';
+import PositionCache from './PositionCache';
+import { requestAnimationTimeout, cancelAnimationTimeout } from '../utils/requestAnimationTimeout';
+/*:: import type {AnimationTimeoutId} from '../utils/requestAnimationTimeout';*/
+/*:: type Props = {
+  autoHeight: boolean,
+  cellCount: number,
+  cellMeasurerCache: CellMeasurerCache,
+  cellPositioner: Positioner,
+  cellRenderer: CellRenderer,
+  className: ?string,
+  height: number,
+  id: ?string,
+  keyMapper: KeyMapper,
+  onCellsRendered: ?OnCellsRenderedCallback,
+  onScroll: ?OnScrollCallback,
+  overscanByPixels: number,
+  role: string,
+  scrollingResetTimeInterval: number,
+  style: mixed,
+  tabIndex: number,
+  width: number,
+  rowDirection: string,
+  scrollTop?: number,
+};*/
+/*:: type State = {
+  isScrolling: boolean,
+  scrollTop: number,
+};*/
+var emptyObject = {};
+
+/**
+ * Specifies the number of milliseconds during which to disable pointer events while a scroll is in progress.
+ * This improves performance and makes scrolling smoother.
+ */
+export var DEFAULT_SCROLLING_RESET_TIME_INTERVAL = 150;
+
+/**
+ * This component efficiently displays arbitrarily positioned cells using windowing techniques.
+ * Cell position is determined by an injected `cellPositioner` property.
+ * Windowing is vertical; this component does not support horizontal scrolling.
+ *
+ * Rendering occurs in two phases:
+ * 1) First pass uses estimated cell sizes (provided by the cache) to determine how many cells to measure in a batch.
+ *    Batch size is chosen using a fast, naive layout algorithm that stacks images in order until the viewport has been filled.
+ *    After measurement is complete (componentDidMount or componentDidUpdate) this component evaluates positioned cells
+ *    in order to determine if another measurement pass is required (eg if actual cell sizes were less than estimated sizes).
+ *    All measurements are permanently cached (keyed by `keyMapper`) for performance purposes.
+ * 2) Second pass uses the external `cellPositioner` to layout cells.
+ *    At this time the positioner has access to cached size measurements for all cells.
+ *    The positions it returns are cached by Masonry for fast access later.
+ *    Phase one is repeated if the user scrolls beyond the current layout's bounds.
+ *    If the layout is invalidated due to eg a resize, cached positions can be cleared using `recomputeCellPositions()`.
+ *
+ * Animation constraints:
+ *   Simple animations are supported (eg translate/slide into place on initial reveal).
+ *   More complex animations are not (eg flying from one position to another on resize).
+ *
+ * Layout constraints:
+ *   This component supports multi-column layout.
+ *   The height of each item may vary.
+ *   The width of each item must not exceed the width of the column it is "in".
+ *   The left position of all items within a column must align.
+ *   (Items may not span multiple columns.)
+ */
+var Masonry = /*#__PURE__*/function (_React$PureComponent) {
+  function Masonry() {
+    var _this;
+    _classCallCheck(this, Masonry);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _callSuper(this, Masonry, [].concat(args));
+    _defineProperty(_this, "state", {
+      isScrolling: false,
+      scrollTop: 0
+    });
+    _defineProperty(_this, "_debounceResetIsScrollingId", void 0);
+    _defineProperty(_this, "_invalidateOnUpdateStartIndex", null);
+    _defineProperty(_this, "_invalidateOnUpdateStopIndex", null);
+    _defineProperty(_this, "_positionCache", new PositionCache());
+    _defineProperty(_this, "_startIndex", null);
+    _defineProperty(_this, "_startIndexMemoized", null);
+    _defineProperty(_this, "_stopIndex", null);
+    _defineProperty(_this, "_stopIndexMemoized", null);
+    _defineProperty(_this, "_debounceResetIsScrollingCallback", function () {
+      _this.setState({
+        isScrolling: false
+      });
+    });
+    _defineProperty(_this, "_setScrollingContainerRef", function (ref) {
+      _this._scrollingContainer = ref;
+    });
+    _defineProperty(_this, "_onScroll", function (event) {
+      var height = _this.props.height;
+      var eventScrollTop = event.currentTarget.scrollTop;
+
+      // When this component is shrunk drastically, React dispatches a series of back-to-back scroll events,
+      // Gradually converging on a scrollTop that is within the bounds of the new, smaller height.
+      // This causes a series of rapid renders that is slow for long lists.
+      // We can avoid that by doing some simple bounds checking to ensure that scroll offsets never exceed their bounds.
+      var scrollTop = Math.min(Math.max(0, _this._getEstimatedTotalHeight() - height), eventScrollTop);
+
+      // On iOS, we can arrive at negative offsets by swiping past the start or end.
+      // Avoid re-rendering in this case as it can cause problems; see #532 for more.
+      if (eventScrollTop !== scrollTop) {
+        return;
+      }
+
+      // Prevent pointer events from interrupting a smooth scroll
+      _this._debounceResetIsScrolling();
+
+      // Certain devices (like Apple touchpad) rapid-fire duplicate events.
+      // Don't force a re-render if this is the case.
+      // The mouse may move faster then the animation frame does.
+      // Use requestAnimationFrame to avoid over-updating.
+      if (_this.state.scrollTop !== scrollTop) {
+        _this.setState({
+          isScrolling: true,
+          scrollTop: scrollTop
+        });
+      }
+    });
+    return _this;
+  }
+  _inherits(Masonry, _React$PureComponent);
+  return _createClass(Masonry, [{
+    key: "clearCellPositions",
+    value: function clearCellPositions() {
+      this._positionCache = new PositionCache();
+      this.forceUpdate();
+    }
+
+    // HACK This method signature was intended for Grid
+  }, {
+    key: "invalidateCellSizeAfterRender",
+    value: function invalidateCellSizeAfterRender(_ref) {
+      var index = _ref.rowIndex;
+      if (this._invalidateOnUpdateStartIndex === null) {
+        this._invalidateOnUpdateStartIndex = index;
+        this._invalidateOnUpdateStopIndex = index;
+      } else {
+        this._invalidateOnUpdateStartIndex = Math.min(this._invalidateOnUpdateStartIndex, index);
+        this._invalidateOnUpdateStopIndex = Math.max(this._invalidateOnUpdateStopIndex, index);
+      }
+    }
+  }, {
+    key: "recomputeCellPositions",
+    value: function recomputeCellPositions() {
+      var stopIndex = this._positionCache.count - 1;
+      this._positionCache = new PositionCache();
+      this._populatePositionCache(0, stopIndex);
+      this.forceUpdate();
+    }
+  }, {
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this._checkInvalidateOnUpdate();
+      this._invokeOnScrollCallback();
+      this._invokeOnCellsRenderedCallback();
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps /*: Props*/, prevState /*: State*/) {
+      this._checkInvalidateOnUpdate();
+      this._invokeOnScrollCallback();
+      this._invokeOnCellsRenderedCallback();
+      if (this.props.scrollTop !== prevProps.scrollTop) {
+        this._debounceResetIsScrolling();
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      if (this._debounceResetIsScrollingId) {
+        cancelAnimationTimeout(this._debounceResetIsScrollingId);
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+      var _this$props = this.props,
+        autoHeight = _this$props.autoHeight,
+        cellCount = _this$props.cellCount,
+        cellMeasurerCache = _this$props.cellMeasurerCache,
+        cellRenderer = _this$props.cellRenderer,
+        className = _this$props.className,
+        height = _this$props.height,
+        id = _this$props.id,
+        keyMapper = _this$props.keyMapper,
+        overscanByPixels = _this$props.overscanByPixels,
+        role = _this$props.role,
+        style = _this$props.style,
+        tabIndex = _this$props.tabIndex,
+        width = _this$props.width,
+        rowDirection = _this$props.rowDirection;
+      var _this$state = this.state,
+        isScrolling = _this$state.isScrolling,
+        scrollTop = _this$state.scrollTop;
+      var children = [];
+      var estimateTotalHeight = this._getEstimatedTotalHeight();
+      var shortestColumnSize = this._positionCache.shortestColumnSize;
+      var measuredCellCount = this._positionCache.count;
+      var startIndex = 0;
+      var stopIndex;
+      this._positionCache.range(Math.max(0, scrollTop - overscanByPixels), height + overscanByPixels * 2, function (index /*: number*/, left /*: number*/, top /*: number*/) {
+        if (typeof stopIndex === 'undefined') {
+          startIndex = index;
+          stopIndex = index;
+        } else {
+          startIndex = Math.min(startIndex, index);
+          stopIndex = Math.max(stopIndex, index);
+        }
+        children.push(cellRenderer({
+          index: index,
+          isScrolling: isScrolling,
+          key: keyMapper(index),
+          parent: _this2,
+          style: _defineProperty(_defineProperty(_defineProperty(_defineProperty({
+            height: cellMeasurerCache.getHeight(index)
+          }, rowDirection === 'ltr' ? 'left' : 'right', left), "position", 'absolute'), "top", top), "width", cellMeasurerCache.getWidth(index))
+        }));
+      });
+
+      // We need to measure additional cells for this layout
+      if (shortestColumnSize < scrollTop + height + overscanByPixels && measuredCellCount < cellCount) {
+        var batchSize = Math.min(cellCount - measuredCellCount, Math.ceil((scrollTop + height + overscanByPixels - shortestColumnSize) / cellMeasurerCache.defaultHeight * width / cellMeasurerCache.defaultWidth));
+        for (var _index = measuredCellCount; _index < measuredCellCount + batchSize; _index++) {
+          stopIndex = _index;
+          children.push(cellRenderer({
+            index: _index,
+            isScrolling: isScrolling,
+            key: keyMapper(_index),
+            parent: this,
+            style: {
+              width: cellMeasurerCache.getWidth(_index)
+            }
+          }));
+        }
+      }
+      this._startIndex = startIndex;
+      this._stopIndex = stopIndex;
+      return /*#__PURE__*/React.createElement("div", {
+        ref: this._setScrollingContainerRef,
+        "aria-label": this.props['aria-label'],
+        className: clsx('ReactVirtualized__Masonry', className),
+        id: id,
+        onScroll: this._onScroll,
+        role: role,
+        style: _objectSpread({
+          boxSizing: 'border-box',
+          direction: 'ltr',
+          height: autoHeight ? 'auto' : height,
+          overflowX: 'hidden',
+          overflowY: estimateTotalHeight < height ? 'hidden' : 'auto',
+          position: 'relative',
+          width: width,
+          WebkitOverflowScrolling: 'touch',
+          willChange: 'transform'
+        }, style),
+        tabIndex: tabIndex
+      }, /*#__PURE__*/React.createElement("div", {
+        className: "ReactVirtualized__Masonry__innerScrollContainer",
+        style: {
+          width: '100%',
+          height: estimateTotalHeight,
+          maxWidth: '100%',
+          maxHeight: estimateTotalHeight,
+          overflow: 'hidden',
+          pointerEvents: isScrolling ? 'none' : '',
+          position: 'relative'
+        }
+      }, children));
+    }
+  }, {
+    key: "_checkInvalidateOnUpdate",
+    value: function _checkInvalidateOnUpdate() {
+      if (typeof this._invalidateOnUpdateStartIndex === 'number') {
+        var startIndex = this._invalidateOnUpdateStartIndex;
+        var stopIndex = this._invalidateOnUpdateStopIndex;
+        this._invalidateOnUpdateStartIndex = null;
+        this._invalidateOnUpdateStopIndex = null;
+
+        // Query external layout logic for position of newly-measured cells
+        this._populatePositionCache(startIndex, stopIndex);
+        this.forceUpdate();
+      }
+    }
+  }, {
+    key: "_debounceResetIsScrolling",
+    value: function _debounceResetIsScrolling() {
+      var scrollingResetTimeInterval = this.props.scrollingResetTimeInterval;
+      if (this._debounceResetIsScrollingId) {
+        cancelAnimationTimeout(this._debounceResetIsScrollingId);
+      }
+      this._debounceResetIsScrollingId = requestAnimationTimeout(this._debounceResetIsScrollingCallback, scrollingResetTimeInterval);
+    }
+  }, {
+    key: "_getEstimatedTotalHeight",
+    value: function _getEstimatedTotalHeight() {
+      var _this$props2 = this.props,
+        cellCount = _this$props2.cellCount,
+        cellMeasurerCache = _this$props2.cellMeasurerCache,
+        width = _this$props2.width;
+      var estimatedColumnCount = Math.max(1, Math.floor(width / cellMeasurerCache.defaultWidth));
+      return this._positionCache.estimateTotalHeight(cellCount, estimatedColumnCount, cellMeasurerCache.defaultHeight);
+    }
+  }, {
+    key: "_invokeOnScrollCallback",
+    value: function _invokeOnScrollCallback() {
+      var _this$props3 = this.props,
+        height = _this$props3.height,
+        onScroll = _this$props3.onScroll;
+      var scrollTop = this.state.scrollTop;
+      if (this._onScrollMemoized !== scrollTop) {
+        onScroll({
+          clientHeight: height,
+          scrollHeight: this._getEstimatedTotalHeight(),
+          scrollTop: scrollTop
+        });
+        this._onScrollMemoized = scrollTop;
+      }
+    }
+  }, {
+    key: "_invokeOnCellsRenderedCallback",
+    value: function _invokeOnCellsRenderedCallback() {
+      if (this._startIndexMemoized !== this._startIndex || this._stopIndexMemoized !== this._stopIndex) {
+        var onCellsRendered = this.props.onCellsRendered;
+        onCellsRendered({
+          startIndex: this._startIndex,
+          stopIndex: this._stopIndex
+        });
+        this._startIndexMemoized = this._startIndex;
+        this._stopIndexMemoized = this._stopIndex;
+      }
+    }
+  }, {
+    key: "_populatePositionCache",
+    value: function _populatePositionCache(startIndex /*: number*/, stopIndex /*: number*/) {
+      var _this$props4 = this.props,
+        cellMeasurerCache = _this$props4.cellMeasurerCache,
+        cellPositioner = _this$props4.cellPositioner;
+      for (var _index2 = startIndex; _index2 <= stopIndex; _index2++) {
+        var _cellPositioner = cellPositioner(_index2),
+          left = _cellPositioner.left,
+          top = _cellPositioner.top;
+        this._positionCache.setPosition(_index2, left, top, cellMeasurerCache.getHeight(_index2));
+      }
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(nextProps /*: Props*/, prevState /*: State*/) /*: $Shape<State>*/{
+      if (nextProps.scrollTop !== undefined && prevState.scrollTop !== nextProps.scrollTop) {
+        return {
+          isScrolling: true,
+          scrollTop: nextProps.scrollTop
+        };
+      }
+      return null;
+    }
+  }]);
+}(React.PureComponent);
+_defineProperty(Masonry, "defaultProps", {
+  autoHeight: false,
+  keyMapper: identity,
+  onCellsRendered: noop,
+  onScroll: noop,
+  overscanByPixels: 20,
+  role: 'grid',
+  scrollingResetTimeInterval: DEFAULT_SCROLLING_RESET_TIME_INTERVAL,
+  style: emptyObject,
+  tabIndex: 0,
+  rowDirection: 'ltr'
+});
+function identity(value) {
+  return value;
+}
+function noop() {}
+/*:: type KeyMapper = (index: number) => mixed;*/
+/*:: export type CellMeasurerCache = {
+  defaultHeight: number,
+  defaultWidth: number,
+  getHeight: (index: number) => number,
+  getWidth: (index: number) => number,
+};*/
+/*:: type CellRenderer = (params: {|
+  index: number,
+  isScrolling: boolean,
+  key: mixed,
+  parent: mixed,
+  style: mixed,
+|}) => mixed;*/
+/*:: type OnCellsRenderedCallback = (params: {|
+  startIndex: number,
+  stopIndex: number,
+|}) => void;*/
+/*:: type OnScrollCallback = (params: {|
+  clientHeight: number,
+  scrollHeight: number,
+  scrollTop: number,
+|}) => void;*/
+/*:: type Position = {
+  left: number,
+  top: number,
+};*/
+polyfill(Masonry);
+export default Masonry;
+/*:: export type Positioner = (index: number) => Position;*/

package/dist/es/Masonry/PositionCache.js

@@ -0,0 +1,82 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import createIntervalTree from '../vendor/intervalTree';
+/*:: type RenderCallback = (index: number, left: number, top: number) => void;*/
+// Position cache requirements:
+//   O(log(n)) lookup of cells to render for a given viewport size
+//   O(1) lookup of shortest measured column (so we know when to enter phase 1)
+var PositionCache = /*#__PURE__*/function () {
+  function PositionCache() {
+    _classCallCheck(this, PositionCache);
+    // Tracks the height of each column
+    _defineProperty(this, "_columnSizeMap", {});
+    // Store tops and bottoms of each cell for fast intersection lookup.
+    _defineProperty(this, "_intervalTree", createIntervalTree());
+    // Maps cell index to x coordinates for quick lookup.
+    _defineProperty(this, "_leftMap", {});
+  }
+  return _createClass(PositionCache, [{
+    key: "estimateTotalHeight",
+    value: function estimateTotalHeight(cellCount /*: number*/, columnCount /*: number*/, defaultCellHeight /*: number*/) /*: number*/{
+      var unmeasuredCellCount = cellCount - this.count;
+      return this.tallestColumnSize + Math.ceil(unmeasuredCellCount / columnCount) * defaultCellHeight;
+    }
+
+    // Render all cells visible within the viewport range defined.
+  }, {
+    key: "range",
+    value: function range(scrollTop /*: number*/, clientHeight /*: number*/, renderCallback /*: RenderCallback*/) /*: void*/{
+      var _this = this;
+      this._intervalTree.queryInterval(scrollTop, scrollTop + clientHeight, function (_ref) {
+        var _ref2 = _slicedToArray(_ref, 3),
+          top = _ref2[0],
+          _ = _ref2[1],
+          index = _ref2[2];
+        return renderCallback(index, _this._leftMap[index], top);
+      });
+    }
+  }, {
+    key: "setPosition",
+    value: function setPosition(index /*: number*/, left /*: number*/, top /*: number*/, height /*: number*/) /*: void*/{
+      this._intervalTree.insert([top, top + height, index]);
+      this._leftMap[index] = left;
+      var columnSizeMap = this._columnSizeMap;
+      var columnHeight = columnSizeMap[left];
+      if (columnHeight === undefined) {
+        columnSizeMap[left] = top + height;
+      } else {
+        columnSizeMap[left] = Math.max(columnHeight, top + height);
+      }
+    }
+  }, {
+    key: "count",
+    get: function get() /*: number*/{
+      return this._intervalTree.count;
+    }
+  }, {
+    key: "shortestColumnSize",
+    get: function get() /*: number*/{
+      var columnSizeMap = this._columnSizeMap;
+      var size = 0;
+      for (var i in columnSizeMap) {
+        var height = columnSizeMap[(i /*: any*/)];
+        size = size === 0 ? height : Math.min(size, height);
+      }
+      return size;
+    }
+  }, {
+    key: "tallestColumnSize",
+    get: function get() /*: number*/{
+      var columnSizeMap = this._columnSizeMap;
+      var size = 0;
+      for (var i in columnSizeMap) {
+        var height = columnSizeMap[(i /*: any*/)];
+        size = Math.max(size, height);
+      }
+      return size;
+    }
+  }]);
+}();
+export { PositionCache as default };

package/dist/es/Masonry/createCellPositioner.js

@@ -0,0 +1,53 @@
+/*:: import type {CellMeasurerCache, Positioner} from './Masonry';*/
+/*:: type createCellPositionerParams = {
+  cellMeasurerCache: CellMeasurerCache,
+  columnCount: number,
+  columnWidth: number,
+  spacer?: number,
+};*/
+/*:: type resetParams = {
+  columnCount: number,
+  columnWidth: number,
+  spacer?: number,
+};*/
+export default function createCellPositioner(_ref /*:: */) /*: Positioner*/{
+  var cellMeasurerCache = _ref /*:: */.cellMeasurerCache,
+    columnCount = _ref /*:: */.columnCount,
+    columnWidth = _ref /*:: */.columnWidth,
+    _ref$spacer = _ref /*:: */.spacer,
+    spacer = _ref$spacer === void 0 ? 0 : _ref$spacer;
+  var columnHeights;
+  initOrResetDerivedValues();
+  function cellPositioner(index) {
+    // Find the shortest column and use it.
+    var columnIndex = 0;
+    for (var i = 1; i < columnHeights.length; i++) {
+      if (columnHeights[i] < columnHeights[columnIndex]) {
+        columnIndex = i;
+      }
+    }
+    var left = columnIndex * (columnWidth + spacer);
+    var top = columnHeights[columnIndex] || 0;
+    columnHeights[columnIndex] = top + cellMeasurerCache.getHeight(index) + spacer;
+    return {
+      left: left,
+      top: top
+    };
+  }
+  function initOrResetDerivedValues() /*: void*/{
+    // Track the height of each column.
+    // Layout algorithm below always inserts into the shortest column.
+    columnHeights = [];
+    for (var i = 0; i < columnCount; i++) {
+      columnHeights[i] = 0;
+    }
+  }
+  function reset(params /*: resetParams*/) /*: void*/{
+    columnCount = params.columnCount;
+    columnWidth = params.columnWidth;
+    spacer = params.spacer;
+    initOrResetDerivedValues();
+  }
+  cellPositioner.reset = reset;
+  return cellPositioner;
+}

package/dist/es/Masonry/index.js

@@ -0,0 +1,4 @@
+import createCellPositioner from './createCellPositioner';
+import Masonry from './Masonry';
+export default Masonry;
+export { createCellPositioner, Masonry };

package/dist/es/MultiGrid/CellMeasurerCacheDecorator.js

@@ -0,0 +1,100 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { CellMeasurerCache } from '../CellMeasurer';
+/*:: type CellMeasurerCacheDecoratorParams = {
+  cellMeasurerCache: CellMeasurerCache,
+  columnIndexOffset: number,
+  rowIndexOffset: number,
+};*/
+/*:: type IndexParam = {
+  index: number,
+};*/
+/**
+ * Caches measurements for a given cell.
+ */
+var CellMeasurerCacheDecorator = /*#__PURE__*/function () {
+  function CellMeasurerCacheDecorator() {
+    var _this = this;
+    var params /*: CellMeasurerCacheDecoratorParams*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _classCallCheck(this, CellMeasurerCacheDecorator);
+    _defineProperty(this, "_cellMeasurerCache", void 0);
+    _defineProperty(this, "_columnIndexOffset", void 0);
+    _defineProperty(this, "_rowIndexOffset", void 0);
+    _defineProperty(this, "columnWidth", function (_ref /*:: */) {
+      var index = _ref /*:: */.index;
+      _this._cellMeasurerCache.columnWidth({
+        index: index + _this._columnIndexOffset
+      });
+    });
+    _defineProperty(this, "rowHeight", function (_ref2 /*:: */) {
+      var index = _ref2 /*:: */.index;
+      _this._cellMeasurerCache.rowHeight({
+        index: index + _this._rowIndexOffset
+      });
+    });
+    var cellMeasurerCache = params.cellMeasurerCache,
+      _params$columnIndexOf = params.columnIndexOffset,
+      columnIndexOffset = _params$columnIndexOf === void 0 ? 0 : _params$columnIndexOf,
+      _params$rowIndexOffse = params.rowIndexOffset,
+      rowIndexOffset = _params$rowIndexOffse === void 0 ? 0 : _params$rowIndexOffse;
+    this._cellMeasurerCache = cellMeasurerCache;
+    this._columnIndexOffset = columnIndexOffset;
+    this._rowIndexOffset = rowIndexOffset;
+  }
+  return _createClass(CellMeasurerCacheDecorator, [{
+    key: "clear",
+    value: function clear(rowIndex /*: number*/, columnIndex /*: number*/) /*: void*/{
+      this._cellMeasurerCache.clear(rowIndex + this._rowIndexOffset, columnIndex + this._columnIndexOffset);
+    }
+  }, {
+    key: "clearAll",
+    value: function clearAll() /*: void*/{
+      this._cellMeasurerCache.clearAll();
+    }
+  }, {
+    key: "defaultHeight",
+    get: function get() /*: number*/{
+      return this._cellMeasurerCache.defaultHeight;
+    }
+  }, {
+    key: "defaultWidth",
+    get: function get() /*: number*/{
+      return this._cellMeasurerCache.defaultWidth;
+    }
+  }, {
+    key: "hasFixedHeight",
+    value: function hasFixedHeight() /*: boolean*/{
+      return this._cellMeasurerCache.hasFixedHeight();
+    }
+  }, {
+    key: "hasFixedWidth",
+    value: function hasFixedWidth() /*: boolean*/{
+      return this._cellMeasurerCache.hasFixedWidth();
+    }
+  }, {
+    key: "getHeight",
+    value: function getHeight(rowIndex /*: number*/) /*: ?number*/{
+      var columnIndex /*: ?number*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      return this._cellMeasurerCache.getHeight(rowIndex + this._rowIndexOffset, columnIndex + this._columnIndexOffset);
+    }
+  }, {
+    key: "getWidth",
+    value: function getWidth(rowIndex /*: number*/) /*: ?number*/{
+      var columnIndex /*: ?number*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      return this._cellMeasurerCache.getWidth(rowIndex + this._rowIndexOffset, columnIndex + this._columnIndexOffset);
+    }
+  }, {
+    key: "has",
+    value: function has(rowIndex /*: number*/) /*: boolean*/{
+      var columnIndex /*: ?number*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      return this._cellMeasurerCache.has(rowIndex + this._rowIndexOffset, columnIndex + this._columnIndexOffset);
+    }
+  }, {
+    key: "set",
+    value: function set(rowIndex /*: number*/, columnIndex /*: number*/, width /*: number*/, height /*: number*/) /*: void*/{
+      this._cellMeasurerCache.set(rowIndex + this._rowIndexOffset, columnIndex + this._columnIndexOffset, (width /*: number*/), (height /*: number*/));
+    }
+  }]);
+}();
+export { CellMeasurerCacheDecorator as default };