@difizen/libro-virtualized 0.1.2

package/es/cell-measurer/cell-measurer.js

@@ -0,0 +1,154 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import * as React from 'react';
+import { findDOMNode } from 'react-dom';
+/**
+ * Wraps a cell and measures its rendered content.
+ * Measurements are stored in a per-cell cache.
+ * Cached-content is not be re-measured.
+ */
+var CellMeasurer = /*#__PURE__*/function (_React$PureComponent) {
+  _inherits(CellMeasurer, _React$PureComponent);
+  var _super = _createSuper(CellMeasurer);
+  function CellMeasurer() {
+    var _this;
+    _classCallCheck(this, CellMeasurer);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _this._measure = function () {
+      var _this$props = _this.props,
+        cache = _this$props.cache,
+        _this$props$columnInd = _this$props.columnIndex,
+        columnIndex = _this$props$columnInd === void 0 ? 0 : _this$props$columnInd,
+        parent = _this$props.parent,
+        _this$props$rowIndex = _this$props.rowIndex,
+        rowIndex = _this$props$rowIndex === void 0 ? _this.props.index || 0 : _this$props$rowIndex;
+      var _this$_getCellMeasure = _this._getCellMeasurements(),
+        height = _this$_getCellMeasure.height,
+        width = _this$_getCellMeasure.width;
+      if (height !== cache.getHeight(rowIndex, columnIndex) || width !== cache.getWidth(rowIndex, columnIndex)) {
+        cache.set(rowIndex, columnIndex, width, height);
+        if (parent && typeof parent.recomputeGridSize === 'function') {
+          parent.recomputeGridSize({
+            columnIndex: columnIndex,
+            rowIndex: rowIndex
+          });
+        }
+      }
+    };
+    return _this;
+  }
+  _createClass(CellMeasurer, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this._maybeMeasureCell();
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate() {
+      this._maybeMeasureCell();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var children = this.props.children;
+      return typeof children === 'function' ? children({
+        measure: this._measure
+      }) : children;
+    }
+  }, {
+    key: "_getCellMeasurements",
+    value: function _getCellMeasurements() {
+      var cache = this.props.cache;
+
+      // eslint-disable-next-line react/no-find-dom-node
+      var node = findDOMNode(this);
+
+      // TODO Check for a bad combination of fixedWidth and missing numeric width or vice versa with height
+
+      if (node && node.ownerDocument && node.ownerDocument.defaultView && node instanceof node.ownerDocument.defaultView.HTMLElement) {
+        var styleWidth = node.style.width;
+        var styleHeight = node.style.height;
+
+        // If we are re-measuring a cell that has already been measured,
+        // It will have a hard-coded width/height from the previous measurement.
+        // The fact that we are measuring indicates this measurement is probably stale,
+        // So explicitly clear it out (eg set to "auto") so we can recalculate.
+        // See issue #593 for more info.
+        // Even if we are measuring initially- if we're inside of a MultiGrid component,
+        // Explicitly clear width/height before measuring to avoid being tainted by another Grid.
+        // eg top/left Grid renders before bottom/right Grid
+        // Since the CellMeasurerCache is shared between them this taints derived cell size values.
+        if (!cache.hasFixedWidth()) {
+          node.style.width = 'auto';
+        }
+        if (!cache.hasFixedHeight()) {
+          node.style.height = 'auto';
+        }
+        var height = Math.ceil(node.offsetHeight);
+        var width = Math.ceil(node.offsetWidth);
+
+        // Reset after measuring to avoid breaking styles; see #660
+        if (styleWidth) {
+          node.style.width = styleWidth;
+        }
+        if (styleHeight) {
+          node.style.height = styleHeight;
+        }
+        return {
+          height: height,
+          width: width
+        };
+      } else {
+        return {
+          height: 0,
+          width: 0
+        };
+      }
+    }
+  }, {
+    key: "_maybeMeasureCell",
+    value: function _maybeMeasureCell() {
+      var _this$props2 = this.props,
+        cache = _this$props2.cache,
+        _this$props2$columnIn = _this$props2.columnIndex,
+        columnIndex = _this$props2$columnIn === void 0 ? 0 : _this$props2$columnIn,
+        parent = _this$props2.parent,
+        _this$props2$rowIndex = _this$props2.rowIndex,
+        rowIndex = _this$props2$rowIndex === void 0 ? this.props.index || 0 : _this$props2$rowIndex;
+      if (!cache.has(rowIndex, columnIndex)) {
+        var _this$_getCellMeasure2 = this._getCellMeasurements(),
+          height = _this$_getCellMeasure2.height,
+          width = _this$_getCellMeasure2.width;
+        cache.set(rowIndex, columnIndex, width, height);
+
+        // If size has changed, let Grid know to re-render.
+        if (parent && typeof parent.invalidateCellSizeAfterRender === 'function') {
+          parent.invalidateCellSizeAfterRender({
+            columnIndex: columnIndex,
+            rowIndex: rowIndex
+          });
+        }
+      }
+    }
+  }]);
+  return CellMeasurer;
+}(React.PureComponent); // Used for DEV mode warning check
+CellMeasurer.__internalCellMeasurerFlag = false;
+export { CellMeasurer as default };
+if (process.env['NODE_ENV'] !== 'production') {
+  CellMeasurer.__internalCellMeasurerFlag = true;
+}

