@depup/react-virtualized 9.22.6-depup.0

package/dist/commonjs/Grid/Grid.ssr.js

@@ -0,0 +1,62 @@
+"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 _Grid = _interopRequireDefault(require("./Grid"));
+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
+ */
+/*:: declare var test: any;*/
+/*:: declare var expect: any;*/
+test('should render Grid with dom server', function () {
+  var rendered = ReactDOMServer.renderToString(/*#__PURE__*/React.createElement(_Grid["default"], {
+    cellRenderer: function cellRenderer(_ref) {
+      var style = _ref.style,
+        key = _ref.key,
+        rowIndex = _ref.rowIndex,
+        columnIndex = _ref.columnIndex;
+      return /*#__PURE__*/React.createElement("div", {
+        style: style,
+        key: key
+      }, rowIndex + ':' + columnIndex);
+    },
+    columnCount: 1000,
+    columnWidth: 20,
+    height: 500,
+    rowCount: 1000,
+    rowHeight: 20,
+    width: 500
+  }));
+  expect(rendered).toContain('0:0');
+  expect(rendered).toContain('24:24');
+  expect(rendered).not.toContain('25:25');
+});
+test('should support :scrollToColumn and :scrollToRow in server render', function () {
+  var rendered = ReactDOMServer.renderToString(/*#__PURE__*/React.createElement(_Grid["default"], {
+    cellRenderer: function cellRenderer(_ref2) {
+      var style = _ref2.style,
+        key = _ref2.key,
+        rowIndex = _ref2.rowIndex,
+        columnIndex = _ref2.columnIndex;
+      return /*#__PURE__*/React.createElement("div", {
+        style: style,
+        key: key
+      }, rowIndex + ':' + columnIndex);
+    },
+    columnCount: 1000,
+    columnWidth: 20,
+    scrollToColumn: 250,
+    height: 500,
+    rowCount: 1000,
+    rowHeight: 20,
+    scrollToRow: 250,
+    width: 500
+  }));
+  expect(rendered).toContain('250:250');
+  expect(rendered).not.toContain('0:0');
+});

package/dist/commonjs/Grid/accessibilityOverscanIndicesGetter.jest.js

@@ -0,0 +1,92 @@
+"use strict";
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+var _accessibilityOverscanIndicesGetter = _interopRequireWildcard(require("./accessibilityOverscanIndicesGetter"));
+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; }
+describe('overscanIndicesGetter', function () {
+  function testHelper(_ref) {
+    var cellCount = _ref.cellCount,
+      startIndex = _ref.startIndex,
+      stopIndex = _ref.stopIndex,
+      overscanCellsCount = _ref.overscanCellsCount,
+      scrollDirection = _ref.scrollDirection;
+    return (0, _accessibilityOverscanIndicesGetter["default"])({
+      cellCount: cellCount,
+      overscanCellsCount: overscanCellsCount,
+      scrollDirection: scrollDirection,
+      startIndex: startIndex,
+      stopIndex: stopIndex
+    });
+  }
+  it('should still overscan by 1 (for keyboard accessibility) if :overscanCellsCount is 0', function () {
+    expect(testHelper({
+      cellCount: 100,
+      startIndex: 10,
+      stopIndex: 20,
+      overscanCellsCount: 0,
+      scrollDirection: _accessibilityOverscanIndicesGetter.SCROLL_DIRECTION_BACKWARD
+    })).toEqual({
+      overscanStartIndex: 9,
+      overscanStopIndex: 21
+    });
+    expect(testHelper({
+      cellCount: 100,
+      startIndex: 10,
+      stopIndex: 20,
+      overscanCellsCount: 0,
+      scrollDirection: _accessibilityOverscanIndicesGetter.SCROLL_DIRECTION_FORWARD
+    })).toEqual({
+      overscanStartIndex: 9,
+      overscanStopIndex: 21
+    });
+  });
+  it('should overscan forward', function () {
+    expect(testHelper({
+      cellCount: 100,
+      startIndex: 20,
+      stopIndex: 30,
+      overscanCellsCount: 10,
+      scrollDirection: _accessibilityOverscanIndicesGetter.SCROLL_DIRECTION_FORWARD
+    })).toEqual({
+      overscanStartIndex: 19,
+      overscanStopIndex: 40
+    });
+  });
+  it('should overscan backward', function () {
+    expect(testHelper({
+      cellCount: 100,
+      startIndex: 20,
+      stopIndex: 30,
+      overscanCellsCount: 10,
+      scrollDirection: _accessibilityOverscanIndicesGetter.SCROLL_DIRECTION_BACKWARD
+    })).toEqual({
+      overscanStartIndex: 10,
+      overscanStopIndex: 31
+    });
+  });
+  it('should not overscan beyond the start of the list', function () {
+    expect(testHelper({
+      cellCount: 100,
+      startIndex: 5,
+      stopIndex: 15,
+      overscanCellsCount: 10,
+      scrollDirection: _accessibilityOverscanIndicesGetter.SCROLL_DIRECTION_BACKWARD
+    })).toEqual({
+      overscanStartIndex: 0,
+      overscanStopIndex: 16
+    });
+  });
+  it('should not overscan beyond the end of the list', function () {
+    expect(testHelper({
+      cellCount: 25,
+      startIndex: 10,
+      stopIndex: 20,
+      overscanCellsCount: 10,
+      scrollDirection: _accessibilityOverscanIndicesGetter.SCROLL_DIRECTION_FORWARD
+    })).toEqual({
+      overscanStartIndex: 9,
+      overscanStopIndex: 24
+    });
+  });
+});

