@depup/react-virtualized 9.22.6-depup.0

package/dist/commonjs/utils/TestHelper.js

@@ -0,0 +1,36 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCellMetadata = getCellMetadata;
+var _initCellMetadata = _interopRequireDefault(require("./initCellMetadata"));
+// Default cell sizes and offsets for use in below tests
+function getCellMetadata() {
+  var cellSizes = [10,
+  // 0: 0..0 (min)
+  20,
+  // 1: 0..10
+  15,
+  // 2: 0..30
+  10,
+  // 3: 5..45
+  15,
+  // 4: 20..55
+  30,
+  // 5: 50..70
+  20,
+  // 6: 70..100
+  10,
+  // 7: 80..110
+  30 //  8: 110..110 (max)
+  ];
+  return (0, _initCellMetadata["default"])({
+    cellCount: cellSizes.length,
+    size: function size(_ref) {
+      var index = _ref.index;
+      return cellSizes[index];
+    }
+  });
+}

package/dist/commonjs/utils/animationFrame.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.raf = exports.caf = void 0;
+/*:: type Callback = (timestamp: number) => void;*/
+/*:: type CancelAnimationFrame = (requestId: number) => void;*/
+/*:: type RequestAnimationFrame = (callback: Callback) => number;*/
+// Properly handle server-side rendering.
+var win;
+if (typeof window !== 'undefined') {
+  win = window;
+} else if (typeof self !== 'undefined') {
+  win = self;
+} else {
+  win = {};
+}
+
+// requestAnimationFrame() shim by Paul Irish
+// http://paulirish.com/2011/requestanimationframe-for-smart-animating/
+var request = win.requestAnimationFrame || win.webkitRequestAnimationFrame || win.mozRequestAnimationFrame || win.oRequestAnimationFrame || win.msRequestAnimationFrame || function (callback /*: Callback*/) /*: RequestAnimationFrame*/{
+  return (win /*: any*/).setTimeout(callback, 1000 / 60);
+};
+var cancel = win.cancelAnimationFrame || win.webkitCancelAnimationFrame || win.mozCancelAnimationFrame || win.oCancelAnimationFrame || win.msCancelAnimationFrame || function (id /*: number*/) {
+  (win /*: any*/).clearTimeout(id);
+};
+var raf /*: RequestAnimationFrame*/ = exports.raf = (request /*: any*/);
+var caf /*: CancelAnimationFrame*/ = exports.caf = (cancel /*: any*/);

package/dist/commonjs/utils/createCallbackMemoizer.jest.js

