@difizen/libro-virtualized 0.1.2

package/es/grid/utils/cell-size-and-position-manager.js

@@ -0,0 +1,268 @@
+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); }
+/* eslint-disable no-param-reassign */
+/* eslint-disable prefer-const */
+/**
+ * Just-in-time calculates and caches size and position information for a collection of cells.
+ */
+var CellSizeAndPositionManager = /*#__PURE__*/function () {
+  function CellSizeAndPositionManager(_ref) {
+    var cellCount = _ref.cellCount,
+      cellSizeGetter = _ref.cellSizeGetter,
+      estimatedCellSize = _ref.estimatedCellSize;
+    _classCallCheck(this, CellSizeAndPositionManager);
+    // Cache of size and position data for cells, mapped by cell index.
+    // Note that invalid values may exist in this map so only rely on cells up to this._lastMeasuredIndex
+    this._cellSizeAndPositionData = {};
+    // Measurements for cells up to this index can be trusted; cells afterward should be estimated.
+    this._lastMeasuredIndex = -1;
+    // Used in deferred mode to track which cells have been queued for measurement.
+    this._lastBatchedIndex = -1;
+    this._cellSizeGetter = cellSizeGetter;
+    this._cellCount = cellCount;
+    this._estimatedCellSize = estimatedCellSize;
+  }
+  _createClass(CellSizeAndPositionManager, [{
+    key: "areOffsetsAdjusted",
+    value: function areOffsetsAdjusted() {
+      return false;
+    }
+  }, {
+    key: "configure",
+    value: function configure(_ref2) {
+      var cellCount = _ref2.cellCount,
+        estimatedCellSize = _ref2.estimatedCellSize,
+        cellSizeGetter = _ref2.cellSizeGetter;
+      this._cellCount = cellCount;
+      this._estimatedCellSize = estimatedCellSize;
+      this._cellSizeGetter = cellSizeGetter;
+    }
+  }, {
+    key: "getCellCount",
+    value: function getCellCount() {
+      return this._cellCount;
+    }
+  }, {
+    key: "getEstimatedCellSize",
+    value: function getEstimatedCellSize() {
+      return this._estimatedCellSize;
+    }
+  }, {
+    key: "getLastMeasuredIndex",
+    value: function getLastMeasuredIndex() {
+      return this._lastMeasuredIndex;
+    }
+  }, {
+    key: "getOffsetAdjustment",
+    value: function getOffsetAdjustment() {
+      return 0;
+    }
+
+    /**
+     * This method returns the size and position for the cell at the specified index.
+     * It just-in-time calculates (or used cached values) for cells leading up to the index.
+     */
+  }, {
+    key: "getSizeAndPositionOfCell",
+    value: function getSizeAndPositionOfCell(index) {
+      if (index < 0 || index >= this._cellCount) {
+        throw Error("Requested index ".concat(index, " is outside of range 0..").concat(this._cellCount));
+      }
+      if (index > this._lastMeasuredIndex) {
+        var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell();
+        var offset = lastMeasuredCellSizeAndPosition.offset + lastMeasuredCellSizeAndPosition.size;
+        for (var i = this._lastMeasuredIndex + 1; i <= index; i++) {
+          var size = this._cellSizeGetter({
+            index: i
+          });
+
+          // undefined or NaN probably means a logic error in the size getter.
+          // null means we're using CellMeasurer and haven't yet measured a given index.
+          if (size === undefined || isNaN(size)) {
+            throw Error("Invalid size returned for cell ".concat(i, " of value ").concat(size));
+          } else if (size === null) {
+            this._cellSizeAndPositionData[i] = {
+              offset: offset,
+              size: 0
+            };
+            this._lastBatchedIndex = index;
+          } else {
+            this._cellSizeAndPositionData[i] = {
+              offset: offset,
+              size: size
+            };
+            offset += size;
+            this._lastMeasuredIndex = index;
+          }
+        }
+      }
+      return this._cellSizeAndPositionData[index];
+    }
+  }, {
+    key: "getSizeAndPositionOfLastMeasuredCell",
+    value: function getSizeAndPositionOfLastMeasuredCell() {
+      return this._lastMeasuredIndex >= 0 ? this._cellSizeAndPositionData[this._lastMeasuredIndex] : {
+        offset: 0,
+        size: 0
+      };
+    }
+
+    /**
+     * Total size of all cells being measured.
+     * This value will be completely estimated initially.
+     * As cells are measured, the estimate will be updated.
+     */
+  }, {
+    key: "getTotalSize",
+    value: function getTotalSize() {
+      var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell();
+      var totalSizeOfMeasuredCells = lastMeasuredCellSizeAndPosition.offset + lastMeasuredCellSizeAndPosition.size;
+      var numUnmeasuredCells = this._cellCount - this._lastMeasuredIndex - 1;
+      var totalSizeOfUnmeasuredCells = numUnmeasuredCells * this._estimatedCellSize;
+      return totalSizeOfMeasuredCells + totalSizeOfUnmeasuredCells;
+    }
+
+    /**
+     * Determines a new offset that ensures a certain cell is visible, given the current offset.
+     * If the cell is already visible then the current offset will be returned.
+     * If the current offset is too great or small, it will be adjusted just enough to ensure the specified index is visible.
+     *
+     * @param align Desired alignment within container; one of "auto" (default), "start", or "end"
+     * @param containerSize Size (width or height) of the container viewport
+     * @param currentOffset Container's current (x or y) offset
+     * @param totalSize Total size (width or height) of all cells
+     * @return Offset to use to ensure the specified cell is visible
+     */
+  }, {
+    key: "getUpdatedOffsetForIndex",
+    value: function getUpdatedOffsetForIndex(_ref3) {
+      var _ref3$align = _ref3.align,
+        align = _ref3$align === void 0 ? 'auto' : _ref3$align,
+        containerSize = _ref3.containerSize,
+        currentOffset = _ref3.currentOffset,
+        targetIndex = _ref3.targetIndex;
+      if (containerSize <= 0) {
+        return 0;
+      }
+      var datum = this.getSizeAndPositionOfCell(targetIndex);
+      var maxOffset = datum.offset;
+      var minOffset = maxOffset - containerSize + datum.size;
+      var idealOffset;
+      switch (align) {
+        case 'start':
+          idealOffset = maxOffset;
+          break;
+        case 'end':
+          idealOffset = minOffset;
+          break;
+        case 'center':
+          idealOffset = maxOffset - (containerSize - datum.size) / 2;
+          break;
+        default:
+          idealOffset = Math.max(minOffset, Math.min(maxOffset, currentOffset));
+          break;
+      }
+      var totalSize = this.getTotalSize();
+      return Math.max(0, Math.min(totalSize - containerSize, idealOffset));
+    }
+  }, {
+    key: "getVisibleCellRange",
+    value: function getVisibleCellRange(params) {
+      var containerSize = params.containerSize,
+        offset = params.offset;
+      var totalSize = this.getTotalSize();
+      if (totalSize === 0) {
+        return {};
+      }
+      var maxOffset = offset + containerSize;
+      var start = this._findNearestCell(offset);
+      var datum = this.getSizeAndPositionOfCell(start);
+      offset = datum.offset + datum.size;
+      var stop = start;
+      while (offset < maxOffset && stop < this._cellCount - 1) {
+        stop++;
+        offset += this.getSizeAndPositionOfCell(stop).size;
+      }
+      return {
+        start: start,
+        stop: stop
+      };
+    }
+
+    /**
+     * Clear all cached values for cells after the specified index.
+     * This method should be called for any cell that has changed its size.
+     * It will not immediately perform any calculations; they'll be performed the next time getSizeAndPositionOfCell() is called.
+     */
+  }, {
+    key: "resetCell",
+    value: function resetCell(index) {
+      this._lastMeasuredIndex = Math.min(this._lastMeasuredIndex, index - 1);
+    }
+  }, {
+    key: "_binarySearch",
+    value: function _binarySearch(high, low, offset) {
+      while (low <= high) {
+        var middle = low + Math.floor((high - low) / 2);
+        var currentOffset = this.getSizeAndPositionOfCell(middle).offset;
+        if (currentOffset === offset) {
+          return middle;
+        } else if (currentOffset < offset) {
+          low = middle + 1;
+        } else if (currentOffset > offset) {
+          high = middle - 1;
+        }
+      }
+      if (low > 0) {
+        return low - 1;
+      } else {
+        return 0;
+      }
+    }
+  }, {
+    key: "_exponentialSearch",
+    value: function _exponentialSearch(index, offset) {
+      var interval = 1;
+      while (index < this._cellCount && this.getSizeAndPositionOfCell(index).offset < offset) {
+        index += interval;
+        interval *= 2;
+      }
+      return this._binarySearch(Math.min(index, this._cellCount - 1), Math.floor(index / 2), offset);
+    }
+
+    /**
+     * Searches for the cell (index) nearest the specified offset.
+     *
+     * If no exact match is found the next lowest cell index will be returned.
+     * This allows partially visible cells (with offsets just before/above the fold) to be visible.
+     */
+  }, {
+    key: "_findNearestCell",
+    value: function _findNearestCell(offset) {
+      if (isNaN(offset)) {
+        throw Error("Invalid offset ".concat(offset, " specified"));
+      }
+
+      // Our search algorithms find the nearest match at or below the specified offset.
+      // So make sure the offset is at least 0 or no match will be found.
+      offset = Math.max(0, offset);
+      var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell();
+      var lastMeasuredIndex = Math.max(0, this._lastMeasuredIndex);
+      if (lastMeasuredCellSizeAndPosition.offset >= offset) {
+        // If we've already measured cells within this range just use a binary search as it's faster.
+        return this._binarySearch(lastMeasuredIndex, 0, offset);
+      } else {
+        // If we haven't yet measured this high, fallback to an exponential search with an inner binary search.
+        // The exponential search avoids pre-computing sizes for the full set of cells as a binary search would.
+        // The overall complexity for this approach is O(log n).
+        return this._exponentialSearch(lastMeasuredIndex, offset);
+      }
+    }
+  }]);
+  return CellSizeAndPositionManager;
+}();
+export { CellSizeAndPositionManager as default };

