@depup/react-virtualized 9.22.6-depup.0

package/dist/commonjs/CellMeasurer/CellMeasurer.js

@@ -0,0 +1,195 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _react = _interopRequireWildcard(require("react"));
+var React = _react;
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(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 type {CellMeasureCache} from './types';*/
+/*:: type Children = (params: {measure: () => void}) => React.Element<*>;*/
+/*:: type Cell = {
+  columnIndex: number,
+  rowIndex: number,
+};*/
+/*:: type Props = {
+  cache: CellMeasureCache,
+  children: Children | React.Element<*>,
+  columnIndex?: number,
+  index?: number,
+  parent: {
+    invalidateCellSizeAfterRender?: (cell: Cell) => void,
+    recomputeGridSize?: (cell: Cell) => void,
+  },
+  rowIndex?: number,
+};*/
+/**
+ * Wraps a cell and measures its rendered content.
+ * Measurements are stored in a per-cell cache.
+ * Cached-content is not be re-measured.
+ */
+var CellMeasurer = exports["default"] = /*#__PURE__*/function (_React$PureComponent) {
+  function CellMeasurer() {
+    var _this;
+    (0, _classCallCheck2["default"])(this, CellMeasurer);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _callSuper(this, CellMeasurer, [].concat(args));
+    (0, _defineProperty2["default"])(_this, "_child", /*#__PURE__*/React.createRef());
+    (0, _defineProperty2["default"])(_this, "_measure", function () {
+      var _this$props = _this.props,
+        cache = _this$props.cache,
+        _this$props$columnInd = _this$props.columnIndex,
+        columnIndex = _this$props$columnInd === void 0 ? 0 : _this$props$columnInd,
+        parent = _this$props.parent,
+        _this$props$rowIndex = _this$props.rowIndex,
+        rowIndex = _this$props$rowIndex === void 0 ? _this.props.index || 0 : _this$props$rowIndex;
+      var _this$_getCellMeasure = _this._getCellMeasurements(),
+        height = _this$_getCellMeasure.height,
+        width = _this$_getCellMeasure.width;
+      if (height !== cache.getHeight(rowIndex, columnIndex) || width !== cache.getWidth(rowIndex, columnIndex)) {
+        cache.set(rowIndex, columnIndex, width, height);
+        if (parent && typeof parent.recomputeGridSize === 'function') {
+          parent.recomputeGridSize({
+            columnIndex: columnIndex,
+            rowIndex: rowIndex
+          });
+        }
+      }
+    });
+    (0, _defineProperty2["default"])(_this, "_registerChild", function (element) {
+      if (element && !(element instanceof Element)) {
+        console.warn('CellMeasurer registerChild expects to be passed Element or null');
+      }
+      _this._child.current = element;
+      if (element) {
+        _this._maybeMeasureCell();
+      }
+    });
+    return _this;
+  }
+  (0, _inherits2["default"])(CellMeasurer, _React$PureComponent);
+  return (0, _createClass2["default"])(CellMeasurer, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this._maybeMeasureCell();
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate() {
+      this._maybeMeasureCell();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+      var children = this.props.children;
+      var resolvedChildren = typeof children === 'function' ? children({
+        measure: this._measure,
+        registerChild: this._registerChild
+      }) : children;
+      if (resolvedChildren === null) {
+        return resolvedChildren;
+      }
+      return /*#__PURE__*/(0, _react.cloneElement)(resolvedChildren, {
+        ref: function ref(node) {
+          if (typeof resolvedChildren.ref === 'function') {
+            resolvedChildren.ref(node);
+          } else if (resolvedChildren.ref) {
+            resolvedChildren.ref.current = node;
+          }
+          _this2._child.current = node;
+        }
+      });
+    }
+  }, {
+    key: "_getCellMeasurements",
+    value: function _getCellMeasurements() {
+      var cache = this.props.cache;
+      var node = this._child.current;
+
+      // TODO Check for a bad combination of fixedWidth and missing numeric width or vice versa with height
+
+      if (node && node.ownerDocument && node.ownerDocument.defaultView && node instanceof node.ownerDocument.defaultView.HTMLElement) {
+        var styleWidth = node.style.width;
+        var styleHeight = node.style.height;
+
+        // If we are re-measuring a cell that has already been measured,
+        // It will have a hard-coded width/height from the previous measurement.
+        // The fact that we are measuring indicates this measurement is probably stale,
+        // So explicitly clear it out (eg set to "auto") so we can recalculate.
+        // See issue #593 for more info.
+        // Even if we are measuring initially- if we're inside of a MultiGrid component,
+        // Explicitly clear width/height before measuring to avoid being tainted by another Grid.
+        // eg top/left Grid renders before bottom/right Grid
+        // Since the CellMeasurerCache is shared between them this taints derived cell size values.
+        if (!cache.hasFixedWidth()) {
+          node.style.width = 'auto';
+        }
+        if (!cache.hasFixedHeight()) {
+          node.style.height = 'auto';
+        }
+        var height = Math.ceil(node.offsetHeight);
+        var width = Math.ceil(node.offsetWidth);
+
+        // Reset after measuring to avoid breaking styles; see #660
+        if (styleWidth) {
+          node.style.width = styleWidth;
+        }
+        if (styleHeight) {
+          node.style.height = styleHeight;
+        }
+        return {
+          height: height,
+          width: width
+        };
+      } else {
+        return {
+          height: 0,
+          width: 0
+        };
+      }
+    }
+  }, {
+    key: "_maybeMeasureCell",
+    value: function _maybeMeasureCell() {
+      var _this$props2 = this.props,
+        cache = _this$props2.cache,
+        _this$props2$columnIn = _this$props2.columnIndex,
+        columnIndex = _this$props2$columnIn === void 0 ? 0 : _this$props2$columnIn,
+        parent = _this$props2.parent,
+        _this$props2$rowIndex = _this$props2.rowIndex,
+        rowIndex = _this$props2$rowIndex === void 0 ? this.props.index || 0 : _this$props2$rowIndex;
+      if (!cache.has(rowIndex, columnIndex)) {
+        var _this$_getCellMeasure2 = this._getCellMeasurements(),
+          height = _this$_getCellMeasure2.height,
+          width = _this$_getCellMeasure2.width;
+        cache.set(rowIndex, columnIndex, width, height);
+
+        // If size has changed, let Grid know to re-render.
+        if (parent && typeof parent.invalidateCellSizeAfterRender === 'function') {
+          parent.invalidateCellSizeAfterRender({
+            columnIndex: columnIndex,
+            rowIndex: rowIndex
+          });
+        }
+      }
+    }
+  }]);
+}(React.PureComponent); // Used for DEV mode warning check
+(0, _defineProperty2["default"])(CellMeasurer, "__internalCellMeasurerFlag", false);
+if (process.env.NODE_ENV !== 'production') {
+  CellMeasurer.__internalCellMeasurerFlag = true;
+}