@@ -0,0 +1,219 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _createCallbackMemoizer = _interopRequireDefault(require("./createCallbackMemoizer"));
+describe('createCallbackMemoizer', function () {
+  function OnRowsRendered() {
+    var _numCalls = 0;
+    var _overscanStartIndex;
+    var _overscanStopIndex;
+    var _startIndex;
+    var _stopIndex;
+    return {
+      numCalls: function numCalls() {
+        return _numCalls;
+      },
+      overscanStartIndex: function overscanStartIndex() {
+        return _overscanStartIndex;
+      },
+      overscanStopIndex: function overscanStopIndex() {
+        return _overscanStopIndex;
+      },
+      startIndex: function startIndex() {
+        return _startIndex;
+      },
+      stopIndex: function stopIndex() {
+        return _stopIndex;
+      },
+      update: function update(params) {
+        _overscanStartIndex = params.overscanStartIndex;
+        _overscanStopIndex = params.overscanStopIndex;
+        _startIndex = params.startIndex;
+        _stopIndex = params.stopIndex;
+        _numCalls++;
+      }
+    };
+  }
+  it('should not call onRowsRendered if startIndex or stopIndex are invalid', function () {
+    var util = new OnRowsRendered();
+    var helper = (0, _createCallbackMemoizer["default"])();
+    helper({
+      callback: util.update,
+      indices: {
+        startIndex: 0,
+        stopIndex: undefined
+      }
+    });
+    expect(util.numCalls()).toEqual(0);
+    helper({
+      callback: util.update,
+      indices: {
+        startIndex: undefined,
+        stopIndex: 0
+      }
+    });
+    expect(util.numCalls()).toEqual(0);
+  });
+  it('should call onRowsRendered if startIndex and stopIndex are valid', function () {
+    var util = new OnRowsRendered();
+    var helper = (0, _createCallbackMemoizer["default"])();
+    helper({
+      callback: util.update,
+      indices: {
+        startIndex: 0,
+        stopIndex: 1
+      }
+    });
+    expect(util.numCalls()).toEqual(1);
+    expect(util.startIndex()).toEqual(0);
+    expect(util.stopIndex()).toEqual(1);
+  });
+  it('should call onRowsRendered if startIndex and stopIndex are invalid but :requireAllKeys is false', function () {
+    var util = new OnRowsRendered();
+    var helper = (0, _createCallbackMemoizer["default"])(false);
+    helper({
+      callback: util.update,
+      indices: {
+        startIndex: undefined,
+        stopIndex: 1
+      }
+    });
+    expect(util.numCalls()).toEqual(1);
+    expect(util.startIndex()).toEqual(undefined);
+    expect(util.stopIndex()).toEqual(1);
+  });
+  it('should not call onRowsRendered if startIndex or stopIndex have not changed', function () {
+    var util = new OnRowsRendered();
+    var helper = (0, _createCallbackMemoizer["default"])();
+    helper({
+      callback: util.update,
+      indices: {
+        startIndex: 0,
+        stopIndex: 1
+      }
+    });
+    expect(util.numCalls()).toEqual(1);
+    expect(util.startIndex()).toEqual(0);
+    expect(util.stopIndex()).toEqual(1);
+    helper({
+      callback: util.update,
+      indices: {
+        startIndex: 0,
+        stopIndex: 1
+      }
+    });
+    expect(util.numCalls()).toEqual(1);
+  });
+  it('should not call onRowsRendered if startIndex or stopIndex have changed', function () {
+    var util = new OnRowsRendered();
+    var helper = (0, _createCallbackMemoizer["default"])();
+    helper({
+      callback: util.update,
+      indices: {
+        startIndex: 0,
+        stopIndex: 1
+      }
+    });
+    expect(util.numCalls()).toEqual(1);
+    expect(util.startIndex()).toEqual(0);
+    expect(util.stopIndex()).toEqual(1);
+    helper({
+      callback: util.update,
+      indices: {
+        startIndex: 1,
+        stopIndex: 1
+      }
+    });
+    expect(util.numCalls()).toEqual(2);
+    expect(util.startIndex()).toEqual(1);
+    expect(util.stopIndex()).toEqual(1);
+    helper({
+      callback: util.update,
+      indices: {
+        startIndex: 1,
+        stopIndex: 2
+      }
+    });
+    expect(util.numCalls()).toEqual(3);
+    expect(util.startIndex()).toEqual(1);
+    expect(util.stopIndex()).toEqual(2);
+  });
+  it('should call onRowsRendered if :overscanCellsCount changes', function () {
+    var util = new OnRowsRendered();
+    var helper = (0, _createCallbackMemoizer["default"])();
+    helper({
+      callback: util.update,
+      indices: {
+        overscanStartIndex: 0,
+        overscanStopIndex: 2,
+        startIndex: 0,
+        stopIndex: 1
+      }
+    });
+    expect(util.numCalls()).toEqual(1);
+    expect(util.startIndex()).toEqual(0);
+    expect(util.stopIndex()).toEqual(1);
+    expect(util.overscanStartIndex()).toEqual(0);
+    expect(util.overscanStopIndex()).toEqual(2);
+    helper({
+      callback: util.update,
+      indices: {
+        overscanStartIndex: 0,
+        overscanStopIndex: 3,
+        startIndex: 0,
+        stopIndex: 1
+      }
+    });
+    expect(util.numCalls()).toEqual(2);
+    expect(util.startIndex()).toEqual(0);
+    expect(util.stopIndex()).toEqual(1);
+    expect(util.overscanStartIndex()).toEqual(0);
+    expect(util.overscanStopIndex()).toEqual(3);
+  });
+  it('should support an array of indices', function () {
+    var numCalls = 0;
+    var indices;
+    var callback = function callback(params) {
+      indices = params;
+      numCalls++;
+    };
+    var helper = (0, _createCallbackMemoizer["default"])();
+    helper({
+      callback: callback,
+      indices: [0, 1, 2]
+    });
+    expect(numCalls).toEqual(1);
+    expect(indices).toEqual([0, 1, 2]);
+    helper({
+      callback: callback,
+      indices: [0, 1]
+    });
+    expect(numCalls).toEqual(2);
+    expect(indices).toEqual([0, 1]);
+  });
+  it('should support an attribute containing an array of indices', function () {
+    var numCalls = 0;
+    var indices;
+    var callback = function callback(params) {
+      indices = params.indices;
+      numCalls++;
+    };
+    var helper = (0, _createCallbackMemoizer["default"])();
+    helper({
+      callback: callback,
+      indices: {
+        indices: [0, 1, 2]
+      }
+    });
+    expect(numCalls).toEqual(1);
+    expect(indices).toEqual([0, 1, 2]);
+    helper({
+      callback: callback,
+      indices: {
+        indices: [0, 1]
+      }
+    });
+    expect(numCalls).toEqual(2);
+    expect(indices).toEqual([0, 1]);
+  });
+});