package/es/grid/utils/max-element-size.d.ts

@@ -0,0 +1,2 @@
+export declare const getMaxElementSize: () => number;
+//# sourceMappingURL=max-element-size.d.ts.map

package/es/grid/utils/max-element-size.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"max-element-size.d.ts","sourceRoot":"","sources":["../../../src/grid/utils/max-element-size.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,iBAAiB,QAAO,MAOpC,CAAC"}

package/es/grid/utils/max-element-size.js

@@ -0,0 +1,17 @@
+var DEFAULT_MAX_ELEMENT_SIZE = 1500000;
+var CHROME_MAX_ELEMENT_SIZE = 1.67771e7;
+var isBrowser = function isBrowser() {
+  return typeof window !== 'undefined';
+};
+var isChrome = function isChrome() {
+  var userAgent = navigator.userAgent;
+  return userAgent.indexOf('Chrome') >= 0;
+};
+export var getMaxElementSize = function getMaxElementSize() {
+  if (isBrowser()) {
+    if (isChrome()) {
+      return CHROME_MAX_ELEMENT_SIZE;
+    }
+  }
+  return DEFAULT_MAX_ELEMENT_SIZE;
+};

package/es/grid/utils/scaling-cell-size-and-position-manager-row.d.ts

@@ -0,0 +1,78 @@
+import type { Alignment, CellSizeGetter, VisibleCellRange } from '../types.js';
+import RowCellSizeAndPositionManager from './cell-size-and-position-manager-row.js';
+type ContainerSizeAndOffset = {
+    containerSize: number;
+    offset: number;
+};
+/**
+ * Browsers have scroll offset limitations (eg Chrome stops scrolling at ~33.5M pixels where as Edge tops out at ~1.5M pixels).
+ * After a certain position, the browser won't allow the user to scroll further (even via JavaScript scroll offset adjustments).
+ * This util picks a lower ceiling for max size and artificially adjusts positions within to make it transparent for users.
+ */
+type Params = {
+    maxScrollSize?: number;
+    cellCount: number;
+    cellSizeGetter: CellSizeGetter;
+    estimatedCellSize: number;
+    cellsHeight: number[];
+    editorAreaHeight: number[];
+    totalSize: number;
+    editorsOffset: number[];
+};
+/**
+ * Extends CellSizeAndPositionManager and adds scaling behavior for lists that are too large to fit within a browser's native limits.
+ */
+export default class RowScalingCellSizeAndPositionManager {
+    _cellSizeAndPositionManager: RowCellSizeAndPositionManager;
+    _maxScrollSize: number;
+    constructor({ maxScrollSize, ...params }: Params);
+    areOffsetsAdjusted(): boolean;
+    configure(params: {
+        cellCount: number;
+        estimatedCellSize: number;
+        cellSizeGetter: CellSizeGetter;
+        cellsHeight: number[];
+        editorAreaHeight: number[];
+        totalSize: number;
+        editorsOffset: number[];
+    }): void;
+    getCellCount(): number;
+    getEstimatedCellSize(): number;
+    getLastMeasuredIndex(): number;
+    /**
+     * Number of pixels a cell at the given position (offset) should be shifted in order to fit within the scaled container.
+     * The offset passed to this function is scaled (safe) as well.
+     */
+    getOffsetAdjustment({ containerSize, offset, }: ContainerSizeAndOffset): number;
+    getSizeAndPositionOfCell(index: number): {
+        offset: number;
+        size: number;
+    };
+    getSizeAndPositionOfLastMeasuredCell(): {
+        offset: number;
+        size: number;
+    };
+    /** See CellSizeAndPositionManager#getTotalSize */
+    getTotalSize(): number;
+    /** See CellSizeAndPositionManager#getUpdatedOffsetForIndex */
+    getUpdatedOffsetForIndex({ align, containerSize, currentOffset, // safe
+    targetIndex, }: {
+        align: Alignment;
+        containerSize: number;
+        currentOffset: number;
+        targetIndex: number;
+    }): number;
+    /** See CellSizeAndPositionManager#getVisibleCellRange */
+    getVisibleCellRange({ containerSize, offset, }: ContainerSizeAndOffset): VisibleCellRange;
+    resetCell(index: number): void;
+    _getOffsetPercentage({ containerSize, offset, // safe
+    totalSize, }: {
+        containerSize: number;
+        offset: number;
+        totalSize: number;
+    }): number;
+    _offsetToSafeOffset({ containerSize, offset, }: ContainerSizeAndOffset): number;
+    _safeOffsetToOffset({ containerSize, offset, }: ContainerSizeAndOffset): number;
+}
+export {};
+//# sourceMappingURL=scaling-cell-size-and-position-manager-row.d.ts.map