package/dist/commonjs/CellMeasurer/CellMeasurerCache.jest.js

@@ -0,0 +1,298 @@
+"use strict";
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+var _CellMeasurerCache = _interopRequireWildcard(require("./CellMeasurerCache"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+describe('CellMeasurerCache', function () {
+  it('should override defaultHeight/defaultWidth if minHeight/minWidth are greater', function () {
+    var cache = new _CellMeasurerCache["default"]({
+      defaultHeight: 20,
+      defaultWidth: 100,
+      fixedHeight: true,
+      fixedWidth: true,
+      minHeight: 30,
+      minWidth: 150
+    });
+    cache.set(0, 0, 50, 10);
+    expect(cache.getHeight(0, 0)).toBe(30);
+    expect(cache.getWidth(0, 0)).toBe(150);
+    expect(cache.rowHeight({
+      index: 0
+    })).toBe(30);
+    expect(cache.columnWidth({
+      index: 0
+    })).toBe(150);
+  });
+  it('should correctly report cache status', function () {
+    var cache = new _CellMeasurerCache["default"]({
+      fixedHeight: true,
+      fixedWidth: true
+    });
+    expect(cache.has(0, 0)).toBe(false);
+  });
+  it('should cache cells', function () {
+    var cache = new _CellMeasurerCache["default"]({
+      fixedHeight: true,
+      fixedWidth: true
+    });
+    cache.set(0, 0, 100, 20);
+    expect(cache.has(0, 0)).toBe(true);
+  });
+  it('should return the correct default sizes for uncached cells if specified', function () {
+    spyOn(console, 'warn'); // Ignore warning about variable width and height
+
+    var cache = new _CellMeasurerCache["default"]({
+      defaultHeight: 20,
+      defaultWidth: 100,
+      minHeight: 15,
+      minWidth: 80
+    });
+    expect(cache.getWidth(0, 0)).toBe(100);
+    expect(cache.getHeight(0, 0)).toBe(20);
+    cache.set(0, 0, 70, 10);
+    expect(cache.getWidth(0, 0)).toBe(80);
+    expect(cache.getHeight(0, 0)).toBe(15);
+  });
+  it('should clear a single cached cell', function () {
+    var cache = new _CellMeasurerCache["default"]({
+      fixedHeight: true,
+      fixedWidth: true
+    });
+    cache.set(0, 0, 100, 20);
+    cache.set(1, 0, 100, 20);
+    expect(cache.has(0, 0)).toBe(true);
+    expect(cache.has(1, 0)).toBe(true);
+    cache.clear(0, 0);
+    expect(cache.has(0, 0)).toBe(false);
+    expect(cache.has(1, 0)).toBe(true);
+  });
+  it('should clear a single cached row cell in column 0 when columnIndex param is absent', function () {
+    var cache = new _CellMeasurerCache["default"]({
+      fixedHeight: true,
+      fixedWidth: true
+    });
+    cache.set(0, 0, 100, 20);
+    cache.set(1, 0, 100, 20);
+    expect(cache.has(0, 0)).toBe(true);
+    expect(cache.has(1, 0)).toBe(true);
+    cache.clear(0);
+    expect(cache.has(0, 0)).toBe(false);
+    expect(cache.has(1, 0)).toBe(true);
+  });
+  it('should clear all cached cells', function () {
+    var cache = new _CellMeasurerCache["default"]({
+      fixedHeight: true,
+      fixedWidth: true
+    });
+    cache.set(0, 0, 100, 20);
+    cache.set(1, 0, 100, 20);
+    expect(cache.has(0, 0)).toBe(true);
+    expect(cache.has(1, 0)).toBe(true);
+    cache.clearAll();
+    expect(cache.has(0, 0)).toBe(false);
+    expect(cache.has(1, 0)).toBe(false);
+  });
+  it('should clear row and column counts when clearing all cells', function () {
+    var cache = new _CellMeasurerCache["default"]({
+      fixedHeight: true,
+      fixedWidth: true
+    });
+    cache.set(0, 0, 100, 20);
+    cache.set(1, 0, 100, 20);
+    expect(cache._rowCount).toBe(2);
+    expect(cache._columnCount).toBe(1);
+    cache.clearAll();
+    expect(cache._rowCount).toBe(0);
+    expect(cache._columnCount).toBe(0);
+  });
+  it('should support a custom :keyMapper', function () {
+    var keyMapper = jest.fn();
+    keyMapper.mockReturnValue('a');
+    spyOn(console, 'warn'); // Ignore warning about variable width and height
+
+    var cache = new _CellMeasurerCache["default"]({
+      defaultHeight: 30,
+      defaultWidth: 50,
+      keyMapper: keyMapper
+    });
+    cache.set(0, 0, 100, 20);
+    expect(cache.has(0, 0)).toBe(true);
+
+    // Changing the returned key should cause cache misses
+    keyMapper.mockReset();
+    keyMapper.mockReturnValue('b');
+    expect(cache.has(0, 0)).toBe(false);
+    expect(cache.columnWidth(0)).toBe(50);
+    expect(cache.rowHeight(0)).toBe(30);
+    expect(keyMapper.mock.calls).toHaveLength(3);
+
+    // Restoring it should fix
+    keyMapper.mockReset();
+    keyMapper.mockReturnValue('a');
+    expect(cache.has(0, 0)).toBe(true);
+    expect(cache.columnWidth(0)).toBe(100);
+    expect(cache.rowHeight(0)).toBe(20);
+    expect(keyMapper.mock.calls).toHaveLength(3);
+  });
+  it('should provide a Grid-compatible :columnWidth method', function () {
+    var cache = new _CellMeasurerCache["default"]({
+      fixedHeight: true
+    });
+    expect(cache.columnWidth({
+      index: 0
+    })).toBe(_CellMeasurerCache.DEFAULT_WIDTH);
+    cache.set(0, 0, 100, 50);
+    expect(cache.columnWidth({
+      index: 0
+    })).toBe(100);
+    expect(cache.columnWidth({
+      index: 1
+    })).toBe(_CellMeasurerCache.DEFAULT_WIDTH);
+    cache.set(1, 0, 75, 50);
+    expect(cache.columnWidth({
+      index: 0
+    })).toBe(100);
+    cache.set(2, 0, 125, 50);
+    expect(cache.columnWidth({
+      index: 0
+    })).toBe(125);
+  });
+  it('should provide a Grid-compatible :rowHeight method', function () {
+    var cache = new _CellMeasurerCache["default"]({
+      fixedWidth: true
+    });
+    expect(cache.rowHeight({
+      index: 0
+    })).toBe(_CellMeasurerCache.DEFAULT_HEIGHT);
+    cache.set(0, 0, 100, 50);
+    expect(cache.rowHeight({
+      index: 0
+    })).toBe(50);
+    expect(cache.rowHeight({
+      index: 1
+    })).toBe(_CellMeasurerCache.DEFAULT_HEIGHT);
+    cache.set(0, 1, 100, 25);
+    expect(cache.rowHeight({
+      index: 0
+    })).toBe(50);
+    cache.set(0, 2, 100, 75);
+    expect(cache.rowHeight({
+      index: 0
+    })).toBe(75);
+  });
+  it('should return the :defaultWidth for :columnWidth if not measured', function () {
+    var cache = new _CellMeasurerCache["default"]({
+      defaultWidth: 25,
+      fixedHeight: true,
+      fixedWidth: true
+    });
+    expect(cache.columnWidth({
+      index: 0
+    })).toBe(25);
+  });
+  it('should return the :defaultHeight for :rowHeight if not measured', function () {
+    var cache = new _CellMeasurerCache["default"]({
+      defaultHeight: 25,
+      fixedHeight: true,
+      fixedWidth: true
+    });
+    expect(cache.rowHeight({
+      index: 0
+    })).toBe(25);
+  });
+  it('should recalculate cached :columnWidth when cells are cleared', function () {
+    var cache = new _CellMeasurerCache["default"]({
+      fixedHeight: true
+    });
+    expect(cache.columnWidth({
+      index: 0
+    })).toBe(_CellMeasurerCache.DEFAULT_WIDTH);
+    cache.set(0, 0, 125, 50);
+    expect(cache.columnWidth({
+      index: 0
+    })).toBe(125);
+    cache.set(1, 0, 150, 50);
+    expect(cache.columnWidth({
+      index: 0
+    })).toBe(150);
+    cache.clear(1, 0);
+    expect(cache.columnWidth({
+      index: 0
+    })).toBe(125);
+    cache.clear(0, 0);
+    expect(cache.columnWidth({
+      index: 0
+    })).toBe(_CellMeasurerCache.DEFAULT_WIDTH);
+    cache.set(0, 0, 125, 50);
+    expect(cache.columnWidth({
+      index: 0
+    })).toBe(125);
+    cache.clearAll();
+    expect(cache.columnWidth({
+      index: 0
+    })).toBe(_CellMeasurerCache.DEFAULT_WIDTH);
+  });
+  it('should recalculate cached :rowHeight when cells are cleared', function () {
+    var cache = new _CellMeasurerCache["default"]({
+      fixedWidth: true
+    });
+    expect(cache.rowHeight({
+      index: 0
+    })).toBe(_CellMeasurerCache.DEFAULT_HEIGHT);
+    cache.set(0, 0, 125, 50);
+    expect(cache.rowHeight({
+      index: 0
+    })).toBe(50);
+    cache.set(0, 1, 150, 75);
+    expect(cache.rowHeight({
+      index: 0
+    })).toBe(75);
+    cache.clear(0, 1);
+    expect(cache.rowHeight({
+      index: 0
+    })).toBe(50);
+    cache.clear(0, 0);
+    expect(cache.rowHeight({
+      index: 0
+    })).toBe(_CellMeasurerCache.DEFAULT_HEIGHT);
+    cache.set(0, 0, 125, 50);
+    expect(cache.rowHeight({
+      index: 0
+    })).toBe(50);
+    cache.clearAll();
+    expect(cache.rowHeight({
+      index: 0
+    })).toBe(_CellMeasurerCache.DEFAULT_HEIGHT);
+  });
+  describe('DEV mode', function () {
+    it('should warn about dynamic width and height configurations', function () {
+      spyOn(console, 'warn');
+      var cache = new _CellMeasurerCache["default"]({
+        fixedHeight: false,
+        fixedWidth: false
+      });
+      expect(cache.hasFixedHeight()).toBe(false);
+      expect(cache.hasFixedWidth()).toBe(false);
+      expect(console.warn).toHaveBeenCalledWith("CellMeasurerCache should only measure a cell's width or height. " + 'You have configured CellMeasurerCache to measure both. ' + 'This will result in poor performance.');
+    });
+    it('should warn about dynamic width with a defaultWidth of 0', function () {
+      spyOn(console, 'warn');
+      var cache = new _CellMeasurerCache["default"]({
+        defaultWidth: 0,
+        fixedHeight: true
+      });
+      expect(cache.getWidth(0, 0)).toBe(0);
+      expect(console.warn).toHaveBeenCalledWith('Fixed width CellMeasurerCache should specify a :defaultWidth greater than 0. ' + 'Failing to do so will lead to unnecessary layout and poor performance.');
+    });
+    it('should warn about dynamic height with a defaultHeight of 0', function () {
+      spyOn(console, 'warn');
+      var cache = new _CellMeasurerCache["default"]({
+        defaultHeight: 0,
+        fixedWidth: true
+      });
+      expect(cache.getHeight(0, 0)).toBe(0);
+      expect(console.warn).toHaveBeenCalledWith('Fixed height CellMeasurerCache should specify a :defaultHeight greater than 0. ' + 'Failing to do so will lead to unnecessary layout and poor performance.');
+    });
+  });
+});

package/dist/commonjs/CellMeasurer/CellMeasurerCache.js

@@ -0,0 +1,202 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.DEFAULT_WIDTH = exports.DEFAULT_HEIGHT = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+/*:: import type {CellMeasureCache} from './types';*/
+var DEFAULT_HEIGHT = exports.DEFAULT_HEIGHT = 30;
+var DEFAULT_WIDTH = exports.DEFAULT_WIDTH = 100;
+
+// Enables more intelligent mapping of a given column and row index to an item ID.
+// This prevents a cell cache from being invalidated when its parent collection is modified.
+/*:: type KeyMapper = (rowIndex: number, columnIndex: number) => any;*/
+/*:: type CellMeasurerCacheParams = {
+  defaultHeight?: number,
+  defaultWidth?: number,
+  fixedHeight?: boolean,
+  fixedWidth?: boolean,
+  minHeight?: number,
+  minWidth?: number,
+  keyMapper?: KeyMapper,
+};*/
+/*:: type Cache = {
+  [key: any]: number,
+};*/
+/*:: type IndexParam = {
+  index: number,
+};*/
+/**
+ * Caches measurements for a given cell.
+ */
+var CellMeasurerCache = exports["default"] = /*#__PURE__*/function () {
+  function CellMeasurerCache() {
+    var _this = this;
+    var params /*: CellMeasurerCacheParams*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    (0, _classCallCheck2["default"])(this, CellMeasurerCache);
+    (0, _defineProperty2["default"])(this, "_cellHeightCache", {});
+    (0, _defineProperty2["default"])(this, "_cellWidthCache", {});
+    (0, _defineProperty2["default"])(this, "_columnWidthCache", {});
+    (0, _defineProperty2["default"])(this, "_rowHeightCache", {});
+    (0, _defineProperty2["default"])(this, "_defaultHeight", void 0);
+    (0, _defineProperty2["default"])(this, "_defaultWidth", void 0);
+    (0, _defineProperty2["default"])(this, "_minHeight", void 0);
+    (0, _defineProperty2["default"])(this, "_minWidth", void 0);
+    (0, _defineProperty2["default"])(this, "_keyMapper", void 0);
+    (0, _defineProperty2["default"])(this, "_hasFixedHeight", void 0);
+    (0, _defineProperty2["default"])(this, "_hasFixedWidth", void 0);
+    (0, _defineProperty2["default"])(this, "_columnCount", 0);
+    (0, _defineProperty2["default"])(this, "_rowCount", 0);
+    (0, _defineProperty2["default"])(this, "columnWidth", function (_ref /*:: */) {
+      var index = _ref /*:: */.index;
+      var key = _this._keyMapper(0, index);
+      return _this._columnWidthCache[key] !== undefined ? _this._columnWidthCache[key] : _this._defaultWidth;
+    });
+    (0, _defineProperty2["default"])(this, "rowHeight", function (_ref2 /*:: */) {
+      var index = _ref2 /*:: */.index;
+      var key = _this._keyMapper(index, 0);
+      return _this._rowHeightCache[key] !== undefined ? _this._rowHeightCache[key] : _this._defaultHeight;
+    });
+    var defaultHeight = params.defaultHeight,
+      defaultWidth = params.defaultWidth,
+      fixedHeight = params.fixedHeight,
+      fixedWidth = params.fixedWidth,
+      keyMapper = params.keyMapper,
+      minHeight = params.minHeight,
+      minWidth = params.minWidth;
+    this._hasFixedHeight = fixedHeight === true;
+    this._hasFixedWidth = fixedWidth === true;
+    this._minHeight = minHeight || 0;
+    this._minWidth = minWidth || 0;
+    this._keyMapper = keyMapper || defaultKeyMapper;
+    this._defaultHeight = Math.max(this._minHeight, typeof defaultHeight === 'number' ? defaultHeight : DEFAULT_HEIGHT);
+    this._defaultWidth = Math.max(this._minWidth, typeof defaultWidth === 'number' ? defaultWidth : DEFAULT_WIDTH);
+    if (process.env.NODE_ENV !== 'production') {
+      if (this._hasFixedHeight === false && this._hasFixedWidth === false) {
+        console.warn("CellMeasurerCache should only measure a cell's width or height. " + 'You have configured CellMeasurerCache to measure both. ' + 'This will result in poor performance.');
+      }
+      if (this._hasFixedHeight === false && this._defaultHeight === 0) {
+        console.warn('Fixed height CellMeasurerCache should specify a :defaultHeight greater than 0. ' + 'Failing to do so will lead to unnecessary layout and poor performance.');
+      }
+      if (this._hasFixedWidth === false && this._defaultWidth === 0) {
+        console.warn('Fixed width CellMeasurerCache should specify a :defaultWidth greater than 0. ' + 'Failing to do so will lead to unnecessary layout and poor performance.');
+      }
+    }
+  }
+  return (0, _createClass2["default"])(CellMeasurerCache, [{
+    key: "clear",
+    value: function clear(rowIndex /*: number*/) {
+      var columnIndex /*: number*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      var key = this._keyMapper(rowIndex, columnIndex);
+      delete this._cellHeightCache[key];
+      delete this._cellWidthCache[key];
+      this._updateCachedColumnAndRowSizes(rowIndex, columnIndex);
+    }
+  }, {
+    key: "clearAll",
+    value: function clearAll() {
+      this._cellHeightCache = {};
+      this._cellWidthCache = {};
+      this._columnWidthCache = {};
+      this._rowHeightCache = {};
+      this._rowCount = 0;
+      this._columnCount = 0;
+    }
+  }, {
+    key: "defaultHeight",
+    get: function get() /*: number*/{
+      return this._defaultHeight;
+    }
+  }, {
+    key: "defaultWidth",
+    get: function get() /*: number*/{
+      return this._defaultWidth;
+    }
+  }, {
+    key: "hasFixedHeight",
+    value: function hasFixedHeight() /*: boolean*/{
+      return this._hasFixedHeight;
+    }
+  }, {
+    key: "hasFixedWidth",
+    value: function hasFixedWidth() /*: boolean*/{
+      return this._hasFixedWidth;
+    }
+  }, {
+    key: "getHeight",
+    value: function getHeight(rowIndex /*: number*/) /*: number*/{
+      var columnIndex /*: number*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      if (this._hasFixedHeight) {
+        return this._defaultHeight;
+      } else {
+        var _key = this._keyMapper(rowIndex, columnIndex);
+        return this._cellHeightCache[_key] !== undefined ? Math.max(this._minHeight, this._cellHeightCache[_key]) : this._defaultHeight;
+      }
+    }
+  }, {
+    key: "getWidth",
+    value: function getWidth(rowIndex /*: number*/) /*: number*/{
+      var columnIndex /*: number*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      if (this._hasFixedWidth) {
+        return this._defaultWidth;
+      } else {
+        var _key2 = this._keyMapper(rowIndex, columnIndex);
+        return this._cellWidthCache[_key2] !== undefined ? Math.max(this._minWidth, this._cellWidthCache[_key2]) : this._defaultWidth;
+      }
+    }
+  }, {
+    key: "has",
+    value: function has(rowIndex /*: number*/) /*: boolean*/{
+      var columnIndex /*: number*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      var key = this._keyMapper(rowIndex, columnIndex);
+      return this._cellHeightCache[key] !== undefined;
+    }
+  }, {
+    key: "set",
+    value: function set(rowIndex /*: number*/, columnIndex /*: number*/, width /*: number*/, height /*: number*/) /*: void*/{
+      var key = this._keyMapper(rowIndex, columnIndex);
+      if (columnIndex >= this._columnCount) {
+        this._columnCount = columnIndex + 1;
+      }
+      if (rowIndex >= this._rowCount) {
+        this._rowCount = rowIndex + 1;
+      }
+
+      // Size is cached per cell so we don't have to re-measure if cells are re-ordered.
+      this._cellHeightCache[key] = height;
+      this._cellWidthCache[key] = width;
+      this._updateCachedColumnAndRowSizes(rowIndex, columnIndex);
+    }
+  }, {
+    key: "_updateCachedColumnAndRowSizes",
+    value: function _updateCachedColumnAndRowSizes(rowIndex /*: number*/, columnIndex /*: number*/) {
+      // :columnWidth and :rowHeight are derived based on all cells in a column/row.
+      // Pre-cache these derived values for faster lookup later.
+      // Reads are expected to occur more frequently than writes in this case.
+      // Only update non-fixed dimensions though to avoid doing unnecessary work.
+      if (!this._hasFixedWidth) {
+        var columnWidth = 0;
+        for (var i = 0; i < this._rowCount; i++) {
+          columnWidth = Math.max(columnWidth, this.getWidth(i, columnIndex));
+        }
+        var columnKey = this._keyMapper(0, columnIndex);
+        this._columnWidthCache[columnKey] = columnWidth;
+      }
+      if (!this._hasFixedHeight) {
+        var rowHeight = 0;
+        for (var _i = 0; _i < this._columnCount; _i++) {
+          rowHeight = Math.max(rowHeight, this.getHeight(rowIndex, _i));
+        }
+        var rowKey = this._keyMapper(rowIndex, 0);
+        this._rowHeightCache[rowKey] = rowHeight;
+      }
+    }
+  }]);
+}();
+function defaultKeyMapper(rowIndex /*: number*/, columnIndex /*: number*/) {
+  return "".concat(rowIndex, "-").concat(columnIndex);
+}