package/dist/commonjs/utils/createCallbackMemoizer.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = createCallbackMemoizer;
+/**
+ * Helper utility that updates the specified callback whenever any of the specified indices have changed.
+ */
+function createCallbackMemoizer() {
+  var requireAllKeys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+  var cachedIndices = {};
+  return function (_ref) {
+    var callback = _ref.callback,
+      indices = _ref.indices;
+    var keys = Object.keys(indices);
+    var allInitialized = !requireAllKeys || keys.every(function (key) {
+      var value = indices[key];
+      return Array.isArray(value) ? value.length > 0 : value >= 0;
+    });
+    var indexChanged = keys.length !== Object.keys(cachedIndices).length || keys.some(function (key) {
+      var cachedValue = cachedIndices[key];
+      var value = indices[key];
+      return Array.isArray(value) ? cachedValue.join(',') !== value.join(',') : cachedValue !== value;
+    });
+    cachedIndices = indices;
+    if (allInitialized && indexChanged) {
+      callback(indices);
+    }
+  };
+}

package/dist/commonjs/utils/getUpdatedOffsetForIndex.jest.js

@@ -0,0 +1,68 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _getUpdatedOffsetForIndex = _interopRequireDefault(require("./getUpdatedOffsetForIndex"));
+var _TestHelper = require("./TestHelper");
+describe('getUpdatedOffsetForIndex', function () {
+  function testHelper(targetIndex, currentOffset) {
+    var cellMetadata = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : (0, _TestHelper.getCellMetadata)();
+    return (0, _getUpdatedOffsetForIndex["default"])({
+      cellOffset: cellMetadata[targetIndex].offset,
+      cellSize: cellMetadata[targetIndex].size,
+      containerSize: 50,
+      currentOffset: currentOffset
+    });
+  }
+  it('should scroll to the beginning', function () {
+    expect(testHelper(0, 100)).toEqual(0);
+  });
+  it('should scroll forward to the middle', function () {
+    expect(testHelper(4, 0)).toEqual(20);
+  });
+  it('should scroll backward to the middle', function () {
+    expect(testHelper(2, 100)).toEqual(30);
+  });
+  it('should not scroll if an item is already visible', function () {
+    expect(testHelper(2, 20)).toEqual(20);
+  });
+  it('should scroll to the end', function () {
+    expect(testHelper(8, 0)).toEqual(110);
+  });
+  it('should honor specified :align values', function () {
+    expect((0, _getUpdatedOffsetForIndex["default"])({
+      align: 'auto',
+      cellOffset: 50,
+      cellSize: 10,
+      containerSize: 50,
+      currentOffset: 0
+    })).toEqual(10);
+    expect((0, _getUpdatedOffsetForIndex["default"])({
+      align: 'start',
+      cellOffset: 50,
+      cellSize: 10,
+      containerSize: 50,
+      currentOffset: 0
+    })).toEqual(50);
+    expect((0, _getUpdatedOffsetForIndex["default"])({
+      align: 'auto',
+      cellOffset: 50,
+      cellSize: 10,
+      containerSize: 50,
+      currentOffset: 100
+    })).toEqual(50);
+    expect((0, _getUpdatedOffsetForIndex["default"])({
+      align: 'end',
+      cellOffset: 50,
+      cellSize: 10,
+      containerSize: 50,
+      currentOffset: 100
+    })).toEqual(10);
+    expect((0, _getUpdatedOffsetForIndex["default"])({
+      align: 'center',
+      cellOffset: 50,
+      cellSize: 10,
+      containerSize: 50,
+      currentOffset: 100
+    })).toEqual(30);
+  });
+});

package/dist/commonjs/utils/getUpdatedOffsetForIndex.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getUpdatedOffsetForIndex;
+/**
+ * Determines a new offset that ensures a certain cell is visible, given the current offset.
+ * If the cell is already visible then the current offset will be returned.
+ * If the current offset is too great or small, it will be adjusted just enough to ensure the specified index is visible.
+ *
+ * @param align Desired alignment within container; one of "auto" (default), "start", or "end"
+ * @param cellOffset Offset (x or y) position for cell
+ * @param cellSize Size (width or height) of cell
+ * @param containerSize Total size (width or height) of the container
+ * @param currentOffset Container's current (x or y) offset
+ * @return Offset to use to ensure the specified cell is visible
+ */
+function getUpdatedOffsetForIndex(_ref) {
+  var _ref$align = _ref.align,
+    align = _ref$align === void 0 ? 'auto' : _ref$align,
+    cellOffset = _ref.cellOffset,
+    cellSize = _ref.cellSize,
+    containerSize = _ref.containerSize,
+    currentOffset = _ref.currentOffset;
+  var maxOffset = cellOffset;
+  var minOffset = maxOffset - containerSize + cellSize;
+  switch (align) {
+    case 'start':
+      return maxOffset;
+    case 'end':
+      return minOffset;
+    case 'center':
+      return maxOffset - (containerSize - cellSize) / 2;
+    default:
+      return Math.max(minOffset, Math.min(maxOffset, currentOffset));
+  }
+}

