@depup/react-virtualized 9.22.6-depup.0

package/dist/commonjs/WindowScroller/WindowScroller.js

@@ -0,0 +1,268 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.IS_SCROLLING_TIMEOUT = 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 _onScroll = require("./utils/onScroll");
+var _dimensions = require("./utils/dimensions");
+var _detectElementResize = _interopRequireDefault(require("../vendor/detectElementResize"));
+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 ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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; })(); }
+/*:: type Props = {
+  /**
+   * Function responsible for rendering children.
+   * This function should implement the following signature:
+   * ({ height, isScrolling, scrollLeft, scrollTop, width }) => PropTypes.element
+   *-/
+  children: ({
+    onChildScroll: ({scrollTop: number}) => void,
+    registerChild: (?Element) => void,
+    height: number,
+    isScrolling: boolean,
+    scrollLeft: number,
+    scrollTop: number,
+    width: number,
+  }) => React.Node,
+
+  /** Callback to be invoked on-resize: ({ height, width }) *-/
+  onResize: ({height: number, width: number}) => void,
+
+  /** Callback to be invoked on-scroll: ({ scrollLeft, scrollTop }) *-/
+  onScroll: ({scrollLeft: number, scrollTop: number}) => void,
+
+  /** Element to attach scroll event listeners. Defaults to window. *-/
+  scrollElement: ?(typeof window | Element),
+  /**
+   * Wait this amount of time after the last scroll event before resetting child `pointer-events`.
+   *-/
+  scrollingResetTimeInterval: number,
+
+  /** Height used for server-side rendering *-/
+  serverHeight: number,
+
+  /** Width used for server-side rendering *-/
+  serverWidth: number,
+
+  /** Force scrollTop updates when .updatePosition is called, fixing forced header height change updates *-/
+  updateScrollTopOnUpdatePosition?: boolean,
+};*/
+/*:: type State = {
+  height: number,
+  width: number,
+  isScrolling: boolean,
+  scrollLeft: number,
+  scrollTop: number,
+};*/
+/*:: type ResizeHandler = (element: Element, onResize: () => void) => void;*/
+/*:: type DetectElementResize = {
+  addResizeListener: ResizeHandler,
+  removeResizeListener: ResizeHandler,
+};*/
+/**
+ * Specifies the number of milliseconds during which to disable pointer events while a scroll is in progress.
+ * This improves performance and makes scrolling smoother.
+ */
+var IS_SCROLLING_TIMEOUT = exports.IS_SCROLLING_TIMEOUT = 150;
+var getWindow = function getWindow() {
+  return typeof window !== 'undefined' ? window : undefined;
+};
+var WindowScroller = exports["default"] = /*#__PURE__*/function (_React$PureComponent) {
+  function WindowScroller() {
+    var _this;
+    (0, _classCallCheck2["default"])(this, WindowScroller);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _callSuper(this, WindowScroller, [].concat(args));
+    (0, _defineProperty2["default"])(_this, "_window", getWindow());
+    (0, _defineProperty2["default"])(_this, "_isMounted", false);
+    (0, _defineProperty2["default"])(_this, "_positionFromTop", 0);
+    (0, _defineProperty2["default"])(_this, "_positionFromLeft", 0);
+    (0, _defineProperty2["default"])(_this, "_detectElementResize", void 0);
+    (0, _defineProperty2["default"])(_this, "_child", void 0);
+    (0, _defineProperty2["default"])(_this, "_windowScrollerRef", /*#__PURE__*/React.createRef());
+    (0, _defineProperty2["default"])(_this, "state", _objectSpread(_objectSpread({}, (0, _dimensions.getDimensions)(_this.props.scrollElement, _this.props)), {}, {
+      isScrolling: false,
+      scrollLeft: 0,
+      scrollTop: 0
+    }));
+    (0, _defineProperty2["default"])(_this, "_registerChild", function (element) {
+      if (element && !(element instanceof Element)) {
+        console.warn('WindowScroller registerChild expects to be passed Element or null');
+      }
+      _this._child = element;
+      _this.updatePosition();
+    });
+    (0, _defineProperty2["default"])(_this, "_onChildScroll", function (_ref) {
+      var scrollTop = _ref.scrollTop;
+      if (_this.state.scrollTop === scrollTop) {
+        return;
+      }
+      var scrollElement = _this.props.scrollElement;
+      if (scrollElement) {
+        if (typeof scrollElement.scrollTo === 'function') {
+          scrollElement.scrollTo(0, scrollTop + _this._positionFromTop);
+        } else {
+          scrollElement.scrollTop = scrollTop + _this._positionFromTop;
+        }
+      }
+    });
+    (0, _defineProperty2["default"])(_this, "_registerResizeListener", function (element) {
+      if (element === window) {
+        window.addEventListener('resize', _this._onResize, false);
+      } else {
+        _this._detectElementResize.addResizeListener(element, _this._onResize);
+      }
+    });
+    (0, _defineProperty2["default"])(_this, "_unregisterResizeListener", function (element) {
+      if (element === window) {
+        window.removeEventListener('resize', _this._onResize, false);
+      } else if (element) {
+        _this._detectElementResize.removeResizeListener(element, _this._onResize);
+      }
+    });
+    (0, _defineProperty2["default"])(_this, "_onResize", function () {
+      _this.updatePosition();
+    });
+    // Referenced by utils/onScroll
+    (0, _defineProperty2["default"])(_this, "__handleWindowScrollEvent", function () {
+      if (!_this._isMounted) {
+        return;
+      }
+      var onScroll = _this.props.onScroll;
+      var scrollElement = _this.props.scrollElement;
+      if (scrollElement) {
+        var scrollOffset = (0, _dimensions.getScrollOffset)(scrollElement);
+        var scrollLeft = Math.max(0, scrollOffset.left - _this._positionFromLeft);
+        var scrollTop = Math.max(0, scrollOffset.top - _this._positionFromTop);
+        _this.setState({
+          isScrolling: true,
+          scrollLeft: scrollLeft,
+          scrollTop: scrollTop
+        });
+        onScroll({
+          scrollLeft: scrollLeft,
+          scrollTop: scrollTop
+        });
+      }
+    });
+    // Referenced by utils/onScroll
+    (0, _defineProperty2["default"])(_this, "__resetIsScrolling", function () {
+      _this.setState({
+        isScrolling: false
+      });
+    });
+    return _this;
+  }
+  (0, _inherits2["default"])(WindowScroller, _React$PureComponent);
+  return (0, _createClass2["default"])(WindowScroller, [{
+    key: "updatePosition",
+    value: function updatePosition() {
+      var scrollElement /*: ?Element*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props.scrollElement;
+      var onResize = this.props.onResize;
+      var _this$state = this.state,
+        height = _this$state.height,
+        width = _this$state.width;
+      var thisNode = this._child || this._windowScrollerRef.current;
+      if (thisNode instanceof Element && scrollElement) {
+        var offset = (0, _dimensions.getPositionOffset)(thisNode, scrollElement);
+        this._positionFromTop = offset.top;
+        this._positionFromLeft = offset.left;
+      }
+      var dimensions = (0, _dimensions.getDimensions)(scrollElement, this.props);
+      if (height !== dimensions.height || width !== dimensions.width) {
+        this.setState({
+          height: dimensions.height,
+          width: dimensions.width
+        });
+        onResize({
+          height: dimensions.height,
+          width: dimensions.width
+        });
+      }
+      if (this.props.updateScrollTopOnUpdatePosition === true) {
+        this.__handleWindowScrollEvent();
+        this.__resetIsScrolling();
+      }
+    }
+  }, {
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var scrollElement = this.props.scrollElement;
+      this._detectElementResize = (0, _detectElementResize["default"])();
+      this.updatePosition(scrollElement);
+      if (scrollElement) {
+        (0, _onScroll.registerScrollListener)(this, scrollElement);
+        this._registerResizeListener(scrollElement);
+      }
+      this._isMounted = true;
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps /*: Props*/, prevState /*: State*/) {
+      var scrollElement = this.props.scrollElement;
+      var prevScrollElement = prevProps.scrollElement;
+      if (prevScrollElement !== scrollElement && prevScrollElement != null && scrollElement != null) {
+        this.updatePosition(scrollElement);
+        (0, _onScroll.unregisterScrollListener)(this, prevScrollElement);
+        (0, _onScroll.registerScrollListener)(this, scrollElement);
+        this._unregisterResizeListener(prevScrollElement);
+        this._registerResizeListener(scrollElement);
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      var scrollElement = this.props.scrollElement;
+      if (scrollElement) {
+        (0, _onScroll.unregisterScrollListener)(this, scrollElement);
+        this._unregisterResizeListener(scrollElement);
+      }
+      this._isMounted = false;
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var children = this.props.children;
+      var _this$state2 = this.state,
+        isScrolling = _this$state2.isScrolling,
+        scrollTop = _this$state2.scrollTop,
+        scrollLeft = _this$state2.scrollLeft,
+        height = _this$state2.height,
+        width = _this$state2.width;
+      return /*#__PURE__*/React.createElement('div', {
+        ref: this._windowScrollerRef
+      }, children({
+        onChildScroll: this._onChildScroll,
+        registerChild: this._registerChild,
+        height: height,
+        isScrolling: isScrolling,
+        scrollLeft: scrollLeft,
+        scrollTop: scrollTop,
+        width: width
+      }));
+    }
+  }]);
+}(React.PureComponent);
+(0, _defineProperty2["default"])(WindowScroller, "defaultProps", {
+  onResize: function onResize() {},
+  onScroll: function onScroll() {},
+  scrollingResetTimeInterval: IS_SCROLLING_TIMEOUT,
+  scrollElement: getWindow(),
+  serverHeight: 0,
+  serverWidth: 0
+});

package/dist/commonjs/WindowScroller/WindowScroller.ssr.js

@@ -0,0 +1,25 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+var React = _interopRequireWildcard(require("react"));
+var ReactDOMServer = _interopRequireWildcard(require("react-dom/server"));
+var _WindowScroller = _interopRequireDefault(require("./WindowScroller"));
+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; }
+/**
+ * @jest-environment node
+ */
+
+test('should render content with default widths and heights initially', function () {
+  var rendered = ReactDOMServer.renderToString(/*#__PURE__*/React.createElement(_WindowScroller["default"], {
+    serverHeight: 100,
+    serverWidth: 200
+  }, function (_ref) {
+    var height = _ref.height,
+      width = _ref.width;
+    return /*#__PURE__*/React.createElement("div", null, "height:".concat(height, ";width:").concat(width));
+  }));
+  expect(rendered).toContain('height:100');
+  expect(rendered).toContain('width:200');
+});