package/es/cell-measurer/index.d.ts

@@ -0,0 +1,5 @@
+import CellMeasurerCache from './cell-measurer-cache.js';
+import CellMeasurer from './cell-measurer.js';
+export default CellMeasurer;
+export { CellMeasurer, CellMeasurerCache };
+//# sourceMappingURL=index.d.ts.map

package/es/cell-measurer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cell-measurer/index.ts"],"names":[],"mappings":"AAAA,OAAO,iBAAiB,MAAM,0BAA0B,CAAC;AACzD,OAAO,YAAY,MAAM,oBAAoB,CAAC;AAE9C,eAAe,YAAY,CAAC;AAC5B,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,CAAC"}

package/es/cell-measurer/index.js

@@ -0,0 +1,4 @@
+import CellMeasurerCache from "./cell-measurer-cache.js";
+import CellMeasurer from "./cell-measurer.js";
+export default CellMeasurer;
+export { CellMeasurer, CellMeasurerCache };

package/es/cell-measurer/types.d.ts

@@ -0,0 +1,9 @@
+export interface CellMeasureCache {
+    hasFixedWidth(): boolean;
+    hasFixedHeight(): boolean;
+    has(rowIndex: number, columnIndex: number): boolean;
+    set(rowIndex: number, columnIndex: number, width: number, height: number): void;
+    getHeight(rowIndex: number, columnIndex?: number): number;
+    getWidth(rowIndex: number, columnIndex?: number): number;
+}
+//# sourceMappingURL=types.d.ts.map

package/es/cell-measurer/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/cell-measurer/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,aAAa,IAAI,OAAO,CAAC;IACzB,cAAc,IAAI,OAAO,CAAC;IAC1B,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC;IACpD,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAChF,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC1D,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAC1D"}

package/es/grid/accessibility-overscanIndices-getter.d.ts

@@ -0,0 +1,11 @@
+import type { OverscanIndices, OverscanIndicesGetterParams } from './types.js';
+export declare const SCROLL_DIRECTION_BACKWARD = -1;
+export declare const SCROLL_DIRECTION_FORWARD = 1;
+export declare const SCROLL_DIRECTION_HORIZONTAL = "horizontal";
+export declare const 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({ cellCount, overscanCellsCount, scrollDirection, startIndex, stopIndex, }: OverscanIndicesGetterParams): OverscanIndices;
+//# sourceMappingURL=accessibility-overscanIndices-getter.d.ts.map

package/es/grid/accessibility-overscanIndices-getter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessibility-overscanIndices-getter.d.ts","sourceRoot":"","sources":["../../src/grid/accessibility-overscanIndices-getter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AAE/E,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAC5C,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C,eAAO,MAAM,2BAA2B,eAAe,CAAC;AACxD,eAAO,MAAM,yBAAyB,aAAa,CAAC;AAEpD;;;GAGG;AAEH,MAAM,CAAC,OAAO,UAAU,4BAA4B,CAAC,EACnD,SAAS,EACT,kBAAkB,EAClB,eAAe,EACf,UAAU,EACV,SAAS,GACV,EAAE,2BAA2B,GAAG,eAAe,CAkB/C"}

package/es/grid/accessibility-overscanIndices-getter.js