package/dist/commonjs/Grid/accessibilityOverscanIndicesGetter.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SCROLL_DIRECTION_VERTICAL = exports.SCROLL_DIRECTION_HORIZONTAL = exports.SCROLL_DIRECTION_FORWARD = exports.SCROLL_DIRECTION_BACKWARD = void 0;
+exports["default"] = defaultOverscanIndicesGetter;
+/*:: import type {OverscanIndicesGetterParams, OverscanIndices} from './types';*/
+var SCROLL_DIRECTION_BACKWARD = exports.SCROLL_DIRECTION_BACKWARD = -1;
+var SCROLL_DIRECTION_FORWARD = exports.SCROLL_DIRECTION_FORWARD = 1;
+var SCROLL_DIRECTION_HORIZONTAL = exports.SCROLL_DIRECTION_HORIZONTAL = 'horizontal';
+var SCROLL_DIRECTION_VERTICAL = exports.SCROLL_DIRECTION_VERTICAL = 'vertical';
+
+/**
+ * Calculates the number of cells to overscan before and after a specified range.
+ * This function ensures that overscanning doesn't exceed the available cells.
+ */
+
+function defaultOverscanIndicesGetter(_ref /*:: */) /*: OverscanIndices*/{
+  var cellCount = _ref /*:: */.cellCount,
+    overscanCellsCount = _ref /*:: */.overscanCellsCount,
+    scrollDirection = _ref /*:: */.scrollDirection,
+    startIndex = _ref /*:: */.startIndex,
+    stopIndex = _ref /*:: */.stopIndex;
+  // Make sure we render at least 1 cell extra before and after (except near boundaries)
+  // This is necessary in order to support keyboard navigation (TAB/SHIFT+TAB) in some cases
+  // For more info see issues #625
+  overscanCellsCount = Math.max(1, overscanCellsCount);
+  if (scrollDirection === SCROLL_DIRECTION_FORWARD) {
+    return {
+      overscanStartIndex: Math.max(0, startIndex - 1),
+      overscanStopIndex: Math.min(cellCount - 1, stopIndex + overscanCellsCount)
+    };
+  } else {
+    return {
+      overscanStartIndex: Math.max(0, startIndex - overscanCellsCount),
+      overscanStopIndex: Math.min(cellCount - 1, stopIndex + 1)
+    };
+  }
+}

package/dist/commonjs/Grid/defaultCellRangeRenderer.js