package/es/grid/utils/scaling-cell-size-and-position-manager-row.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaling-cell-size-and-position-manager-row.d.ts","sourceRoot":"","sources":["../../../src/grid/utils/scaling-cell-size-and-position-manager-row.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/E,OAAO,6BAA6B,MAAM,yCAAyC,CAAC;AAGpF,KAAK,sBAAsB,GAAG;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;GAIG;AAEH,KAAK,MAAM,GAAG;IACZ,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,cAAc,CAAC;IAC/B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,oCAAoC;IACvD,2BAA2B,EAAE,6BAA6B,CAAC;IAC3D,cAAc,EAAE,MAAM,CAAC;gBAEX,EAAE,aAAmC,EAAE,GAAG,MAAM,EAAE,EAAE,MAAM;IAMtE,kBAAkB,IAAI,OAAO;IAI7B,SAAS,CAAC,MAAM,EAAE;QAChB,SAAS,EAAE,MAAM,CAAC;QAClB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,cAAc,EAAE,cAAc,CAAC;QAC/B,WAAW,EAAE,MAAM,EAAE,CAAC;QACtB,gBAAgB,EAAE,MAAM,EAAE,CAAC;QAC3B,SAAS,EAAE,MAAM,CAAC;QAClB,aAAa,EAAE,MAAM,EAAE,CAAC;KACzB;IAID,YAAY,IAAI,MAAM;IAItB,oBAAoB,IAAI,MAAM;IAI9B,oBAAoB,IAAI,MAAM;IAI9B;;;OAGG;IACH,mBAAmB,CAAC,EAClB,aAAa,EACb,MAAM,GACP,EAAE,sBAAsB,GAAG,MAAM;IAYlC,wBAAwB,CAAC,KAAK,EAAE,MAAM;;;;IAItC,oCAAoC;;;;IAIpC,kDAAkD;IAClD,YAAY,IAAI,MAAM;IAOtB,8DAA8D;IAC9D,wBAAwB,CAAC,EACvB,KAAc,EACd,aAAa,EACb,aAAa,EAAE,OAAO;IACtB,WAAW,GACZ,EAAE;QACD,KAAK,EAAE,SAAS,CAAC;QACjB,aAAa,EAAE,MAAM,CAAC;QACtB,aAAa,EAAE,MAAM,CAAC;QACtB,WAAW,EAAE,MAAM,CAAC;KACrB;IAmBD,yDAAyD;IACzD,mBAAmB,CAAC,EAClB,aAAa,EACb,MAAM,GACP,EAAE,sBAAsB,GAAG,gBAAgB;IAY5C,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAI9B,oBAAoB,CAAC,EACnB,aAAa,EACb,MAAM,EAAE,OAAO;IACf,SAAS,GACV,EAAE;QACD,aAAa,EAAE,MAAM,CAAC;QACtB,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,EAAE,MAAM,CAAC;KACnB;IAID,mBAAmB,CAAC,EAClB,aAAa,EACb,MAAM,GACP,EAAE,sBAAsB,GAAG,MAAM;IAiBlC,mBAAmB,CAAC,EAClB,aAAa,EACb,MAAM,GACP,EAAE,sBAAsB,GAAG,MAAM;CAgBnC"}

