@depup/react-virtualized 9.22.6-depup.0

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

@@ -0,0 +1,293 @@
+import CellMeasurerCache, { DEFAULT_HEIGHT, DEFAULT_WIDTH } from './CellMeasurerCache';
+describe('CellMeasurerCache', function () {
+  it('should override defaultHeight/defaultWidth if minHeight/minWidth are greater', function () {
+    var cache = new CellMeasurerCache({
+      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({
+      fixedHeight: true,
+      fixedWidth: true
+    });
+    expect(cache.has(0, 0)).toBe(false);
+  });
+  it('should cache cells', function () {
+    var cache = new CellMeasurerCache({
+      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({
+      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({
+      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({
+      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({
+      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({
+      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({
+      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({
+      fixedHeight: true
+    });
+    expect(cache.columnWidth({
+      index: 0
+    })).toBe(DEFAULT_WIDTH);
+    cache.set(0, 0, 100, 50);
+    expect(cache.columnWidth({
+      index: 0
+    })).toBe(100);
+    expect(cache.columnWidth({
+      index: 1
+    })).toBe(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({
+      fixedWidth: true
+    });
+    expect(cache.rowHeight({
+      index: 0
+    })).toBe(DEFAULT_HEIGHT);
+    cache.set(0, 0, 100, 50);
+    expect(cache.rowHeight({
+      index: 0
+    })).toBe(50);
+    expect(cache.rowHeight({
+      index: 1
+    })).toBe(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({
+      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({
+      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({
+      fixedHeight: true
+    });
+    expect(cache.columnWidth({
+      index: 0
+    })).toBe(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(DEFAULT_WIDTH);
+    cache.set(0, 0, 125, 50);
+    expect(cache.columnWidth({
+      index: 0
+    })).toBe(125);
+    cache.clearAll();
+    expect(cache.columnWidth({
+      index: 0
+    })).toBe(DEFAULT_WIDTH);
+  });
+  it('should recalculate cached :rowHeight when cells are cleared', function () {
+    var cache = new CellMeasurerCache({
+      fixedWidth: true
+    });
+    expect(cache.rowHeight({
+      index: 0
+    })).toBe(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(DEFAULT_HEIGHT);
+    cache.set(0, 0, 125, 50);
+    expect(cache.rowHeight({
+      index: 0
+    })).toBe(50);
+    cache.clearAll();
+    expect(cache.rowHeight({
+      index: 0
+    })).toBe(DEFAULT_HEIGHT);
+  });
+  describe('DEV mode', function () {
+    it('should warn about dynamic width and height configurations', function () {
+      spyOn(console, 'warn');
+      var cache = new CellMeasurerCache({
+        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({
+        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({
+        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/es/CellMeasurer/CellMeasurerCache.js

@@ -0,0 +1,196 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+/*:: import type {CellMeasureCache} from './types';*/
+export var DEFAULT_HEIGHT = 30;
+export var 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 = /*#__PURE__*/function () {
+  function CellMeasurerCache() {
+    var _this = this;
+    var params /*: CellMeasurerCacheParams*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _classCallCheck(this, CellMeasurerCache);
+    _defineProperty(this, "_cellHeightCache", {});
+    _defineProperty(this, "_cellWidthCache", {});
+    _defineProperty(this, "_columnWidthCache", {});
+    _defineProperty(this, "_rowHeightCache", {});
+    _defineProperty(this, "_defaultHeight", void 0);
+    _defineProperty(this, "_defaultWidth", void 0);
+    _defineProperty(this, "_minHeight", void 0);
+    _defineProperty(this, "_minWidth", void 0);
+    _defineProperty(this, "_keyMapper", void 0);
+    _defineProperty(this, "_hasFixedHeight", void 0);
+    _defineProperty(this, "_hasFixedWidth", void 0);
+    _defineProperty(this, "_columnCount", 0);
+    _defineProperty(this, "_rowCount", 0);
+    _defineProperty(this, "columnWidth", function (_ref /*:: */) {
+      var index = _ref /*:: */.index;
+      var key = _this._keyMapper(0, index);
+      return _this._columnWidthCache[key] !== undefined ? _this._columnWidthCache[key] : _this._defaultWidth;
+    });
+    _defineProperty(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 _createClass(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;
+      }
+    }
+  }]);
+}();
+export { CellMeasurerCache as default };
+function defaultKeyMapper(rowIndex /*: number*/, columnIndex /*: number*/) {
+  return "".concat(rowIndex, "-").concat(columnIndex);
+}

package/dist/es/CellMeasurer/index.js

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

package/dist/es/CellMeasurer/types.js

@@ -0,0 +1,13 @@
+/*:: export interface CellMeasureCache {
+  hasFixedWidth(): boolean;
+  hasFixedHeight(): boolean;
+  has(rowIndex: number, columnIndex: number): boolean;
+  set(
+    rowIndex: number,
+    columnIndex: number,
+    width: number,
+    height: number,
+  ): void;
+  getHeight(rowIndex: number, columnIndex?: number): number;
+  getWidth(rowIndex: number, columnIndex?: number): number;
+}*/