package/dist/commonjs/WindowScroller/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "IS_SCROLLING_TIMEOUT", {
+  enumerable: true,
+  get: function get() {
+    return _WindowScroller.IS_SCROLLING_TIMEOUT;
+  }
+});
+Object.defineProperty(exports, "WindowScroller", {
+  enumerable: true,
+  get: function get() {
+    return _WindowScroller["default"];
+  }
+});
+exports["default"] = void 0;
+var _WindowScroller = _interopRequireWildcard(require("./WindowScroller"));
+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; }
+var _default = exports["default"] = _WindowScroller["default"];

package/dist/commonjs/WindowScroller/utils/dimensions.js

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDimensions = getDimensions;
+exports.getPositionOffset = getPositionOffset;
+exports.getScrollOffset = getScrollOffset;
+/**
+ * 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,
+};*/
+var isWindow = function isWindow(element) {
+  return element === window;
+};
+var getBoundingBox = function getBoundingBox(element) {
+  return element.getBoundingClientRect();
+};
+function getDimensions(scrollElement /*: ?Element*/, props /*: WindowScrollerProps*/) /*: Dimensions*/{
+  if (!scrollElement) {
+    return {
+      height: props.serverHeight,
+      width: props.serverWidth
+    };
+  } else if (isWindow(scrollElement)) {
+    var _window = window,
+      innerHeight = _window.innerHeight,
+      innerWidth = _window.innerWidth;
+    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).
+ */
+function getPositionOffset(element /*: Element*/, container /*: Element*/) {
+  if (isWindow(container) && document.documentElement) {
+    var containerElement = document.documentElement;
+    var elementRect = getBoundingBox(element);
+    var containerRect = getBoundingBox(containerElement);
+    return {
+      top: elementRect.top - containerRect.top,
+      left: elementRect.left - containerRect.left
+    };
+  } else {
+    var scrollOffset = getScrollOffset(container);
+    var _elementRect = getBoundingBox(element);
+    var _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.
+ */
+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/commonjs/WindowScroller/utils/onScroll.js

@@ -0,0 +1,70 @@
+"use strict";
+'no babel-plugin-flow-react-proptypes';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.registerScrollListener = registerScrollListener;
+exports.unregisterScrollListener = unregisterScrollListener;
+var _requestAnimationTimeout = require("../../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) {
+    (0, _requestAnimationTimeout.cancelAnimationTimeout)(disablePointerEventsTimeoutId);
+  }
+  var maximumTimeout = 0;
+  mountedInstances.forEach(function (instance) {
+    maximumTimeout = Math.max(maximumTimeout, instance.props.scrollingResetTimeInterval);
+  });
+  disablePointerEventsTimeoutId = (0, _requestAnimationTimeout.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();
+    }
+  });
+}
+function registerScrollListener(component /*: WindowScroller*/, element /*: Element*/) {
+  if (!mountedInstances.some(function (instance) {
+    return instance.props.scrollElement === element;
+  })) {
+    element.addEventListener('scroll', onScrollWindow);
+  }
+  mountedInstances.push(component);
+}
+function unregisterScrollListener(component /*: WindowScroller*/, element /*: Element*/) {
+  mountedInstances = mountedInstances.filter(function (instance) {
+    return instance !== component;
+  });
+  if (!mountedInstances.length) {
+    element.removeEventListener('scroll', onScrollWindow);
+    if (disablePointerEventsTimeoutId) {
+      (0, _requestAnimationTimeout.cancelAnimationTimeout)(disablePointerEventsTimeoutId);
+      enablePointerEventsIfDisabled();
+    }
+  }
+}