package/es/grid/utils/scaling-cell-size-and-position-manager-row.js

@@ -0,0 +1,187 @@
+var _excluded = ["maxScrollSize"];
+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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+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); }
+/* eslint-disable no-param-reassign */
+
+import RowCellSizeAndPositionManager from "./cell-size-and-position-manager-row.js";
+import { getMaxElementSize } from "./max-element-size.js";
+
+/**
+ * Browsers have scroll offset limitations (eg Chrome stops scrolling at ~33.5M pixels where as Edge tops out at ~1.5M pixels).
+ * After a certain position, the browser won't allow the user to scroll further (even via JavaScript scroll offset adjustments).
+ * This util picks a lower ceiling for max size and artificially adjusts positions within to make it transparent for users.
+ */
+/**
+ * Extends CellSizeAndPositionManager and adds scaling behavior for lists that are too large to fit within a browser's native limits.
+ */
+var RowScalingCellSizeAndPositionManager = /*#__PURE__*/function () {
+  function RowScalingCellSizeAndPositionManager(_ref) {
+    var _ref$maxScrollSize = _ref.maxScrollSize,
+      maxScrollSize = _ref$maxScrollSize === void 0 ? getMaxElementSize() : _ref$maxScrollSize,
+      params = _objectWithoutProperties(_ref, _excluded);
+    _classCallCheck(this, RowScalingCellSizeAndPositionManager);
+    // Favor composition over inheritance to simplify IE10 support
+    this._cellSizeAndPositionManager = new RowCellSizeAndPositionManager(params);
+    this._maxScrollSize = maxScrollSize;
+  }
+  _createClass(RowScalingCellSizeAndPositionManager, [{
+    key: "areOffsetsAdjusted",
+    value: function areOffsetsAdjusted() {
+      return this._cellSizeAndPositionManager.getTotalSize() > this._maxScrollSize;
+    }
+  }, {
+    key: "configure",
+    value: function configure(params) {
+      this._cellSizeAndPositionManager.configure(params);
+    }
+  }, {
+    key: "getCellCount",
+    value: function getCellCount() {
+      return this._cellSizeAndPositionManager.getCellCount();
+    }
+  }, {
+    key: "getEstimatedCellSize",
+    value: function getEstimatedCellSize() {
+      return this._cellSizeAndPositionManager.getEstimatedCellSize();
+    }
+  }, {
+    key: "getLastMeasuredIndex",
+    value: function getLastMeasuredIndex() {
+      return this._cellSizeAndPositionManager.getLastMeasuredIndex();
+    }
+
+    /**
+     * Number of pixels a cell at the given position (offset) should be shifted in order to fit within the scaled container.
+     * The offset passed to this function is scaled (safe) as well.
+     */
+  }, {
+    key: "getOffsetAdjustment",
+    value: function getOffsetAdjustment(_ref2) {
+      var containerSize = _ref2.containerSize,
+        offset = _ref2.offset;
+      var totalSize = this._cellSizeAndPositionManager.getTotalSize();
+      var safeTotalSize = this.getTotalSize();
+      var offsetPercentage = this._getOffsetPercentage({
+        containerSize: containerSize,
+        offset: offset,
+        totalSize: safeTotalSize
+      });
+      return Math.round(offsetPercentage * (safeTotalSize - totalSize));
+    }
+  }, {
+    key: "getSizeAndPositionOfCell",
+    value: function getSizeAndPositionOfCell(index) {
+      return this._cellSizeAndPositionManager.getSizeAndPositionOfCell(index);
+    }
+  }, {
+    key: "getSizeAndPositionOfLastMeasuredCell",
+    value: function getSizeAndPositionOfLastMeasuredCell() {
+      return this._cellSizeAndPositionManager.getSizeAndPositionOfLastMeasuredCell();
+    }
+
+    /** See CellSizeAndPositionManager#getTotalSize */
+  }, {
+    key: "getTotalSize",
+    value: function getTotalSize() {
+      return Math.min(this._maxScrollSize, this._cellSizeAndPositionManager.getTotalSize());
+    }
+
+    /** See CellSizeAndPositionManager#getUpdatedOffsetForIndex */
+  }, {
+    key: "getUpdatedOffsetForIndex",
+    value: function getUpdatedOffsetForIndex(_ref3) {
+      var _ref3$align = _ref3.align,
+        align = _ref3$align === void 0 ? 'auto' : _ref3$align,
+        containerSize = _ref3.containerSize,
+        currentOffset = _ref3.currentOffset,
+        targetIndex = _ref3.targetIndex;
+      currentOffset = this._safeOffsetToOffset({
+        containerSize: containerSize,
+        offset: currentOffset
+      });
+      var offset = this._cellSizeAndPositionManager.getUpdatedOffsetForIndex({
+        align: align,
+        containerSize: containerSize,
+        currentOffset: currentOffset,
+        targetIndex: targetIndex
+      });
+      return this._offsetToSafeOffset({
+        containerSize: containerSize,
+        offset: offset
+      });
+    }
+
+    /** See CellSizeAndPositionManager#getVisibleCellRange */
+  }, {
+    key: "getVisibleCellRange",
+    value: function getVisibleCellRange(_ref4) {
+      var containerSize = _ref4.containerSize,
+        offset = _ref4.offset;
+      offset = this._safeOffsetToOffset({
+        containerSize: containerSize,
+        offset: offset
+      });
+      return this._cellSizeAndPositionManager.getVisibleCellRange({
+        containerSize: containerSize,
+        offset: offset
+      });
+    }
+  }, {
+    key: "resetCell",
+    value: function resetCell(index) {
+      this._cellSizeAndPositionManager.resetCell(index);
+    }
+  }, {
+    key: "_getOffsetPercentage",
+    value: function _getOffsetPercentage(_ref5) {
+      var containerSize = _ref5.containerSize,
+        offset = _ref5.offset,
+        totalSize = _ref5.totalSize;
+      return totalSize <= containerSize ? 0 : offset / (totalSize - containerSize);
+    }
+  }, {
+    key: "_offsetToSafeOffset",
+    value: function _offsetToSafeOffset(_ref6) {
+      var containerSize = _ref6.containerSize,
+        offset = _ref6.offset;
+      var totalSize = this._cellSizeAndPositionManager.getTotalSize();
+      var safeTotalSize = this.getTotalSize();
+      if (totalSize === safeTotalSize) {
+        return offset;
+      } else {
+        var offsetPercentage = this._getOffsetPercentage({
+          containerSize: containerSize,
+          offset: offset,
+          totalSize: totalSize
+        });
+        return Math.round(offsetPercentage * (safeTotalSize - containerSize));
+      }
+    }
+  }, {
+    key: "_safeOffsetToOffset",
+    value: function _safeOffsetToOffset(_ref7) {
+      var containerSize = _ref7.containerSize,
+        offset = _ref7.offset;
+      var totalSize = this._cellSizeAndPositionManager.getTotalSize();
+      var safeTotalSize = this.getTotalSize();
+      if (totalSize === safeTotalSize) {
+        return offset;
+      } else {
+        var offsetPercentage = this._getOffsetPercentage({
+          containerSize: containerSize,
+          offset: offset,
+          totalSize: safeTotalSize
+        });
+        return Math.round(offsetPercentage * (totalSize - containerSize));
+      }
+    }
+  }]);
+  return RowScalingCellSizeAndPositionManager;
+}();
+export { RowScalingCellSizeAndPositionManager as default };