@@ -0,0 +1,139 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = defaultCellRangeRenderer;
+var _react = _interopRequireDefault(require("react"));
+/*:: import type {CellRangeRendererParams} from './types';*/
+/**
+ * Default implementation of cellRangeRenderer used by Grid.
+ * This renderer supports cell-caching while the user is scrolling.
+ */
+function defaultCellRangeRenderer(_ref /*:: */) {
+  var cellCache = _ref /*:: */.cellCache,
+    cellRenderer = _ref /*:: */.cellRenderer,
+    columnSizeAndPositionManager = _ref /*:: */.columnSizeAndPositionManager,
+    columnStartIndex = _ref /*:: */.columnStartIndex,
+    columnStopIndex = _ref /*:: */.columnStopIndex,
+    deferredMeasurementCache = _ref /*:: */.deferredMeasurementCache,
+    horizontalOffsetAdjustment = _ref /*:: */.horizontalOffsetAdjustment,
+    isScrolling = _ref /*:: */.isScrolling,
+    isScrollingOptOut = _ref /*:: */.isScrollingOptOut,
+    parent = _ref /*:: */.parent,
+    rowSizeAndPositionManager = _ref /*:: */.rowSizeAndPositionManager,
+    rowStartIndex = _ref /*:: */.rowStartIndex,
+    rowStopIndex = _ref /*:: */.rowStopIndex,
+    styleCache = _ref /*:: */.styleCache,
+    verticalOffsetAdjustment = _ref /*:: */.verticalOffsetAdjustment,
+    visibleColumnIndices = _ref /*:: */.visibleColumnIndices,
+    visibleRowIndices = _ref /*:: */.visibleRowIndices;
+  var renderedCells = [];
+
+  // Browsers have native size limits for elements (eg Chrome 33M pixels, IE 1.5M pixes).
+  // User cannot scroll beyond these size limitations.
+  // In order to work around this, ScalingCellSizeAndPositionManager compresses offsets.
+  // We should never cache styles for compressed offsets though as this can lead to bugs.
+  // See issue #576 for more.
+  var areOffsetsAdjusted = columnSizeAndPositionManager.areOffsetsAdjusted() || rowSizeAndPositionManager.areOffsetsAdjusted();
+  var canCacheStyle = !isScrolling && !areOffsetsAdjusted;
+  for (var rowIndex = rowStartIndex; rowIndex <= rowStopIndex; rowIndex++) {
+    var rowDatum = rowSizeAndPositionManager.getSizeAndPositionOfCell(rowIndex);
+    for (var columnIndex = columnStartIndex; columnIndex <= columnStopIndex; columnIndex++) {
+      var columnDatum = columnSizeAndPositionManager.getSizeAndPositionOfCell(columnIndex);
+      var isVisible = columnIndex >= visibleColumnIndices.start && columnIndex <= visibleColumnIndices.stop && rowIndex >= visibleRowIndices.start && rowIndex <= visibleRowIndices.stop;
+      var key = "".concat(rowIndex, "-").concat(columnIndex);
+      var style = void 0;
+
+      // Cache style objects so shallow-compare doesn't re-render unnecessarily.
+      if (canCacheStyle && styleCache[key]) {
+        style = styleCache[key];
+      } else {
+        // In deferred mode, cells will be initially rendered before we know their size.
+        // Don't interfere with CellMeasurer's measurements by setting an invalid size.
+        if (deferredMeasurementCache && !deferredMeasurementCache.has(rowIndex, columnIndex)) {
+          // Position not-yet-measured cells at top/left 0,0,
+          // And give them width/height of 'auto' so they can grow larger than the parent Grid if necessary.
+          // Positioning them further to the right/bottom influences their measured size.
+          style = {
+            height: 'auto',
+            left: 0,
+            position: 'absolute',
+            top: 0,
+            width: 'auto'
+          };
+        } else {
+          style = {
+            height: rowDatum.size,
+            left: columnDatum.offset + horizontalOffsetAdjustment,
+            position: 'absolute',
+            top: rowDatum.offset + verticalOffsetAdjustment,
+            width: columnDatum.size
+          };
+          styleCache[key] = style;
+        }
+      }
+      var cellRendererParams = {
+        columnIndex: columnIndex,
+        isScrolling: isScrolling,
+        isVisible: isVisible,
+        key: key,
+        parent: parent,
+        rowIndex: rowIndex,
+        style: style
+      };
+      var renderedCell = void 0;
+
+      // Avoid re-creating cells while scrolling.
+      // This can lead to the same cell being created many times and can cause performance issues for "heavy" cells.
+      // If a scroll is in progress- cache and reuse cells.
+      // This cache will be thrown away once scrolling completes.
+      // However if we are scaling scroll positions and sizes, we should also avoid caching.
+      // This is because the offset changes slightly as scroll position changes and caching leads to stale values.
+      // For more info refer to issue #395
+      //
+      // If isScrollingOptOut is specified, we always cache cells.
+      // For more info refer to issue #1028
+      if ((isScrollingOptOut || isScrolling) && !horizontalOffsetAdjustment && !verticalOffsetAdjustment) {
+        if (!cellCache[key]) {
+          cellCache[key] = cellRenderer(cellRendererParams);
+        }
+        renderedCell = cellCache[key];
+
+        // If the user is no longer scrolling, don't cache cells.
+        // This makes dynamic cell content difficult for users and would also lead to a heavier memory footprint.
+      } else {
+        renderedCell = cellRenderer(cellRendererParams);
+      }
+      if (renderedCell == null || renderedCell === false) {
+        continue;
+      }
+      if (process.env.NODE_ENV !== 'production') {
+        warnAboutMissingStyle(parent, renderedCell);
+      }
+      if (!renderedCell.props.role) {
+        renderedCell = /*#__PURE__*/_react["default"].cloneElement(renderedCell, {
+          role: 'gridcell'
+        });
+      }
+      renderedCells.push(renderedCell);
+    }
+  }
+  return renderedCells;
+}
+function warnAboutMissingStyle(parent, renderedCell) {
+  if (process.env.NODE_ENV !== 'production') {
+    if (renderedCell) {
+      // If the direct child is a CellMeasurer, then we should check its child
+      // See issue #611
+      if (renderedCell.type && renderedCell.type.__internalCellMeasurerFlag) {
+        renderedCell = renderedCell.props.children;
+      }
+      if (renderedCell && renderedCell.props && renderedCell.props.style === undefined && parent.__warnedAboutMissingStyle !== true) {
+        parent.__warnedAboutMissingStyle = true;
+        console.warn('Rendered cell should include style property for positioning.');
+      }
+    }
+  }
+}

