@depup/react-virtualized 9.22.6-depup.0

package/dist/es/Grid/Grid.ssr.js

@@ -0,0 +1,57 @@
+/**
+ * 
+ * @jest-environment node
+ */
+
+import * as React from 'react';
+import * as ReactDOMServer from 'react-dom/server';
+import Grid from './Grid';
+/*:: declare var test: any;*/
+/*:: declare var expect: any;*/
+test('should render Grid with dom server', function () {
+  var rendered = ReactDOMServer.renderToString(/*#__PURE__*/React.createElement(Grid, {
+    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, {
+    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/es/Grid/accessibilityOverscanIndicesGetter.jest.js

@@ -0,0 +1,87 @@
+import overscanIndicesGetter, { SCROLL_DIRECTION_BACKWARD, SCROLL_DIRECTION_FORWARD } from './accessibilityOverscanIndicesGetter';
+describe('overscanIndicesGetter', function () {
+  function testHelper(_ref) {
+    var cellCount = _ref.cellCount,
+      startIndex = _ref.startIndex,
+      stopIndex = _ref.stopIndex,
+      overscanCellsCount = _ref.overscanCellsCount,
+      scrollDirection = _ref.scrollDirection;
+    return overscanIndicesGetter({
+      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: SCROLL_DIRECTION_BACKWARD
+    })).toEqual({
+      overscanStartIndex: 9,
+      overscanStopIndex: 21
+    });
+    expect(testHelper({
+      cellCount: 100,
+      startIndex: 10,
+      stopIndex: 20,
+      overscanCellsCount: 0,
+      scrollDirection: SCROLL_DIRECTION_FORWARD
+    })).toEqual({
+      overscanStartIndex: 9,
+      overscanStopIndex: 21
+    });
+  });
+  it('should overscan forward', function () {
+    expect(testHelper({
+      cellCount: 100,
+      startIndex: 20,
+      stopIndex: 30,
+      overscanCellsCount: 10,
+      scrollDirection: SCROLL_DIRECTION_FORWARD
+    })).toEqual({
+      overscanStartIndex: 19,
+      overscanStopIndex: 40
+    });
+  });
+  it('should overscan backward', function () {
+    expect(testHelper({
+      cellCount: 100,
+      startIndex: 20,
+      stopIndex: 30,
+      overscanCellsCount: 10,
+      scrollDirection: 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: 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: SCROLL_DIRECTION_FORWARD
+    })).toEqual({
+      overscanStartIndex: 9,
+      overscanStopIndex: 24
+    });
+  });
+});

package/dist/es/Grid/accessibilityOverscanIndicesGetter.js

@@ -0,0 +1,33 @@
+/*:: import type {OverscanIndicesGetterParams, OverscanIndices} from './types';*/
+export var SCROLL_DIRECTION_BACKWARD = -1;
+export var SCROLL_DIRECTION_FORWARD = 1;
+export var SCROLL_DIRECTION_HORIZONTAL = 'horizontal';
+export var 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.
+ */
+
+export default 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/es/Grid/defaultCellRangeRenderer.js

@@ -0,0 +1,134 @@
+/*:: import type {CellRangeRendererParams} from './types';*/
+import React from 'react';
+
+/**
+ * Default implementation of cellRangeRenderer used by Grid.
+ * This renderer supports cell-caching while the user is scrolling.
+ */
+
+export default 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.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/es/Grid/defaultOverscanIndicesGetter.jest.js

@@ -0,0 +1,87 @@
+import overscanIndicesGetter, { SCROLL_DIRECTION_BACKWARD, SCROLL_DIRECTION_FORWARD } from './defaultOverscanIndicesGetter';
+describe('overscanIndicesGetter', function () {
+  function testHelper(_ref) {
+    var cellCount = _ref.cellCount,
+      startIndex = _ref.startIndex,
+      stopIndex = _ref.stopIndex,
+      overscanCellsCount = _ref.overscanCellsCount,
+      scrollDirection = _ref.scrollDirection;
+    return overscanIndicesGetter({
+      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: SCROLL_DIRECTION_BACKWARD
+    })).toEqual({
+      overscanStartIndex: 10,
+      overscanStopIndex: 20
+    });
+    expect(testHelper({
+      cellCount: 100,
+      startIndex: 10,
+      stopIndex: 20,
+      overscanCellsCount: 0,
+      scrollDirection: SCROLL_DIRECTION_FORWARD
+    })).toEqual({
+      overscanStartIndex: 10,
+      overscanStopIndex: 20
+    });
+  });
+  it('should overscan forward', function () {
+    expect(testHelper({
+      cellCount: 100,
+      startIndex: 20,
+      stopIndex: 30,
+      overscanCellsCount: 10,
+      scrollDirection: SCROLL_DIRECTION_FORWARD
+    })).toEqual({
+      overscanStartIndex: 20,
+      overscanStopIndex: 40
+    });
+  });
+  it('should overscan backward', function () {
+    expect(testHelper({
+      cellCount: 100,
+      startIndex: 20,
+      stopIndex: 30,
+      overscanCellsCount: 10,
+      scrollDirection: 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: 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: SCROLL_DIRECTION_FORWARD
+    })).toEqual({
+      overscanStartIndex: 10,
+      overscanStopIndex: 24
+    });
+  });
+});

package/dist/es/Grid/defaultOverscanIndicesGetter.js

@@ -0,0 +1,29 @@
+/*:: import type {OverscanIndicesGetterParams, OverscanIndices} from './types';*/
+export var SCROLL_DIRECTION_BACKWARD = -1;
+export var SCROLL_DIRECTION_FORWARD = 1;
+export var SCROLL_DIRECTION_HORIZONTAL = 'horizontal';
+export var 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.
+ */
+
+export default 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/es/Grid/index.js

@@ -0,0 +1,15 @@
+/*:: export type {
+  NoContentRenderer,
+  Alignment,
+  CellPosition,
+  CellSize,
+  OverscanIndicesGetter,
+  RenderedSection,
+  CellRendererParams,
+  Scroll,
+} from './types';*/
+export { default } from './Grid';
+export { default as Grid } from './Grid';
+export { default as accessibilityOverscanIndicesGetter } from './accessibilityOverscanIndicesGetter';
+export { default as defaultCellRangeRenderer } from './defaultCellRangeRenderer';
+export { default as defaultOverscanIndicesGetter } from './defaultOverscanIndicesGetter';

package/dist/es/Grid/types.js

@@ -0,0 +1,96 @@
+import * as React from 'react';
+import ScalingCellSizeAndPositionManager from './utils/ScalingCellSizeAndPositionManager';
+/*:: export type CellPosition = {columnIndex: number, rowIndex: number};*/
+/*:: export type CellRendererParams = {
+  columnIndex: number,
+  isScrolling: boolean,
+  isVisible: boolean,
+  key: string,
+  parent: Object,
+  rowIndex: number,
+  style: Object,
+};*/
+/*:: export type CellRenderer = (props: CellRendererParams) => React.Element<*>;*/
+/*:: export type CellCache = {[key: string]: React.Element<*>};*/
+/*:: export type StyleCache = {[key: string]: Object};*/
+/*:: export type CellRangeRendererParams = {
+  cellCache: CellCache,
+  cellRenderer: CellRenderer,
+  columnSizeAndPositionManager: ScalingCellSizeAndPositionManager,
+  columnStartIndex: number,
+  columnStopIndex: number,
+  deferredMeasurementCache?: Object,
+  horizontalOffsetAdjustment: number,
+  isScrolling: boolean,
+  isScrollingOptOut: boolean,
+  parent: Object,
+  rowSizeAndPositionManager: ScalingCellSizeAndPositionManager,
+  rowStartIndex: number,
+  rowStopIndex: number,
+  scrollLeft: number,
+  scrollTop: number,
+  styleCache: StyleCache,
+  verticalOffsetAdjustment: number,
+  visibleColumnIndices: Object,
+  visibleRowIndices: Object,
+};*/
+/*:: export type CellRangeRenderer = (
+  params: CellRangeRendererParams,
+) => React.Element<*>[];*/
+/*:: export type CellSizeGetter = (params: {index: number}) => number;*/
+/*:: export type CellSize = CellSizeGetter | number;*/
+/*:: export type NoContentRenderer = () => React.Element<*> | null;*/
+/*:: export type Scroll = {
+  clientHeight: number,
+  clientWidth: number,
+  scrollHeight: number,
+  scrollLeft: number,
+  scrollTop: number,
+  scrollWidth: number,
+};*/
+/*:: export type ScrollbarPresenceChange = {
+  horizontal: boolean,
+  vertical: boolean,
+  size: number,
+};*/
+/*:: export type RenderedSection = {
+  columnOverscanStartIndex: number,
+  columnOverscanStopIndex: number,
+  columnStartIndex: number,
+  columnStopIndex: number,
+  rowOverscanStartIndex: number,
+  rowOverscanStopIndex: number,
+  rowStartIndex: number,
+  rowStopIndex: number,
+};*/
+/*:: export type OverscanIndicesGetterParams = {
+  // One of SCROLL_DIRECTION_HORIZONTAL or SCROLL_DIRECTION_VERTICAL
+  direction: 'horizontal' | 'vertical',
+
+  // One of SCROLL_DIRECTION_BACKWARD or SCROLL_DIRECTION_FORWARD
+  scrollDirection: -1 | 1,
+
+  // Number of rows or columns in the current axis
+  cellCount: number,
+
+  // Maximum number of cells to over-render in either direction
+  overscanCellsCount: number,
+
+  // Begin of range of visible cells
+  startIndex: number,
+
+  // End of range of visible cells
+  stopIndex: number,
+};*/
+/*:: export type OverscanIndices = {
+  overscanStartIndex: number,
+  overscanStopIndex: number,
+};*/
+/*:: export type OverscanIndicesGetter = (
+  params: OverscanIndicesGetterParams,
+) => OverscanIndices;*/
+/*:: export type Alignment = 'auto' | 'end' | 'start' | 'center';*/
+/*:: export type VisibleCellRange = {
+  start?: number,
+  stop?: number,
+};*/