package/dist/commonjs/index.js

@@ -0,0 +1,180 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ArrowKeyStepper", {
+  enumerable: true,
+  get: function get() {
+    return _ArrowKeyStepper.ArrowKeyStepper;
+  }
+});
+Object.defineProperty(exports, "AutoSizer", {
+  enumerable: true,
+  get: function get() {
+    return _AutoSizer.AutoSizer;
+  }
+});
+Object.defineProperty(exports, "CellMeasurer", {
+  enumerable: true,
+  get: function get() {
+    return _CellMeasurer.CellMeasurer;
+  }
+});
+Object.defineProperty(exports, "CellMeasurerCache", {
+  enumerable: true,
+  get: function get() {
+    return _CellMeasurer.CellMeasurerCache;
+  }
+});
+Object.defineProperty(exports, "Collection", {
+  enumerable: true,
+  get: function get() {
+    return _Collection.Collection;
+  }
+});
+Object.defineProperty(exports, "Column", {
+  enumerable: true,
+  get: function get() {
+    return _Table.Column;
+  }
+});
+Object.defineProperty(exports, "ColumnSizer", {
+  enumerable: true,
+  get: function get() {
+    return _ColumnSizer.ColumnSizer;
+  }
+});
+Object.defineProperty(exports, "Grid", {
+  enumerable: true,
+  get: function get() {
+    return _Grid.Grid;
+  }
+});
+Object.defineProperty(exports, "InfiniteLoader", {
+  enumerable: true,
+  get: function get() {
+    return _InfiniteLoader.InfiniteLoader;
+  }
+});
+Object.defineProperty(exports, "List", {
+  enumerable: true,
+  get: function get() {
+    return _List.List;
+  }
+});
+Object.defineProperty(exports, "Masonry", {
+  enumerable: true,
+  get: function get() {
+    return _Masonry.Masonry;
+  }
+});
+Object.defineProperty(exports, "MultiGrid", {
+  enumerable: true,
+  get: function get() {
+    return _MultiGrid.MultiGrid;
+  }
+});
+Object.defineProperty(exports, "ScrollSync", {
+  enumerable: true,
+  get: function get() {
+    return _ScrollSync.ScrollSync;
+  }
+});
+Object.defineProperty(exports, "SortDirection", {
+  enumerable: true,
+  get: function get() {
+    return _Table.SortDirection;
+  }
+});
+Object.defineProperty(exports, "SortIndicator", {
+  enumerable: true,
+  get: function get() {
+    return _Table.SortIndicator;
+  }
+});
+Object.defineProperty(exports, "Table", {
+  enumerable: true,
+  get: function get() {
+    return _Table.Table;
+  }
+});
+Object.defineProperty(exports, "WindowScroller", {
+  enumerable: true,
+  get: function get() {
+    return _WindowScroller.WindowScroller;
+  }
+});
+Object.defineProperty(exports, "accessibilityOverscanIndicesGetter", {
+  enumerable: true,
+  get: function get() {
+    return _Grid.accessibilityOverscanIndicesGetter;
+  }
+});
+Object.defineProperty(exports, "createMasonryCellPositioner", {
+  enumerable: true,
+  get: function get() {
+    return _Masonry.createCellPositioner;
+  }
+});
+Object.defineProperty(exports, "createTableMultiSort", {
+  enumerable: true,
+  get: function get() {
+    return _Table.createMultiSort;
+  }
+});
+Object.defineProperty(exports, "defaultCellRangeRenderer", {
+  enumerable: true,
+  get: function get() {
+    return _Grid.defaultCellRangeRenderer;
+  }
+});
+Object.defineProperty(exports, "defaultOverscanIndicesGetter", {
+  enumerable: true,
+  get: function get() {
+    return _Grid.defaultOverscanIndicesGetter;
+  }
+});
+Object.defineProperty(exports, "defaultTableCellDataGetter", {
+  enumerable: true,
+  get: function get() {
+    return _Table.defaultCellDataGetter;
+  }
+});
+Object.defineProperty(exports, "defaultTableCellRenderer", {
+  enumerable: true,
+  get: function get() {
+    return _Table.defaultCellRenderer;
+  }
+});
+Object.defineProperty(exports, "defaultTableHeaderRenderer", {
+  enumerable: true,
+  get: function get() {
+    return _Table.defaultHeaderRenderer;
+  }
+});
+Object.defineProperty(exports, "defaultTableHeaderRowRenderer", {
+  enumerable: true,
+  get: function get() {
+    return _Table.defaultHeaderRowRenderer;
+  }
+});
+Object.defineProperty(exports, "defaultTableRowRenderer", {
+  enumerable: true,
+  get: function get() {
+    return _Table.defaultRowRenderer;
+  }
+});
+var _ArrowKeyStepper = require("./ArrowKeyStepper");
+var _AutoSizer = require("./AutoSizer");
+var _CellMeasurer = require("./CellMeasurer");
+var _Collection = require("./Collection");
+var _ColumnSizer = require("./ColumnSizer");
+var _Grid = require("./Grid");
+var _InfiniteLoader = require("./InfiniteLoader");
+var _List = require("./List");
+var _Masonry = require("./Masonry");
+var _MultiGrid = require("./MultiGrid");
+var _ScrollSync = require("./ScrollSync");
+var _Table = require("./Table");
+var _WindowScroller = require("./WindowScroller");

package/dist/commonjs/jest-setup.js

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