package/dist/commonjs/Grid/defaultOverscanIndicesGetter.jest.js

@@ -0,0 +1,92 @@
+"use strict";
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+var _defaultOverscanIndicesGetter = _interopRequireWildcard(require("./defaultOverscanIndicesGetter"));
+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; }
+describe('overscanIndicesGetter', function () {
+  function testHelper(_ref) {
+    var cellCount = _ref.cellCount,
+      startIndex = _ref.startIndex,
+      stopIndex = _ref.stopIndex,
+      overscanCellsCount = _ref.overscanCellsCount,
+      scrollDirection = _ref.scrollDirection;
+    return (0, _defaultOverscanIndicesGetter["default"])({
+      cellCount: cellCount,
+      overscanCellsCount: overscanCellsCount,
+      scrollDirection: scrollDirection,
+      startIndex: startIndex,
+      stopIndex: stopIndex
+    });
+  }
+  it('should not overscan if :overscanCellsCount is 0', function () {
+    expect(testHelper({
+      cellCount: 100,
+      startIndex: 10,
+      stopIndex: 20,
+      overscanCellsCount: 0,
+      scrollDirection: _defaultOverscanIndicesGetter.SCROLL_DIRECTION_BACKWARD
+    })).toEqual({
+      overscanStartIndex: 10,
+      overscanStopIndex: 20
+    });
+    expect(testHelper({
+      cellCount: 100,
+      startIndex: 10,
+      stopIndex: 20,
+      overscanCellsCount: 0,
+      scrollDirection: _defaultOverscanIndicesGetter.SCROLL_DIRECTION_FORWARD
+    })).toEqual({
+      overscanStartIndex: 10,
+      overscanStopIndex: 20
+    });
+  });
+  it('should overscan forward', function () {
+    expect(testHelper({
+      cellCount: 100,
+      startIndex: 20,
+      stopIndex: 30,
+      overscanCellsCount: 10,
+      scrollDirection: _defaultOverscanIndicesGetter.SCROLL_DIRECTION_FORWARD
+    })).toEqual({
+      overscanStartIndex: 20,
+      overscanStopIndex: 40
+    });
+  });
+  it('should overscan backward', function () {
+    expect(testHelper({
+      cellCount: 100,
+      startIndex: 20,
+      stopIndex: 30,
+      overscanCellsCount: 10,
+      scrollDirection: _defaultOverscanIndicesGetter.SCROLL_DIRECTION_BACKWARD
+    })).toEqual({
+      overscanStartIndex: 10,
+      overscanStopIndex: 30
+    });
+  });
+  it('should not overscan beyond the start of the list', function () {
+    expect(testHelper({
+      cellCount: 100,
+      startIndex: 5,
+      stopIndex: 15,
+      overscanCellsCount: 10,
+      scrollDirection: _defaultOverscanIndicesGetter.SCROLL_DIRECTION_BACKWARD
+    })).toEqual({
+      overscanStartIndex: 0,
+      overscanStopIndex: 15
+    });
+  });
+  it('should not overscan beyond the end of the list', function () {
+    expect(testHelper({
+      cellCount: 25,
+      startIndex: 10,
+      stopIndex: 20,
+      overscanCellsCount: 10,
+      scrollDirection: _defaultOverscanIndicesGetter.SCROLL_DIRECTION_FORWARD
+    })).toEqual({
+      overscanStartIndex: 10,
+      overscanStopIndex: 24
+    });
+  });
+});