@@ -0,0 +1,33 @@
+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) {
+  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
+  // eslint-disable-next-line no-param-reassign
+  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/es/grid/default-cell-range-renderer.d.ts

@@ -0,0 +1,10 @@
+/** @flow */
+/// <reference types="react" />
+import type { CellRangeRendererParams } from './types.js';
+/**
+ * Default implementation of cellRangeRenderer used by Grid.
+ * This renderer supports cell-caching while the user is scrolling.
+ */
+export default function defaultCellRangeRenderer({ cellCache, cellRenderer, columnSizeAndPositionManager, columnStartIndex, columnStopIndex, deferredMeasurementCache, horizontalOffsetAdjustment, isScrolling, isScrollingOptOut, parent, // Grid (or List or Table)
+rowSizeAndPositionManager, rowStartIndex, rowStopIndex, styleCache, verticalOffsetAdjustment, visibleColumnIndices, visibleRowIndices, }: CellRangeRendererParams): (string | number | boolean | import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | undefined)[];
+//# sourceMappingURL=default-cell-range-renderer.d.ts.map

package/es/grid/default-cell-range-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-cell-range-renderer.d.ts","sourceRoot":"","sources":["../../src/grid/default-cell-range-renderer.ts"],"names":[],"mappings":"AACA,YAAY;;AAEZ,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAE1D;;;GAGG;AAEH,MAAM,CAAC,OAAO,UAAU,wBAAwB,CAAC,EAC/C,SAAS,EACT,YAAY,EACZ,4BAA4B,EAC5B,gBAAgB,EAChB,eAAe,EACf,wBAAwB,EACxB,0BAA0B,EAC1B,WAAW,EACX,iBAAiB,EACjB,MAAM,EAAE,0BAA0B;AAClC,yBAAyB,EACzB,aAAa,EACb,YAAY,EACZ,UAAU,EACV,wBAAwB,EACxB,oBAAoB,EACpB,iBAAiB,GAClB,EAAE,uBAAuB,4KAiHzB"}

package/es/grid/default-cell-range-renderer.js

@@ -0,0 +1,135 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/**
+ * 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.
+  // const areOffsetsAdjusted =
+  //   columnSizeAndPositionManager.areOffsetsAdjusted() ||
+  //   rowSizeAndPositionManager.areOffsetsAdjusted();
+
+  // const canCacheStyle = !isScrolling && !areOffsetsAdjusted;
+
+  for (var rowIndex = rowStartIndex; rowIndex <= rowStopIndex; rowIndex++) {
+    var rowDatum = rowSizeAndPositionManager.getSizeAndPositionOfCell(rowIndex);
+    // 计算无偏差
+
+    for (var columnIndex = columnStartIndex; columnIndex <= columnStopIndex; columnIndex++) {
+      // const columnDatum = columnSizeAndPositionManager.getSizeAndPositionOfCell(columnIndex);
+      var isVisible = columnIndex >= visibleColumnIndices['start'] && columnIndex <= visibleColumnIndices['stop'] && rowIndex >= visibleRowIndices['start'] && rowIndex <= visibleRowIndices['stop'];
+      var key = "".concat(rowIndex, "-").concat(columnIndex);
+
+      // 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 {
+      var style = {
+        height: rowDatum.size,
+        left: '73px',
+        // columnDatum.offset + horizontalOffsetAdjustment,
+        position: 'absolute',
+        top: rowDatum.offset + verticalOffsetAdjustment,
+        width: 'calc(100% - 135px)' // 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);
+      }
+      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) {
+        // eslint-disable-next-line no-param-reassign
+        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/es/grid/default-overscanIndices-getter.d.ts

@@ -0,0 +1,11 @@
+import type { OverscanIndices, OverscanIndicesGetterParams } from './types.js';
+export declare const SCROLL_DIRECTION_BACKWARD = -1;
+export declare const SCROLL_DIRECTION_FORWARD = 1;
+export declare const SCROLL_DIRECTION_HORIZONTAL = "horizontal";
+export declare const 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({ cellCount, overscanCellsCount, scrollDirection, startIndex, stopIndex, }: OverscanIndicesGetterParams): OverscanIndices;
+//# sourceMappingURL=default-overscanIndices-getter.d.ts.map

package/es/grid/default-overscanIndices-getter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-overscanIndices-getter.d.ts","sourceRoot":"","sources":["../../src/grid/default-overscanIndices-getter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AAE/E,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAC5C,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C,eAAO,MAAM,2BAA2B,eAAe,CAAC;AACxD,eAAO,MAAM,yBAAyB,aAAa,CAAC;AAEpD;;;GAGG;AAEH,MAAM,CAAC,OAAO,UAAU,4BAA4B,CAAC,EACnD,SAAS,EACT,kBAAkB,EAClB,eAAe,EACf,UAAU,EACV,SAAS,GACV,EAAE,2BAA2B,GAAG,eAAe,CAY/C"}

package/es/grid/default-overscanIndices-getter.js

@@ -0,0 +1,28 @@
+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) {
+  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)
+    };
+  }
+}