@depup/react-virtualized 9.22.6-depup.0

package/dist/commonjs/Grid/utils/ScalingCellSizeAndPositionManager.jest.js

@@ -0,0 +1,201 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _ScalingCellSizeAndPositionManager = _interopRequireDefault(require("./ScalingCellSizeAndPositionManager"));
+describe('ScalingCellSizeAndPositionManager', function () {
+  function init() {
+    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      _ref$cellCount = _ref.cellCount,
+      cellCount = _ref$cellCount === void 0 ? 10 : _ref$cellCount,
+      _ref$cellSize = _ref.cellSize,
+      cellSize = _ref$cellSize === void 0 ? 10 : _ref$cellSize,
+      _ref$estimatedCellSiz = _ref.estimatedCellSize,
+      estimatedCellSize = _ref$estimatedCellSiz === void 0 ? 10 : _ref$estimatedCellSiz,
+      _ref$maxScrollSize = _ref.maxScrollSize,
+      maxScrollSize = _ref$maxScrollSize === void 0 ? 50 : _ref$maxScrollSize;
+    var cellSizeAndPositionManager = new _ScalingCellSizeAndPositionManager["default"]({
+      cellCount: cellCount,
+      cellSizeGetter: function cellSizeGetter() {
+        return cellSize;
+      },
+      estimatedCellSize: estimatedCellSize,
+      maxScrollSize: maxScrollSize
+    });
+    return cellSizeAndPositionManager;
+  }
+  describe('_getOffsetPercentage', function () {
+    it('should return the correct offset fraction', function () {
+      var expectations = [{
+        offset: 0,
+        expectedOffsetPercentage: 0
+      }, {
+        offset: 35,
+        expectedOffsetPercentage: 0.5
+      }, {
+        offset: 70,
+        expectedOffsetPercentage: 1
+      }];
+      var instance = init();
+      expectations.forEach(function (expectation) {
+        expect(instance._getOffsetPercentage({
+          containerSize: 30,
+          offset: expectation.offset,
+          totalSize: 100
+        })).toBe(expectation.expectedOffsetPercentage);
+      });
+    });
+  });
+  describe('getOffsetAdjustment', function () {
+    it('should always return 0 as the adjustment for unscaled lists', function () {
+      var maxScrollSizes = [100, 150];
+      maxScrollSizes.forEach(function (maxScrollSize) {
+        var instance = init({
+          cellCount: 10,
+          maxScrollSize: maxScrollSize
+        });
+        var offsets = [0, 35, 70];
+        offsets.forEach(function (offset) {
+          expect(instance.getOffsetAdjustment({
+            containerSize: 30,
+            offset: offset
+          })).toBe(0);
+        });
+      });
+    });
+    it('should properly scale an offset at the beginning, middle, and end of the list', function () {
+      var offsetsAndExpectedAdjustements = [{
+        offset: 0,
+        expectedAdjustment: -0
+      }, {
+        offset: 10,
+        expectedAdjustment: -25
+      }, {
+        offset: 20,
+        expectedAdjustment: -50
+      }];
+      var instance = init();
+      offsetsAndExpectedAdjustements.forEach(function (offsetAndExpectedAdjustement) {
+        expect(instance.getOffsetAdjustment({
+          containerSize: 30,
+          offset: offsetAndExpectedAdjustement.offset
+        })).toBe(offsetAndExpectedAdjustement.expectedAdjustment);
+      });
+    });
+  });
+  describe('getTotalSize', function () {
+    it('should return :totalSize if it is not greater than :maxScrollSize', function () {
+      var maxScrollSizes = [500, 750];
+      maxScrollSizes.forEach(function (maxScrollSize) {
+        var instance = init({
+          cellCount: 50,
+          maxScrollSize: maxScrollSize
+        });
+        expect(instance.getTotalSize()).toEqual(500);
+      });
+    });
+    it('should return :maxScrollSize if :totalSize is greater', function () {
+      var instance = init({
+        cellCount: 100,
+        maxScrollSize: 100
+      });
+      expect(instance.getTotalSize()).toEqual(100);
+    });
+  });
+  describe('getUpdatedOffsetForIndex', function () {
+    it('should scroll to a cell before the current range', function () {
+      var data = [{
+        targetIndex: 0,
+        expectedOffset: 0
+      }, {
+        targetIndex: 1,
+        expectedOffset: 3
+      },
+      // (unsafe: 10)
+      {
+        targetIndex: 2,
+        expectedOffset: 6
+      } // (unsafe: 20)
+      ];
+      var instance = init();
+      data.forEach(function (datum) {
+        expect(instance.getUpdatedOffsetForIndex({
+          containerSize: 30,
+          currentOffset: 10,
+          // (unsafe: 35)
+          targetIndex: datum.targetIndex
+        })).toBe(datum.expectedOffset);
+      });
+    });
+    it('should scroll to a cell after the current range', function () {
+      var data = [{
+        targetIndex: 7,
+        expectedOffset: 14
+      },
+      // (unsafe: 50)
+      {
+        targetIndex: 9,
+        expectedOffset: 20
+      } // (unsafe: 70)
+      ];
+      var instance = init();
+      data.forEach(function (datum) {
+        expect(instance.getUpdatedOffsetForIndex({
+          containerSize: 30,
+          currentOffset: 0,
+          targetIndex: datum.targetIndex
+        })).toBe(datum.expectedOffset);
+      });
+    });
+    it('should not scroll to a cell already visible within the current range', function () {
+      var instance = init();
+      expect(instance.getUpdatedOffsetForIndex({
+        containerSize: 30,
+        currentOffset: 10,
+        // (unsafe: 35)
+        targetIndex: 4
+      })).toBe(10);
+    });
+  });
+  describe('getVisibleCellRange', function () {
+    it('should correct identify the first set of cells', function () {
+      var instance = init();
+      expect(instance.getVisibleCellRange({
+        containerSize: 30,
+        offset: 0
+      })).toEqual({
+        start: 0,
+        stop: 2
+      });
+    });
+    it('should correct identify cells in the middle', function () {
+      var instance = init();
+      expect(instance.getVisibleCellRange({
+        containerSize: 30,
+        offset: 2.85 // (unsafe: 10)
+      })).toEqual({
+        start: 1,
+        stop: 3
+      });
+    });
+    it('should correct identify partially visible cells', function () {
+      var instance = init();
+      expect(instance.getVisibleCellRange({
+        containerSize: 30,
+        offset: 10 // (unsafe: 35)
+      })).toEqual({
+        start: 3,
+        stop: 6
+      });
+    });
+    it('should correct identify the last set of cells', function () {
+      var instance = init();
+      expect(instance.getVisibleCellRange({
+        containerSize: 30,
+        offset: 20
+      })).toEqual({
+        start: 7,
+        stop: 9
+      });
+    });
+  });
+});