package/es/grid/utils/scaling-cell-size-and-position-manager.d.ts

@@ -0,0 +1,70 @@
+import type { Alignment, CellSizeGetter, VisibleCellRange } from '../types.js';
+import CellSizeAndPositionManager from './cell-size-and-position-manager.js';
+type ContainerSizeAndOffset = {
+    containerSize: number;
+    offset: number;
+};
+/**
+ * Browsers have scroll offset limitations (eg Chrome stops scrolling at ~33.5M pixels where as Edge tops out at ~1.5M pixels).
+ * After a certain position, the browser won't allow the user to scroll further (even via JavaScript scroll offset adjustments).
+ * This util picks a lower ceiling for max size and artificially adjusts positions within to make it transparent for users.
+ */
+type Params = {
+    maxScrollSize?: number;
+    cellCount: number;
+    cellSizeGetter: CellSizeGetter;
+    estimatedCellSize: number;
+};
+/**
+ * Extends CellSizeAndPositionManager and adds scaling behavior for lists that are too large to fit within a browser's native limits.
+ */
+export default class ScalingCellSizeAndPositionManager {
+    _cellSizeAndPositionManager: CellSizeAndPositionManager;
+    _maxScrollSize: number;
+    constructor({ maxScrollSize, ...params }: Params);
+    areOffsetsAdjusted(): boolean;
+    configure(params: {
+        cellCount: number;
+        estimatedCellSize: number;
+        cellSizeGetter: CellSizeGetter;
+    }): void;
+    getCellCount(): number;
+    getEstimatedCellSize(): number;
+    getLastMeasuredIndex(): number;
+    /**
+     * Number of pixels a cell at the given position (offset) should be shifted in order to fit within the scaled container.
+     * The offset passed to this function is scaled (safe) as well.
+     */
+    getOffsetAdjustment({ containerSize, offset, }: ContainerSizeAndOffset): number;
+    getSizeAndPositionOfCell(index: number): {
+        offset: number;
+        size: number;
+    };
+    getSizeAndPositionOfLastMeasuredCell(): {
+        offset: number;
+        size: number;
+    };
+    /** See CellSizeAndPositionManager#getTotalSize */
+    getTotalSize(): number;
+    /** See CellSizeAndPositionManager#getUpdatedOffsetForIndex */
+    getUpdatedOffsetForIndex({ align, containerSize, currentOffset, // safe
+    targetIndex, }: {
+        align: Alignment;
+        containerSize: number;
+        currentOffset: number;
+        targetIndex: number;
+    }): number;
+    /** See CellSizeAndPositionManager#getVisibleCellRange */
+    getVisibleCellRange({ containerSize, offset, }: ContainerSizeAndOffset): VisibleCellRange;
+    resetCell(index: number): void;
+    _getOffsetPercentage({ containerSize, offset, // safe
+    totalSize, }: {
+        containerSize: number;
+        offset: number;
+        totalSize: number;
+    }): number;
+    _offsetToSafeOffset({ containerSize, offset, }: ContainerSizeAndOffset): number;
+    _safeOffsetToOffset({ containerSize, offset, }: ContainerSizeAndOffset): number;
+}
+export {};
+//# sourceMappingURL=scaling-cell-size-and-position-manager.d.ts.map