package/dist/commonjs/Grid/defaultOverscanIndicesGetter.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SCROLL_DIRECTION_VERTICAL = exports.SCROLL_DIRECTION_HORIZONTAL = exports.SCROLL_DIRECTION_FORWARD = exports.SCROLL_DIRECTION_BACKWARD = void 0;
+exports["default"] = defaultOverscanIndicesGetter;
+/*:: import type {OverscanIndicesGetterParams, OverscanIndices} from './types';*/
+var SCROLL_DIRECTION_BACKWARD = exports.SCROLL_DIRECTION_BACKWARD = -1;
+var SCROLL_DIRECTION_FORWARD = exports.SCROLL_DIRECTION_FORWARD = 1;
+var SCROLL_DIRECTION_HORIZONTAL = exports.SCROLL_DIRECTION_HORIZONTAL = 'horizontal';
+var SCROLL_DIRECTION_VERTICAL = exports.SCROLL_DIRECTION_VERTICAL = 'vertical';
+
+/**
+ * Calculates the number of cells to overscan before and after a specified range.
+ * This function ensures that overscanning doesn't exceed the available cells.
+ */
+
+function defaultOverscanIndicesGetter(_ref /*:: */) /*: OverscanIndices*/{
+  var cellCount = _ref /*:: */.cellCount,
+    overscanCellsCount = _ref /*:: */.overscanCellsCount,
+    scrollDirection = _ref /*:: */.scrollDirection,
+    startIndex = _ref /*:: */.startIndex,
+    stopIndex = _ref /*:: */.stopIndex;
+  if (scrollDirection === SCROLL_DIRECTION_FORWARD) {
+    return {
+      overscanStartIndex: Math.max(0, startIndex),
+      overscanStopIndex: Math.min(cellCount - 1, stopIndex + overscanCellsCount)
+    };
+  } else {
+    return {
+      overscanStartIndex: Math.max(0, startIndex - overscanCellsCount),
+      overscanStopIndex: Math.min(cellCount - 1, stopIndex)
+    };
+  }
+}

package/dist/commonjs/Grid/index.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Grid", {
+  enumerable: true,
+  get: function get() {
+    return _Grid["default"];
+  }
+});
+Object.defineProperty(exports, "accessibilityOverscanIndicesGetter", {
+  enumerable: true,
+  get: function get() {
+    return _accessibilityOverscanIndicesGetter["default"];
+  }
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function get() {
+    return _Grid["default"];
+  }
+});
+Object.defineProperty(exports, "defaultCellRangeRenderer", {
+  enumerable: true,
+  get: function get() {
+    return _defaultCellRangeRenderer["default"];
+  }
+});
+Object.defineProperty(exports, "defaultOverscanIndicesGetter", {
+  enumerable: true,
+  get: function get() {
+    return _defaultOverscanIndicesGetter["default"];
+  }
+});
+var _Grid = _interopRequireDefault(require("./Grid"));
+var _accessibilityOverscanIndicesGetter = _interopRequireDefault(require("./accessibilityOverscanIndicesGetter"));
+var _defaultCellRangeRenderer = _interopRequireDefault(require("./defaultCellRangeRenderer"));
+var _defaultOverscanIndicesGetter = _interopRequireDefault(require("./defaultOverscanIndicesGetter"));

package/dist/commonjs/Grid/types.js

@@ -0,0 +1,8 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+var React = _interopRequireWildcard(require("react"));
+var _ScalingCellSizeAndPositionManager = _interopRequireDefault(require("./utils/ScalingCellSizeAndPositionManager"));
+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; }