package/dist/commonjs/Grid/utils/ScalingCellSizeAndPositionManager.js

@@ -0,0 +1,204 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _CellSizeAndPositionManager = _interopRequireDefault(require("./CellSizeAndPositionManager"));
+var _maxElementSize = require("./maxElementSize.js");
+var _excluded = ["maxScrollSize"];
+/*:: import type {Alignment, CellSizeGetter, VisibleCellRange} from '../types';*/
+/*:: type ContainerSizeAndOffset = {
+  containerSize: number,
+  offset: number,
+};*/
+/*:: type Params = {
+  maxScrollSize?: number,
+  cellCount: number,
+  cellSizeGetter: CellSizeGetter,
+  estimatedCellSize: number,
+};*/
+/**
+ * Browsers have scroll offset limitations (eg Chrome stops scrolling at ~33.5M pixels where as Edge tops out at ~1.5M pixels).
+ * After a certain position, the browser won't allow the user to scroll further (even via JavaScript scroll offset adjustments).
+ * This util picks a lower ceiling for max size and artificially adjusts positions within to make it transparent for users.
+ */
+/**
+ * Extends CellSizeAndPositionManager and adds scaling behavior for lists that are too large to fit within a browser's native limits.
+ */
+var ScalingCellSizeAndPositionManager = exports["default"] = /*#__PURE__*/function () {
+  function ScalingCellSizeAndPositionManager(_ref /*:: */) {
+    var _ref$maxScrollSize = _ref /*:: */.maxScrollSize,
+      maxScrollSize = _ref$maxScrollSize === void 0 ? (0, _maxElementSize.getMaxElementSize)() : _ref$maxScrollSize,
+      params = (0, _objectWithoutProperties2["default"])(_ref /*:: */, _excluded);
+    (0, _classCallCheck2["default"])(this, ScalingCellSizeAndPositionManager);
+    (0, _defineProperty2["default"])(this, "_cellSizeAndPositionManager", void 0);
+    (0, _defineProperty2["default"])(this, "_maxScrollSize", void 0);
+    // Favor composition over inheritance to simplify IE10 support
+    this._cellSizeAndPositionManager = new _CellSizeAndPositionManager["default"](params);
+    this._maxScrollSize = maxScrollSize;
+  }
+  return (0, _createClass2["default"])(ScalingCellSizeAndPositionManager, [{
+    key: "areOffsetsAdjusted",
+    value: function areOffsetsAdjusted() /*: boolean*/{
+      return this._cellSizeAndPositionManager.getTotalSize() > this._maxScrollSize;
+    }
+  }, {
+    key: "configure",
+    value: function configure(params
+    /*: {
+        cellCount: number,
+        estimatedCellSize: number,
+        cellSizeGetter: CellSizeGetter,
+      }*/
+    ) {
+      this._cellSizeAndPositionManager.configure(params);
+    }
+  }, {
+    key: "getCellCount",
+    value: function getCellCount() /*: number*/{
+      return this._cellSizeAndPositionManager.getCellCount();
+    }
+  }, {
+    key: "getEstimatedCellSize",
+    value: function getEstimatedCellSize() /*: number*/{
+      return this._cellSizeAndPositionManager.getEstimatedCellSize();
+    }
+  }, {
+    key: "getLastMeasuredIndex",
+    value: function getLastMeasuredIndex() /*: number*/{
+      return this._cellSizeAndPositionManager.getLastMeasuredIndex();
+    }
+
+    /**
+     * Number of pixels a cell at the given position (offset) should be shifted in order to fit within the scaled container.
+     * The offset passed to this function is scaled (safe) as well.
+     */
+  }, {
+    key: "getOffsetAdjustment",
+    value: function getOffsetAdjustment(_ref2 /*:: */) /*: number*/{
+      var containerSize = _ref2 /*:: */.containerSize,
+        offset = _ref2 /*:: */.offset;
+      var totalSize = this._cellSizeAndPositionManager.getTotalSize();
+      var safeTotalSize = this.getTotalSize();
+      var offsetPercentage = this._getOffsetPercentage({
+        containerSize: containerSize,
+        offset: offset,
+        totalSize: safeTotalSize
+      });
+      return Math.round(offsetPercentage * (safeTotalSize - totalSize));
+    }
+  }, {
+    key: "getSizeAndPositionOfCell",
+    value: function getSizeAndPositionOfCell(index /*: number*/) {
+      return this._cellSizeAndPositionManager.getSizeAndPositionOfCell(index);
+    }
+  }, {
+    key: "getSizeAndPositionOfLastMeasuredCell",
+    value: function getSizeAndPositionOfLastMeasuredCell() {
+      return this._cellSizeAndPositionManager.getSizeAndPositionOfLastMeasuredCell();
+    }
+
+    /** See CellSizeAndPositionManager#getTotalSize */
+  }, {
+    key: "getTotalSize",
+    value: function getTotalSize() /*: number*/{
+      return Math.min(this._maxScrollSize, this._cellSizeAndPositionManager.getTotalSize());
+    }
+
+    /** See CellSizeAndPositionManager#getUpdatedOffsetForIndex */
+  }, {
+    key: "getUpdatedOffsetForIndex",
+    value: function getUpdatedOffsetForIndex(_ref3 /*:: */) {
+      var _ref3$align = _ref3 /*:: */.align,
+        align = _ref3$align === void 0 ? 'auto' : _ref3$align,
+        containerSize = _ref3 /*:: */.containerSize,
+        currentOffset = _ref3 /*:: */.currentOffset,
+        targetIndex = _ref3 /*:: */.targetIndex;
+      currentOffset = this._safeOffsetToOffset({
+        containerSize: containerSize,
+        offset: currentOffset
+      });
+      var offset = this._cellSizeAndPositionManager.getUpdatedOffsetForIndex({
+        align: align,
+        containerSize: containerSize,
+        currentOffset: currentOffset,
+        targetIndex: targetIndex
+      });
+      return this._offsetToSafeOffset({
+        containerSize: containerSize,
+        offset: offset
+      });
+    }
+
+    /** See CellSizeAndPositionManager#getVisibleCellRange */
+  }, {
+    key: "getVisibleCellRange",
+    value: function getVisibleCellRange(_ref4 /*:: */) /*: VisibleCellRange*/{
+      var containerSize = _ref4 /*:: */.containerSize,
+        offset = _ref4 /*:: */.offset;
+      offset = this._safeOffsetToOffset({
+        containerSize: containerSize,
+        offset: offset
+      });
+      return this._cellSizeAndPositionManager.getVisibleCellRange({
+        containerSize: containerSize,
+        offset: offset
+      });
+    }
+  }, {
+    key: "resetCell",
+    value: function resetCell(index /*: number*/) /*: void*/{
+      this._cellSizeAndPositionManager.resetCell(index);
+    }
+  }, {
+    key: "_getOffsetPercentage",
+    value: function _getOffsetPercentage(_ref5 /*:: */) {
+      var containerSize = _ref5 /*:: */.containerSize,
+        offset = _ref5 /*:: */.offset,
+        totalSize = _ref5 /*:: */.totalSize;
+      return totalSize <= containerSize ? 0 : offset / (totalSize - containerSize);
+    }
+  }, {
+    key: "_offsetToSafeOffset",
+    value: function _offsetToSafeOffset(_ref6 /*:: */) /*: number*/{
+      var containerSize = _ref6 /*:: */.containerSize,
+        offset = _ref6 /*:: */.offset;
+      var totalSize = this._cellSizeAndPositionManager.getTotalSize();
+      var safeTotalSize = this.getTotalSize();
+      if (totalSize === safeTotalSize) {
+        return offset;
+      } else {
+        var offsetPercentage = this._getOffsetPercentage({
+          containerSize: containerSize,
+          offset: offset,
+          totalSize: totalSize
+        });
+        return Math.round(offsetPercentage * (safeTotalSize - containerSize));
+      }
+    }
+  }, {
+    key: "_safeOffsetToOffset",
+    value: function _safeOffsetToOffset(_ref7 /*:: */) /*: number*/{
+      var containerSize = _ref7 /*:: */.containerSize,
+        offset = _ref7 /*:: */.offset;
+      var totalSize = this._cellSizeAndPositionManager.getTotalSize();
+      var safeTotalSize = this.getTotalSize();
+      if (totalSize === safeTotalSize) {
+        return offset;
+      } else {
+        var offsetPercentage = this._getOffsetPercentage({
+          containerSize: containerSize,
+          offset: offset,
+          totalSize: safeTotalSize
+        });
+        return Math.round(offsetPercentage * (totalSize - containerSize));
+      }
+    }
+  }]);
+}();

