@depup/react-virtualized 9.22.6-depup.0

package/dist/es/WindowScroller/utils/dimensions.js.flow

@@ -0,0 +1,91 @@
+// @flow
+
+/**
+ * Gets the dimensions of the element, accounting for API differences between
+ * `window` and other DOM elements.
+ */
+
+type Dimensions = {
+  height: number,
+  width: number,
+};
+
+// TODO Move this into WindowScroller and import from there
+type WindowScrollerProps = {
+  serverHeight: number,
+  serverWidth: number,
+};
+
+const isWindow = element => element === window;
+
+const getBoundingBox = element => element.getBoundingClientRect();
+
+export function getDimensions(
+  scrollElement: ?Element,
+  props: WindowScrollerProps,
+): Dimensions {
+  if (!scrollElement) {
+    return {
+      height: props.serverHeight,
+      width: props.serverWidth,
+    };
+  } else if (isWindow(scrollElement)) {
+    const {innerHeight, innerWidth} = window;
+    return {
+      height: typeof innerHeight === 'number' ? innerHeight : 0,
+      width: typeof innerWidth === 'number' ? innerWidth : 0,
+    };
+  } else {
+    return getBoundingBox(scrollElement);
+  }
+}
+
+/**
+ * Gets the vertical and horizontal position of an element within its scroll container.
+ * Elements that have been “scrolled past” return negative values.
+ * Handles edge-case where a user is navigating back (history) from an already-scrolled page.
+ * In this case the body’s top or left position will be a negative number and this element’s top or left will be increased (by that amount).
+ */
+export function getPositionOffset(element: Element, container: Element) {
+  if (isWindow(container) && document.documentElement) {
+    const containerElement = document.documentElement;
+    const elementRect = getBoundingBox(element);
+    const containerRect = getBoundingBox(containerElement);
+    return {
+      top: elementRect.top - containerRect.top,
+      left: elementRect.left - containerRect.left,
+    };
+  } else {
+    const scrollOffset = getScrollOffset(container);
+    const elementRect = getBoundingBox(element);
+    const containerRect = getBoundingBox(container);
+    return {
+      top: elementRect.top + scrollOffset.top - containerRect.top,
+      left: elementRect.left + scrollOffset.left - containerRect.left,
+    };
+  }
+}
+
+/**
+ * Gets the vertical and horizontal scroll amount of the element, accounting for IE compatibility
+ * and API differences between `window` and other DOM elements.
+ */
+export function getScrollOffset(element: Element) {
+  if (isWindow(element) && document.documentElement) {
+    return {
+      top:
+        'scrollY' in window
+          ? window.scrollY
+          : document.documentElement.scrollTop,
+      left:
+        'scrollX' in window
+          ? window.scrollX
+          : document.documentElement.scrollLeft,
+    };
+  } else {
+    return {
+      top: element.scrollTop,
+      left: element.scrollLeft,
+    };
+  }
+}

package/dist/es/WindowScroller/utils/onScroll.js

@@ -0,0 +1,64 @@
+'no babel-plugin-flow-react-proptypes';
+
+import { requestAnimationTimeout, cancelAnimationTimeout } from '../../utils/requestAnimationTimeout';
+/*:: import type WindowScroller from '../WindowScroller.js';*/
+var mountedInstances = [];
+var originalBodyPointerEvents = null;
+var disablePointerEventsTimeoutId = null;
+function enablePointerEventsIfDisabled() {
+  if (disablePointerEventsTimeoutId) {
+    disablePointerEventsTimeoutId = null;
+    if (document.body && originalBodyPointerEvents != null) {
+      document.body.style.pointerEvents = originalBodyPointerEvents;
+    }
+    originalBodyPointerEvents = null;
+  }
+}
+function enablePointerEventsAfterDelayCallback() {
+  enablePointerEventsIfDisabled();
+  mountedInstances.forEach(function (instance) {
+    return instance.__resetIsScrolling();
+  });
+}
+function enablePointerEventsAfterDelay() {
+  if (disablePointerEventsTimeoutId) {
+    cancelAnimationTimeout(disablePointerEventsTimeoutId);
+  }
+  var maximumTimeout = 0;
+  mountedInstances.forEach(function (instance) {
+    maximumTimeout = Math.max(maximumTimeout, instance.props.scrollingResetTimeInterval);
+  });
+  disablePointerEventsTimeoutId = requestAnimationTimeout(enablePointerEventsAfterDelayCallback, maximumTimeout);
+}
+function onScrollWindow(event /*: Event*/) {
+  if (event.currentTarget === window && originalBodyPointerEvents == null && document.body) {
+    originalBodyPointerEvents = document.body.style.pointerEvents;
+    document.body.style.pointerEvents = 'none';
+  }
+  enablePointerEventsAfterDelay();
+  mountedInstances.forEach(function (instance) {
+    if (instance.props.scrollElement === event.currentTarget) {
+      instance.__handleWindowScrollEvent();
+    }
+  });
+}
+export function registerScrollListener(component /*: WindowScroller*/, element /*: Element*/) {
+  if (!mountedInstances.some(function (instance) {
+    return instance.props.scrollElement === element;
+  })) {
+    element.addEventListener('scroll', onScrollWindow);
+  }
+  mountedInstances.push(component);
+}
+export function unregisterScrollListener(component /*: WindowScroller*/, element /*: Element*/) {
+  mountedInstances = mountedInstances.filter(function (instance) {
+    return instance !== component;
+  });
+  if (!mountedInstances.length) {
+    element.removeEventListener('scroll', onScrollWindow);
+    if (disablePointerEventsTimeoutId) {
+      cancelAnimationTimeout(disablePointerEventsTimeoutId);
+      enablePointerEventsIfDisabled();
+    }
+  }
+}