package/dist/commonjs/utils/initCellMetadata.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = initCellMetadata;
+/**
+ * Initializes metadata for an axis and its cells.
+ * This data is used to determine which cells are visible given a container size and scroll position.
+ *
+ * @param cellCount Total number of cells.
+ * @param size Either a fixed size or a function that returns the size for a given given an index.
+ * @return Object mapping cell index to cell metadata (size, offset)
+ */
+function initCellMetadata(_ref) {
+  var cellCount = _ref.cellCount,
+    size = _ref.size;
+  var sizeGetter = typeof size === 'function' ? size : function () {
+    return size;
+  };
+  var cellMetadata = [];
+  var offset = 0;
+  for (var i = 0; i < cellCount; i++) {
+    var _size = sizeGetter({
+      index: i
+    });
+    if (_size == null || isNaN(_size)) {
+      throw Error("Invalid size returned for cell ".concat(i, " of value ").concat(_size));
+    }
+    cellMetadata[i] = {
+      size: _size,
+      offset: offset
+    };
+    offset += _size;
+  }
+  return cellMetadata;
+}

package/dist/commonjs/utils/requestAnimationTimeout.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.requestAnimationTimeout = exports.cancelAnimationTimeout = void 0;
+var _animationFrame = require("./animationFrame");
+/*:: export type AnimationTimeoutId = {
+  id: number,
+};*/
+var cancelAnimationTimeout = exports.cancelAnimationTimeout = function cancelAnimationTimeout(frame /*: AnimationTimeoutId*/) {
+  return (0, _animationFrame.caf)(frame.id);
+};
+
+/**
+ * Recursively calls requestAnimationFrame until a specified delay has been met or exceeded.
+ * When the delay time has been reached the function you're timing out will be called.
+ *
+ * Credit: Joe Lambert (https://gist.github.com/joelambert/1002116#file-requesttimeout-js)
+ */
+var requestAnimationTimeout = exports.requestAnimationTimeout = function requestAnimationTimeout(callback /*: Function*/, delay /*: number*/) /*: AnimationTimeoutId*/{
+  var start;
+  // wait for end of processing current event handler, because event handler may be long
+  Promise.resolve().then(function () {
+    start = Date.now();
+  });
+  var _timeout = function timeout() {
+    if (Date.now() - start >= delay) {
+      callback.call();
+    } else {
+      frame.id = (0, _animationFrame.raf)(_timeout);
+    }
+  };
+  var frame /*: AnimationTimeoutId*/ = {
+    id: (0, _animationFrame.raf)(_timeout)
+  };
+  return frame;
+};

package/dist/commonjs/vendor/binarySearchBounds.js