package/dist/commonjs/Grid/utils/calculateSizeAndPositionDataAndUpdateScrollOffset.jest.js

@@ -0,0 +1,84 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _calculateSizeAndPositionDataAndUpdateScrollOffset = _interopRequireDefault(require("./calculateSizeAndPositionDataAndUpdateScrollOffset"));
+describe('calculateSizeAndPositionDataAndUpdateScrollOffset', function () {
+  function helper() {
+    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      _ref$cellCount = _ref.cellCount,
+      cellCount = _ref$cellCount === void 0 ? 100 : _ref$cellCount,
+      _ref$cellSize = _ref.cellSize,
+      cellSize = _ref$cellSize === void 0 ? 10 : _ref$cellSize,
+      _ref$computeMetadataC = _ref.computeMetadataCallbackProps,
+      computeMetadataCallbackProps = _ref$computeMetadataC === void 0 ? {} : _ref$computeMetadataC,
+      _ref$nextCellsCount = _ref.nextCellsCount,
+      nextCellsCount = _ref$nextCellsCount === void 0 ? 100 : _ref$nextCellsCount,
+      _ref$nextCellSize = _ref.nextCellSize,
+      nextCellSize = _ref$nextCellSize === void 0 ? 10 : _ref$nextCellSize,
+      nextScrollToIndex = _ref.nextScrollToIndex,
+      scrollToIndex = _ref.scrollToIndex;
+    var computeMetadataCallbackCalls = [];
+    var updateScrollOffsetForScrollToIndexCalls = [];
+    (0, _calculateSizeAndPositionDataAndUpdateScrollOffset["default"])({
+      cellCount: cellCount,
+      cellSize: cellSize,
+      computeMetadataCallback: function computeMetadataCallback(params) {
+        return computeMetadataCallbackCalls.push(params);
+      },
+      computeMetadataCallbackProps: computeMetadataCallbackProps,
+      nextCellsCount: nextCellsCount,
+      nextCellSize: nextCellSize,
+      nextScrollToIndex: nextScrollToIndex,
+      scrollToIndex: scrollToIndex,
+      updateScrollOffsetForScrollToIndex: function updateScrollOffsetForScrollToIndex(params) {
+        return updateScrollOffsetForScrollToIndexCalls.push(params);
+      }
+    });
+    return {
+      computeMetadataCallbackCalls: computeMetadataCallbackCalls,
+      updateScrollOffsetForScrollToIndexCalls: updateScrollOffsetForScrollToIndexCalls
+    };
+  }
+  it('should call :computeMetadataCallback if :cellCount has changed', function () {
+    var _helper = helper({
+        cellCount: 100,
+        nextCellsCount: 200
+      }),
+      computeMetadataCallbackCalls = _helper.computeMetadataCallbackCalls;
+    expect(computeMetadataCallbackCalls.length).toEqual(1);
+  });
+  it('should call :computeMetadataCallback if numeric :cellSize has changed', function () {
+    var _helper2 = helper({
+        cellSize: 10,
+        nextCellSize: 20
+      }),
+      computeMetadataCallbackCalls = _helper2.computeMetadataCallbackCalls;
+    expect(computeMetadataCallbackCalls.length).toEqual(1);
+  });
+  it('should not call :computeMetadataCallback if :cellSize callback has changed', function () {
+    var _helper3 = helper({
+        cellSize: function cellSize() {},
+        nextCellSize: function nextCellSize() {}
+      }),
+      computeMetadataCallbackCalls = _helper3.computeMetadataCallbackCalls;
+    expect(computeMetadataCallbackCalls.length).toEqual(0);
+  });
+  it('should not call :updateScrollOffsetForScrollToIndex if :scrollToIndex is not specified', function () {
+    var _helper4 = helper(),
+      updateScrollOffsetForScrollToIndexCalls = _helper4.updateScrollOffsetForScrollToIndexCalls;
+    expect(updateScrollOffsetForScrollToIndexCalls.length).toEqual(0);
+  });
+  it('should not call :updateScrollOffsetForScrollToIndex if :scrollToIndex has also changed', function () {
+    var _helper5 = helper({
+        scrollToIndex: 10,
+        nextScrollToIndex: 20
+      }),
+      updateScrollOffsetForScrollToIndexCalls = _helper5.updateScrollOffsetForScrollToIndexCalls;
+    expect(updateScrollOffsetForScrollToIndexCalls.length).toEqual(0);
+  });
+  it('should not call :computeMetadataCallback if the above conditions are not true', function () {
+    var _helper6 = helper(),
+      computeMetadataCallbackCalls = _helper6.computeMetadataCallbackCalls;
+    expect(computeMetadataCallbackCalls.length).toEqual(0);
+  });
+});