package/dist/es/WindowScroller/utils/onScroll.js.flow

@@ -0,0 +1,94 @@
+// @flow
+'no babel-plugin-flow-react-proptypes';
+
+import {
+  requestAnimationTimeout,
+  cancelAnimationTimeout,
+} from '../../utils/requestAnimationTimeout';
+import type WindowScroller from '../WindowScroller.js';
+
+let mountedInstances = [];
+let originalBodyPointerEvents = null;
+let disablePointerEventsTimeoutId = null;
+
+function enablePointerEventsIfDisabled() {
+  if (disablePointerEventsTimeoutId) {
+    disablePointerEventsTimeoutId = null;
+
+    if (document.body && originalBodyPointerEvents != null) {
+      document.body.style.pointerEvents = originalBodyPointerEvents;
+    }
+
+    originalBodyPointerEvents = null;
+  }
+}
+
+function enablePointerEventsAfterDelayCallback() {
+  enablePointerEventsIfDisabled();
+  mountedInstances.forEach(instance => instance.__resetIsScrolling());
+}
+
+function enablePointerEventsAfterDelay() {
+  if (disablePointerEventsTimeoutId) {
+    cancelAnimationTimeout(disablePointerEventsTimeoutId);
+  }
+
+  var maximumTimeout = 0;
+  mountedInstances.forEach(instance => {
+    maximumTimeout = Math.max(
+      maximumTimeout,
+      instance.props.scrollingResetTimeInterval,
+    );
+  });
+
+  disablePointerEventsTimeoutId = requestAnimationTimeout(
+    enablePointerEventsAfterDelayCallback,
+    maximumTimeout,
+  );
+}
+
+function onScrollWindow(event: Event) {
+  if (
+    event.currentTarget === window &&
+    originalBodyPointerEvents == null &&
+    document.body
+  ) {
+    originalBodyPointerEvents = document.body.style.pointerEvents;
+
+    document.body.style.pointerEvents = 'none';
+  }
+  enablePointerEventsAfterDelay();
+  mountedInstances.forEach(instance => {
+    if (instance.props.scrollElement === event.currentTarget) {
+      instance.__handleWindowScrollEvent();
+    }
+  });
+}
+
+export function registerScrollListener(
+  component: WindowScroller,
+  element: Element,
+) {
+  if (
+    !mountedInstances.some(instance => instance.props.scrollElement === element)
+  ) {
+    element.addEventListener('scroll', onScrollWindow);
+  }
+  mountedInstances.push(component);
+}
+
+export function unregisterScrollListener(
+  component: WindowScroller,
+  element: Element,
+) {
+  mountedInstances = mountedInstances.filter(
+    instance => instance !== component,
+  );
+  if (!mountedInstances.length) {
+    element.removeEventListener('scroll', onScrollWindow);
+    if (disablePointerEventsTimeoutId) {
+      cancelAnimationTimeout(disablePointerEventsTimeoutId);
+      enablePointerEventsIfDisabled();
+    }
+  }
+}

package/dist/es/index.js