package/es/grid/utils/scaling-cell-size-and-position-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaling-cell-size-and-position-manager.d.ts","sourceRoot":"","sources":["../../../src/grid/utils/scaling-cell-size-and-position-manager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/E,OAAO,0BAA0B,MAAM,qCAAqC,CAAC;AAG7E,KAAK,sBAAsB,GAAG;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;GAIG;AAEH,KAAK,MAAM,GAAG;IACZ,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,cAAc,CAAC;IAC/B,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,iCAAiC;IACpD,2BAA2B,EAAE,0BAA0B,CAAC;IACxD,cAAc,EAAE,MAAM,CAAC;gBAEX,EAAE,aAAmC,EAAE,GAAG,MAAM,EAAE,EAAE,MAAM;IAMtE,kBAAkB,IAAI,OAAO;IAI7B,SAAS,CAAC,MAAM,EAAE;QAChB,SAAS,EAAE,MAAM,CAAC;QAClB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,cAAc,EAAE,cAAc,CAAC;KAChC;IAID,YAAY,IAAI,MAAM;IAItB,oBAAoB,IAAI,MAAM;IAI9B,oBAAoB,IAAI,MAAM;IAI9B;;;OAGG;IACH,mBAAmB,CAAC,EAClB,aAAa,EACb,MAAM,GACP,EAAE,sBAAsB,GAAG,MAAM;IAYlC,wBAAwB,CAAC,KAAK,EAAE,MAAM;;;;IAItC,oCAAoC;;;;IAIpC,kDAAkD;IAClD,YAAY,IAAI,MAAM;IAOtB,8DAA8D;IAC9D,wBAAwB,CAAC,EACvB,KAAc,EACd,aAAa,EACb,aAAa,EAAE,OAAO;IACtB,WAAW,GACZ,EAAE;QACD,KAAK,EAAE,SAAS,CAAC;QACjB,aAAa,EAAE,MAAM,CAAC;QACtB,aAAa,EAAE,MAAM,CAAC;QACtB,WAAW,EAAE,MAAM,CAAC;KACrB;IAmBD,yDAAyD;IACzD,mBAAmB,CAAC,EAClB,aAAa,EACb,MAAM,GACP,EAAE,sBAAsB,GAAG,gBAAgB;IAY5C,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAI9B,oBAAoB,CAAC,EACnB,aAAa,EACb,MAAM,EAAE,OAAO;IACf,SAAS,GACV,EAAE;QACD,aAAa,EAAE,MAAM,CAAC;QACtB,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,EAAE,MAAM,CAAC;KACnB;IAID,mBAAmB,CAAC,EAClB,aAAa,EACb,MAAM,GACP,EAAE,sBAAsB,GAAG,MAAM;IAiBlC,mBAAmB,CAAC,EAClB,aAAa,EACb,MAAM,GACP,EAAE,sBAAsB,GAAG,MAAM;CAgBnC"}