package/dist/commonjs/Grid/utils/calculateSizeAndPositionDataAndUpdateScrollOffset.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = calculateSizeAndPositionDataAndUpdateScrollOffset;
+/**
+ * Helper method that determines when to recalculate row or column metadata.
+ */
+/*:: type Params<T> = {
+  // Number of rows or columns in the current axis
+  cellCount: number,
+
+  // Width or height of cells for the current axis
+  cellSize: ?number,
+
+  // Method to invoke if cell metadata should be recalculated
+  computeMetadataCallback: (props: T) => void,
+
+  // Parameters to pass to :computeMetadataCallback
+  computeMetadataCallbackProps: T,
+
+  // Newly updated number of rows or columns in the current axis
+  nextCellsCount: number,
+
+  // Newly updated width or height of cells for the current axis
+  nextCellSize: ?number,
+
+  // Newly updated scroll-to-index
+  nextScrollToIndex: number,
+
+  // Scroll-to-index
+  scrollToIndex: number,
+
+  // Callback to invoke if the scroll position should be recalculated
+  updateScrollOffsetForScrollToIndex: () => void,
+};*/
+function calculateSizeAndPositionDataAndUpdateScrollOffset(_ref /*:: */) {
+  var cellCount = _ref /*:: */.cellCount,
+    cellSize = _ref /*:: */.cellSize,
+    computeMetadataCallback = _ref /*:: */.computeMetadataCallback,
+    computeMetadataCallbackProps = _ref /*:: */.computeMetadataCallbackProps,
+    nextCellsCount = _ref /*:: */.nextCellsCount,
+    nextCellSize = _ref /*:: */.nextCellSize,
+    nextScrollToIndex = _ref /*:: */.nextScrollToIndex,
+    scrollToIndex = _ref /*:: */.scrollToIndex,
+    updateScrollOffsetForScrollToIndex = _ref /*:: */.updateScrollOffsetForScrollToIndex;
+  // Don't compare cell sizes if they are functions because inline functions would cause infinite loops.
+  // In that event users should use the manual recompute methods to inform of changes.
+  if (cellCount !== nextCellsCount || (typeof cellSize === 'number' || typeof nextCellSize === 'number') && cellSize !== nextCellSize) {
+    computeMetadataCallback(computeMetadataCallbackProps);
+
+    // Updated cell metadata may have hidden the previous scrolled-to item.
+    // In this case we should also update the scrollTop to ensure it stays visible.
+    if (scrollToIndex >= 0 && scrollToIndex === nextScrollToIndex) {
+      updateScrollOffsetForScrollToIndex();
+    }
+  }
+}

package/dist/commonjs/Grid/utils/maxElementSize.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getMaxElementSize = void 0;
+var DEFAULT_MAX_ELEMENT_SIZE = 1500000;
+var CHROME_MAX_ELEMENT_SIZE = 1.67771e7;
+var isBrowser = function isBrowser() {
+  return typeof window !== 'undefined';
+};
+var isChrome = function isChrome() {
+  return !!window.chrome;
+};
+var getMaxElementSize = exports.getMaxElementSize = function getMaxElementSize() /*: number*/{
+  if (isBrowser()) {
+    if (isChrome()) {
+      return CHROME_MAX_ELEMENT_SIZE;
+    }
+  }
+  return DEFAULT_MAX_ELEMENT_SIZE;
+};