@@ -0,0 +1,13 @@
+export { ArrowKeyStepper } from './ArrowKeyStepper';
+export { AutoSizer } from './AutoSizer';
+export { CellMeasurer, CellMeasurerCache } from './CellMeasurer';
+export { Collection } from './Collection';
+export { ColumnSizer } from './ColumnSizer';
+export { accessibilityOverscanIndicesGetter, defaultCellRangeRenderer, defaultOverscanIndicesGetter, Grid } from './Grid';
+export { InfiniteLoader } from './InfiniteLoader';
+export { List } from './List';
+export { createCellPositioner as createMasonryCellPositioner, Masonry } from './Masonry';
+export { MultiGrid } from './MultiGrid';
+export { ScrollSync } from './ScrollSync';
+export { createMultiSort as createTableMultiSort, defaultCellDataGetter as defaultTableCellDataGetter, defaultCellRenderer as defaultTableCellRenderer, defaultHeaderRenderer as defaultTableHeaderRenderer, defaultHeaderRowRenderer as defaultTableHeaderRowRenderer, defaultRowRenderer as defaultTableRowRenderer, Table, Column, SortDirection, SortIndicator } from './Table';
+export { WindowScroller } from './WindowScroller';

package/dist/es/jest-setup.js

@@ -0,0 +1,5 @@
+jest.mock('dom-helpers/scrollbarSize', function () {
+  return function getScrollbarSize() {
+    return 20;
+  };
+});

package/dist/es/utils/TestHelper.js

@@ -0,0 +1,30 @@
+import initCellMetadata from './initCellMetadata';
+
+// Default cell sizes and offsets for use in below tests
+export 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 initCellMetadata({
+    cellCount: cellSizes.length,
+    size: function size(_ref) {
+      var index = _ref.index;
+      return cellSizes[index];
+    }
+  });
+}

package/dist/es/utils/animationFrame.js

@@ -0,0 +1,23 @@
+/*:: 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);
+};
+export var raf /*: RequestAnimationFrame*/ = (request /*: any*/);
+export var caf /*: CancelAnimationFrame*/ = (cancel /*: any*/);

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

@@ -0,0 +1,216 @@
+import createCallbackMemoizer from './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 = createCallbackMemoizer();
+    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 = createCallbackMemoizer();
+    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 = createCallbackMemoizer(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 = createCallbackMemoizer();
+    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 = createCallbackMemoizer();
+    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 = createCallbackMemoizer();
+    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 = createCallbackMemoizer();
+    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 = createCallbackMemoizer();
+    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/es/utils/createCallbackMemoizer.js

@@ -0,0 +1,25 @@
+/**
+ * Helper utility that updates the specified callback whenever any of the specified indices have changed.
+ */
+export default 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/es/utils/getUpdatedOffsetForIndex.jest.js

@@ -0,0 +1,65 @@
+import getUpdatedOffsetForIndex from './getUpdatedOffsetForIndex';
+import { getCellMetadata } from './TestHelper';
+describe('getUpdatedOffsetForIndex', function () {
+  function testHelper(targetIndex, currentOffset) {
+    var cellMetadata = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : getCellMetadata();
+    return getUpdatedOffsetForIndex({
+      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(getUpdatedOffsetForIndex({
+      align: 'auto',
+      cellOffset: 50,
+      cellSize: 10,
+      containerSize: 50,
+      currentOffset: 0
+    })).toEqual(10);
+    expect(getUpdatedOffsetForIndex({
+      align: 'start',
+      cellOffset: 50,
+      cellSize: 10,
+      containerSize: 50,
+      currentOffset: 0
+    })).toEqual(50);
+    expect(getUpdatedOffsetForIndex({
+      align: 'auto',
+      cellOffset: 50,
+      cellSize: 10,
+      containerSize: 50,
+      currentOffset: 100
+    })).toEqual(50);
+    expect(getUpdatedOffsetForIndex({
+      align: 'end',
+      cellOffset: 50,
+      cellSize: 10,
+      containerSize: 50,
+      currentOffset: 100
+    })).toEqual(10);
+    expect(getUpdatedOffsetForIndex({
+      align: 'center',
+      cellOffset: 50,
+      cellSize: 10,
+      containerSize: 50,
+      currentOffset: 100
+    })).toEqual(30);
+  });
+});

package/dist/es/utils/getUpdatedOffsetForIndex.js

@@ -0,0 +1,32 @@
+/**
+ * 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
+ */
+export default 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/es/utils/initCellMetadata.js

@@ -0,0 +1,31 @@
+/**
+ * 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)
+ */
+export default 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;
+}