@difizen/libro-virtualized 0.1.2

package/es/grid/utils/scaling-cell-size-and-position-manager.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 CellSizeAndPositionManager from "./cell-size-and-position-manager.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 ScalingCellSizeAndPositionManager = /*#__PURE__*/function () {
+  function ScalingCellSizeAndPositionManager(_ref) {
+    var _ref$maxScrollSize = _ref.maxScrollSize,
+      maxScrollSize = _ref$maxScrollSize === void 0 ? getMaxElementSize() : _ref$maxScrollSize,
+      params = _objectWithoutProperties(_ref, _excluded);
+    _classCallCheck(this, ScalingCellSizeAndPositionManager);
+    // Favor composition over inheritance to simplify IE10 support
+    this._cellSizeAndPositionManager = new CellSizeAndPositionManager(params);
+    this._maxScrollSize = maxScrollSize;
+  }
+  _createClass(ScalingCellSizeAndPositionManager, [{
+    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 ScalingCellSizeAndPositionManager;
+}();
+export { ScalingCellSizeAndPositionManager as default };

package/es/grid/utils/update-scroll-index-helper.d.ts

@@ -0,0 +1,24 @@
+import type { Alignment, CellSize } from '../types.js';
+import type ScalingCellSizeAndPositionManager from './scaling-cell-size-and-position-manager.js';
+/**
+ * Helper function that determines when to update scroll offsets to ensure that a scroll-to-index remains visible.
+ * This function also ensures that the scroll ofset isn't past the last column/row of cells.
+ */
+type Params = {
+    cellSize?: CellSize;
+    cellSizeAndPositionManager: ScalingCellSizeAndPositionManager;
+    previousCellsCount: number;
+    previousCellSize: CellSize;
+    previousScrollToAlignment: Alignment;
+    previousScrollToIndex: number;
+    previousSize: number;
+    scrollOffset: number;
+    scrollToAlignment: Alignment;
+    scrollToIndex: number;
+    size: number;
+    sizeJustIncreasedFromZero: boolean;
+    updateScrollIndexCallback: (index: number) => void;
+};
+export default function updateScrollIndexHelper({ cellSize, cellSizeAndPositionManager, previousCellsCount, previousCellSize, previousScrollToAlignment, previousScrollToIndex, previousSize, scrollOffset, scrollToAlignment, scrollToIndex, size, sizeJustIncreasedFromZero, updateScrollIndexCallback, }: Params): void;
+export {};
+//# sourceMappingURL=update-scroll-index-helper.d.ts.map

package/es/grid/utils/update-scroll-index-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-scroll-index-helper.d.ts","sourceRoot":"","sources":["../../../src/grid/utils/update-scroll-index-helper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvD,OAAO,KAAK,iCAAiC,MAAM,6CAA6C,CAAC;AAEjG;;;GAGG;AAEH,KAAK,MAAM,GAAG;IAEZ,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAGpB,0BAA0B,EAAE,iCAAiC,CAAC;IAG9D,kBAAkB,EAAE,MAAM,CAAC;IAG3B,gBAAgB,EAAE,QAAQ,CAAC;IAE3B,yBAAyB,EAAE,SAAS,CAAC;IAGrC,qBAAqB,EAAE,MAAM,CAAC;IAG9B,YAAY,EAAE,MAAM,CAAC;IAGrB,YAAY,EAAE,MAAM,CAAC;IAErB,iBAAiB,EAAE,SAAS,CAAC;IAG7B,aAAa,EAAE,MAAM,CAAC;IAGtB,IAAI,EAAE,MAAM,CAAC;IAEb,yBAAyB,EAAE,OAAO,CAAC;IAGnC,yBAAyB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACpD,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,uBAAuB,CAAC,EAC9C,QAAQ,EACR,0BAA0B,EAC1B,kBAAkB,EAClB,gBAAgB,EAChB,yBAAyB,EACzB,qBAAqB,EACrB,YAAY,EACZ,YAAY,EACZ,iBAAiB,EACjB,aAAa,EACb,IAAI,EACJ,yBAAyB,EACzB,yBAAyB,GAC1B,EAAE,MAAM,QAkCR"}

package/es/grid/utils/update-scroll-index-helper.js

@@ -0,0 +1,40 @@
+/**
+ * Helper function that determines when to update scroll offsets to ensure that a scroll-to-index remains visible.
+ * This function also ensures that the scroll ofset isn't past the last column/row of cells.
+ */
+
+export default function updateScrollIndexHelper(_ref) {
+  var cellSize = _ref.cellSize,
+    cellSizeAndPositionManager = _ref.cellSizeAndPositionManager,
+    previousCellsCount = _ref.previousCellsCount,
+    previousCellSize = _ref.previousCellSize,
+    previousScrollToAlignment = _ref.previousScrollToAlignment,
+    previousScrollToIndex = _ref.previousScrollToIndex,
+    previousSize = _ref.previousSize,
+    scrollOffset = _ref.scrollOffset,
+    scrollToAlignment = _ref.scrollToAlignment,
+    scrollToIndex = _ref.scrollToIndex,
+    size = _ref.size,
+    sizeJustIncreasedFromZero = _ref.sizeJustIncreasedFromZero,
+    updateScrollIndexCallback = _ref.updateScrollIndexCallback;
+  var cellCount = cellSizeAndPositionManager.getCellCount();
+  var hasScrollToIndex = scrollToIndex >= 0 && scrollToIndex < cellCount;
+  var sizeHasChanged = size !== previousSize || sizeJustIncreasedFromZero || !previousCellSize || typeof cellSize === 'number' && cellSize !== previousCellSize;
+
+  // If we have a new scroll target OR if height/row-height has changed,
+  // We should ensure that the scroll target is visible.
+  if (hasScrollToIndex && (sizeHasChanged || scrollToAlignment !== previousScrollToAlignment || scrollToIndex !== previousScrollToIndex)) {
+    updateScrollIndexCallback(scrollToIndex);
+
+    // If we don't have a selected item but list size or number of children have decreased,
+    // Make sure we aren't scrolled too far past the current content.
+  } else if (!hasScrollToIndex && cellCount > 0 && (size < previousSize || cellCount < previousCellsCount)) {
+    // We need to ensure that the current scroll offset is still within the collection's range.
+    // To do this, we don't need to measure everything; CellMeasurer would perform poorly.
+    // Just check to make sure we're still okay.
+    // Only adjust the scroll position if we've scrolled below the last set of rows.
+    if (scrollOffset > cellSizeAndPositionManager.getTotalSize() - size) {
+      updateScrollIndexCallback(cellCount - 1);
+    }
+  }
+}

package/es/index.d.ts

@@ -0,0 +1,5 @@
+export * from './auto-sizer/index.js';
+export * from './cell-measurer/index.js';
+export * from './grid/index.js';
+export * from './list/index.js';
+//# sourceMappingURL=index.d.ts.map

package/es/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC"}

package/es/index.js

@@ -0,0 +1,4 @@
+export * from "./auto-sizer/index.js";
+export * from "./cell-measurer/index.js";
+export * from "./grid/index.js";
+export * from "./list/index.js";

package/es/list/index.d.ts

@@ -0,0 +1,3 @@
+export { default, default as List } from './list.js';
+export type { RowRendererParams } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/es/list/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/list/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,WAAW,CAAC;AACrD,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC"}

package/es/list/index.js

@@ -0,0 +1 @@
+export { default, default as List } from "./list.js";

package/es/list/list.d.ts

@@ -0,0 +1,109 @@
+import * as React from 'react';
+import type { Alignment, CellPosition, CellRendererParams, CellSize, NoContentRenderer, OverscanIndicesGetter, RenderedSection, Scroll as GridScroll } from '../grid/index.js';
+import Grid, { accessibilityOverscanIndicesGetter } from '../grid/index.js';
+import type { RenderedRows, RowRenderer, Scroll } from './types.js';
+/**
+ * It is inefficient to create and manage a large list of DOM elements within a scrolling container
+ * if only a few of those elements are visible. The primary purpose of this component is to improve
+ * performance by only rendering the DOM nodes that a user is able to see based on their current
+ * scroll position.
+ *
+ * This component renders a virtualized list of elements with either fixed or dynamic heights.
+ */
+type Props = {
+    'aria-label'?: string;
+    /**
+     * Removes fixed height from the scrollingContainer so that the total height
+     * of rows can stretch the window. Intended for use with WindowScroller
+     */
+    autoHeight: boolean;
+    /** Optional CSS class name */
+    className?: string;
+    /**
+     * Used to estimate the total height of a List before all of its rows have actually been measured.
+     * The estimated total height is adjusted as rows are rendered.
+     */
+    estimatedRowSize: number;
+    /** Height constraint for list (determines how many actual rows are rendered) */
+    height: number;
+    /** Optional renderer to be used in place of rows when rowCount is 0 */
+    noRowsRenderer: NoContentRenderer;
+    /** Callback invoked with information about the slice of rows that were just rendered.  */
+    onRowsRendered: (params: RenderedRows) => void;
+    /**
+     * Callback invoked whenever the scroll offset changes within the inner scrollable region.
+     * This callback can be used to sync scrolling between lists, tables, or grids.
+     */
+    onScroll: (params: Scroll) => void;
+    /** See Grid#overscanIndicesGetter */
+    overscanIndicesGetter: OverscanIndicesGetter;
+    /**
+     * Number of rows to render above/below the visible bounds of the list.
+     * These rows can help for smoother scrolling on touch devices.
+     */
+    overscanRowCount: number;
+    /** Either a fixed row height (number) or a function that returns the height of a row given its index.  */
+    rowHeight: CellSize;
+    /** Responsible for rendering a row given an index; ({ index: number }): node */
+    rowRenderer: RowRenderer;
+    /** Number of rows in list. */
+    rowCount: number;
+    /** See Grid#scrollToAlignment */
+    scrollToAlignment: Alignment;
+    /** Row index to ensure visible (by forcefully scrolling if necessary) */
+    scrollToIndex: number;
+    /** Vertical offset. */
+    scrollTop?: number;
+    /** Optional inline style */
+    style: any;
+    /** Tab index for focus */
+    tabIndex?: number;
+    /** Width of list */
+    width: number;
+    cellsHeight: number[];
+    editorsOffset: number[];
+    editorAreaHeight: number[];
+    totalSize: number;
+    noEditorArea: React.ReactElement;
+};
+export default class List extends React.PureComponent<Props> {
+    static defaultProps: {
+        autoHeight: boolean;
+        estimatedRowSize: number;
+        onScroll: () => void;
+        noRowsRenderer: () => null;
+        onRowsRendered: () => void;
+        overscanIndicesGetter: typeof accessibilityOverscanIndicesGetter;
+        overscanRowCount: number;
+        scrollToAlignment: string;
+        scrollToIndex: number;
+        style: {};
+    };
+    Grid?: React.ElementRef<typeof Grid> | null;
+    forceUpdateGrid(): void;
+    /** See Grid#getOffsetForCell */
+    getOffsetForRow({ alignment, index }: {
+        alignment: Alignment;
+        index: number;
+    }): number;
+    /** CellMeasurer compatibility */
+    invalidateCellSizeAfterRender({ columnIndex, rowIndex }: CellPosition): void;
+    /** See Grid#measureAllCells */
+    measureAllRows(): void;
+    /** CellMeasurer compatibility */
+    recomputeGridSize({ columnIndex, rowIndex }?: CellPosition): void;
+    /** See Grid#recomputeGridSize */
+    recomputeRowHeights(index?: number): void;
+    scrollToLine(cellIndex?: number, lineIndex?: number): void;
+    /** See Grid#scrollToPosition */
+    scrollToPosition(scrollTop?: number): void;
+    /** See Grid#scrollToCell */
+    scrollToRow(index?: number): void;
+    render(): import("react/jsx-runtime").JSX.Element;
+    _cellRenderer: ({ parent, rowIndex, style, isScrolling, isVisible, key, }: CellRendererParams) => React.ReactNode;
+    _setRef: (ref: React.ElementRef<typeof Grid> | null) => void;
+    _onScroll: ({ clientHeight, scrollHeight, scrollTop }: GridScroll) => void;
+    _onSectionRendered: ({ rowOverscanStartIndex, rowOverscanStopIndex, rowStartIndex, rowStopIndex, }: RenderedSection) => void;
+}
+export {};
+//# sourceMappingURL=list.d.ts.map

package/es/list/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../src/list/list.tsx"],"names":[],"mappings":"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"}

package/es/list/list.js

@@ -0,0 +1,261 @@
+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 ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+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 classNames from 'classnames';
+import * as React from 'react';
+import Grid, { accessibilityOverscanIndicesGetter } from "../grid/index.js";
+
+/**
+ * It is inefficient to create and manage a large list of DOM elements within a scrolling container
+ * if only a few of those elements are visible. The primary purpose of this component is to improve
+ * performance by only rendering the DOM nodes that a user is able to see based on their current
+ * scroll position.
+ *
+ * This component renders a virtualized list of elements with either fixed or dynamic heights.
+ */
+import { jsx as _jsx } from "react/jsx-runtime";
+var List = /*#__PURE__*/function (_React$PureComponent) {
+  _inherits(List, _React$PureComponent);
+  var _super = _createSuper(List);
+  function List() {
+    var _this;
+    _classCallCheck(this, List);
+    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._cellRenderer = function (_ref) {
+      var parent = _ref.parent,
+        rowIndex = _ref.rowIndex,
+        style = _ref.style,
+        isScrolling = _ref.isScrolling,
+        isVisible = _ref.isVisible,
+        key = _ref.key;
+      var rowRenderer = _this.props.rowRenderer;
+
+      // TRICKY The style object is sometimes cached by Grid.
+      // This prevents new style objects from bypassing shallowCompare().
+      // However as of React 16, style props are auto-frozen (at least in dev mode)
+      // Check to make sure we can still modify the style before proceeding.
+      // https://github.com/facebook/react/commit/977357765b44af8ff0cfea327866861073095c12#commitcomment-20648713
+      // const { writable } = Object.getOwnPropertyDescriptor(style, 'width');
+      // if (writable) {
+      //   // By default, List cells should be 100% width.
+      //   // This prevents them from flowing under a scrollbar (if present).
+      //   style.width = '100%';
+      // }
+
+      return rowRenderer({
+        index: rowIndex,
+        style: style,
+        isScrolling: isScrolling,
+        isVisible: isVisible,
+        key: key,
+        parent: parent
+      });
+    };
+    _this._setRef = function (ref) {
+      _this.Grid = ref;
+    };
+    _this._onScroll = function (_ref2) {
+      var clientHeight = _ref2.clientHeight,
+        scrollHeight = _ref2.scrollHeight,
+        scrollTop = _ref2.scrollTop;
+      var onScroll = _this.props.onScroll;
+      onScroll({
+        clientHeight: clientHeight,
+        scrollHeight: scrollHeight,
+        scrollTop: scrollTop
+      });
+    };
+    _this._onSectionRendered = function (_ref3) {
+      var rowOverscanStartIndex = _ref3.rowOverscanStartIndex,
+        rowOverscanStopIndex = _ref3.rowOverscanStopIndex,
+        rowStartIndex = _ref3.rowStartIndex,
+        rowStopIndex = _ref3.rowStopIndex;
+      var onRowsRendered = _this.props.onRowsRendered;
+      onRowsRendered({
+        overscanStartIndex: rowOverscanStartIndex,
+        overscanStopIndex: rowOverscanStopIndex,
+        startIndex: rowStartIndex,
+        stopIndex: rowStopIndex
+      });
+    };
+    return _this;
+  }
+  _createClass(List, [{
+    key: "forceUpdateGrid",
+    value: function forceUpdateGrid() {
+      if (this.Grid) {
+        this.Grid.forceUpdate();
+      }
+    }
+
+    /** See Grid#getOffsetForCell */
+  }, {
+    key: "getOffsetForRow",
+    value: function getOffsetForRow(_ref4) {
+      var alignment = _ref4.alignment,
+        index = _ref4.index;
+      if (this.Grid) {
+        var _this$Grid$getOffsetF = this.Grid.getOffsetForCell({
+            alignment: alignment,
+            rowIndex: index,
+            columnIndex: 0
+          }),
+          scrollTop = _this$Grid$getOffsetF.scrollTop;
+        return scrollTop;
+      }
+      return 0;
+    }
+
+    /** CellMeasurer compatibility */
+  }, {
+    key: "invalidateCellSizeAfterRender",
+    value: function invalidateCellSizeAfterRender(_ref5) {
+      var columnIndex = _ref5.columnIndex,
+        rowIndex = _ref5.rowIndex;
+      if (this.Grid) {
+        this.Grid.invalidateCellSizeAfterRender({
+          rowIndex: rowIndex,
+          columnIndex: columnIndex
+        });
+      }
+    }
+
+    /** See Grid#measureAllCells */
+  }, {
+    key: "measureAllRows",
+    value: function measureAllRows() {
+      if (this.Grid) {
+        this.Grid.measureAllCells();
+      }
+    }
+
+    /** CellMeasurer compatibility */
+  }, {
+    key: "recomputeGridSize",
+    value: function recomputeGridSize() {
+      var _ref6 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+          columnIndex: 0,
+          rowIndex: 0
+        },
+        _ref6$columnIndex = _ref6.columnIndex,
+        columnIndex = _ref6$columnIndex === void 0 ? 0 : _ref6$columnIndex,
+        _ref6$rowIndex = _ref6.rowIndex,
+        rowIndex = _ref6$rowIndex === void 0 ? 0 : _ref6$rowIndex;
+      if (this.Grid) {
+        this.Grid.recomputeGridSize({
+          rowIndex: rowIndex,
+          columnIndex: columnIndex
+        });
+      }
+    }
+
+    /** See Grid#recomputeGridSize */
+  }, {
+    key: "recomputeRowHeights",
+    value: function recomputeRowHeights() {
+      var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+      if (this.Grid) {
+        this.Grid.recomputeGridSize({
+          rowIndex: index,
+          columnIndex: 0
+        });
+      }
+    }
+  }, {
+    key: "scrollToLine",
+    value: function scrollToLine() {
+      var cellIndex = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+      var lineIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      if (this.Grid) {
+        this.Grid.scrollToLine({
+          cellIndex: cellIndex,
+          lineIndex: lineIndex
+        });
+      }
+    }
+
+    /** See Grid#scrollToPosition */
+  }, {
+    key: "scrollToPosition",
+    value: function scrollToPosition() {
+      var scrollTop = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+      if (this.Grid) {
+        this.Grid.scrollToPosition({
+          scrollTop: scrollTop
+        });
+      }
+    }
+
+    /** See Grid#scrollToCell */
+  }, {
+    key: "scrollToRow",
+    value: function scrollToRow() {
+      var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+      if (this.Grid) {
+        this.Grid.scrollToCell({
+          columnIndex: 0,
+          rowIndex: index
+        });
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        className = _this$props.className,
+        noRowsRenderer = _this$props.noRowsRenderer,
+        scrollToIndex = _this$props.scrollToIndex,
+        width = _this$props.width;
+      return /*#__PURE__*/_jsx(Grid, _objectSpread(_objectSpread({
+        resizeObserver: {}
+      }, this.props), {}, {
+        autoContainerWidth: true,
+        cellRenderer: this._cellRenderer,
+        className: classNames('ReactVirtualized__List', className),
+        columnWidth: width,
+        columnCount: 1,
+        noContentRenderer: noRowsRenderer,
+        onScroll: this._onScroll,
+        onSectionRendered: this._onSectionRendered,
+        ref: this._setRef,
+        scrollToRow: scrollToIndex
+      }));
+    }
+  }]);
+  return List;
+}(React.PureComponent);
+List.defaultProps = {
+  autoHeight: false,
+  estimatedRowSize: 30,
+  onScroll: function onScroll() {
+    //
+  },
+  noRowsRenderer: function noRowsRenderer() {
+    return null;
+  },
+  onRowsRendered: function onRowsRendered() {
+    //
+  },
+  overscanIndicesGetter: accessibilityOverscanIndicesGetter,
+  overscanRowCount: 10,
+  scrollToAlignment: 'auto',
+  scrollToIndex: -1,
+  style: {}
+};
+export { List as default };