@@ -0,0 +1,200 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+/**
+ * Binary Search Bounds
+ * https://github.com/mikolalysenko/binary-search-bounds
+ * Mikola Lysenko
+ *
+ * Inlined because of Content Security Policy issue caused by the use of `new Function(...)` syntax.
+ * Issue reported here: https://github.com/mikolalysenko/binary-search-bounds/issues/5
+ **/
+
+function _GEA(a, l, h, y) {
+  var i = h + 1;
+  while (l <= h) {
+    var m = l + h >>> 1,
+      x = a[m];
+    if (x >= y) {
+      i = m;
+      h = m - 1;
+    } else {
+      l = m + 1;
+    }
+  }
+  return i;
+}
+function _GEP(a, l, h, y, c) {
+  var i = h + 1;
+  while (l <= h) {
+    var m = l + h >>> 1,
+      x = a[m];
+    if (c(x, y) >= 0) {
+      i = m;
+      h = m - 1;
+    } else {
+      l = m + 1;
+    }
+  }
+  return i;
+}
+function dispatchBsearchGE(a, y, c, l, h) {
+  if (typeof c === 'function') {
+    return _GEP(a, l === void 0 ? 0 : l | 0, h === void 0 ? a.length - 1 : h | 0, y, c);
+  } else {
+    return _GEA(a, c === void 0 ? 0 : c | 0, l === void 0 ? a.length - 1 : l | 0, y);
+  }
+}
+function _GTA(a, l, h, y) {
+  var i = h + 1;
+  while (l <= h) {
+    var m = l + h >>> 1,
+      x = a[m];
+    if (x > y) {
+      i = m;
+      h = m - 1;
+    } else {
+      l = m + 1;
+    }
+  }
+  return i;
+}
+function _GTP(a, l, h, y, c) {
+  var i = h + 1;
+  while (l <= h) {
+    var m = l + h >>> 1,
+      x = a[m];
+    if (c(x, y) > 0) {
+      i = m;
+      h = m - 1;
+    } else {
+      l = m + 1;
+    }
+  }
+  return i;
+}
+function dispatchBsearchGT(a, y, c, l, h) {
+  if (typeof c === 'function') {
+    return _GTP(a, l === void 0 ? 0 : l | 0, h === void 0 ? a.length - 1 : h | 0, y, c);
+  } else {
+    return _GTA(a, c === void 0 ? 0 : c | 0, l === void 0 ? a.length - 1 : l | 0, y);
+  }
+}
+function _LTA(a, l, h, y) {
+  var i = l - 1;
+  while (l <= h) {
+    var m = l + h >>> 1,
+      x = a[m];
+    if (x < y) {
+      i = m;
+      l = m + 1;
+    } else {
+      h = m - 1;
+    }
+  }
+  return i;
+}
+function _LTP(a, l, h, y, c) {
+  var i = l - 1;
+  while (l <= h) {
+    var m = l + h >>> 1,
+      x = a[m];
+    if (c(x, y) < 0) {
+      i = m;
+      l = m + 1;
+    } else {
+      h = m - 1;
+    }
+  }
+  return i;
+}
+function dispatchBsearchLT(a, y, c, l, h) {
+  if (typeof c === 'function') {
+    return _LTP(a, l === void 0 ? 0 : l | 0, h === void 0 ? a.length - 1 : h | 0, y, c);
+  } else {
+    return _LTA(a, c === void 0 ? 0 : c | 0, l === void 0 ? a.length - 1 : l | 0, y);
+  }
+}
+function _LEA(a, l, h, y) {
+  var i = l - 1;
+  while (l <= h) {
+    var m = l + h >>> 1,
+      x = a[m];
+    if (x <= y) {
+      i = m;
+      l = m + 1;
+    } else {
+      h = m - 1;
+    }
+  }
+  return i;
+}
+function _LEP(a, l, h, y, c) {
+  var i = l - 1;
+  while (l <= h) {
+    var m = l + h >>> 1,
+      x = a[m];
+    if (c(x, y) <= 0) {
+      i = m;
+      l = m + 1;
+    } else {
+      h = m - 1;
+    }
+  }
+  return i;
+}
+function dispatchBsearchLE(a, y, c, l, h) {
+  if (typeof c === 'function') {
+    return _LEP(a, l === void 0 ? 0 : l | 0, h === void 0 ? a.length - 1 : h | 0, y, c);
+  } else {
+    return _LEA(a, c === void 0 ? 0 : c | 0, l === void 0 ? a.length - 1 : l | 0, y);
+  }
+}
+function _EQA(a, l, h, y) {
+  l - 1;
+  while (l <= h) {
+    var m = l + h >>> 1,
+      x = a[m];
+    if (x === y) {
+      return m;
+    } else if (x <= y) {
+      l = m + 1;
+    } else {
+      h = m - 1;
+    }
+  }
+  return -1;
+}
+function _EQP(a, l, h, y, c) {
+  l - 1;
+  while (l <= h) {
+    var m = l + h >>> 1,
+      x = a[m];
+    var p = c(x, y);
+    if (p === 0) {
+      return m;
+    } else if (p <= 0) {
+      l = m + 1;
+    } else {
+      h = m - 1;
+    }
+  }
+  return -1;
+}
+function dispatchBsearchEQ(a, y, c, l, h) {
+  if (typeof c === 'function') {
+    return _EQP(a, l === void 0 ? 0 : l | 0, h === void 0 ? a.length - 1 : h | 0, y, c);
+  } else {
+    return _EQA(a, c === void 0 ? 0 : c | 0, l === void 0 ? a.length - 1 : l | 0, y);
+  }
+}
+var _default = exports["default"] = {
+  ge: dispatchBsearchGE,
+  gt: dispatchBsearchGT,
+  lt: dispatchBsearchLT,
+  le: dispatchBsearchLE,
+  eq: dispatchBsearchEQ
+};