virtual-scroller 1.8.1 → 1.9.0

package/commonjs/VirtualScroller.onRender.js

@@ -0,0 +1,357 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+
+var _debug = _interopRequireWildcard(require("./utility/debug.js"));
+
+var _getStateSnapshot = _interopRequireDefault(require("./utility/getStateSnapshot.js"));
+
+var _shallowEqual = _interopRequireDefault(require("./utility/shallowEqual.js"));
+
+var _Layout = require("./Layout.js");
+
+var _tbody = require("./DOM/tbody.js");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _default() {
+  var _this = this;
+
+  /**
+   * Should be called right after updates to `state` have been rendered.
+   * @param  {object} newState
+   * @param  {object} [prevState]
+   */
+  this._onRender = function (newState, prevState) {
+    (0, _debug["default"])('~ Rendered ~');
+
+    if ((0, _debug.isDebug)()) {
+      (0, _debug["default"])('State', (0, _getStateSnapshot["default"])(newState));
+    }
+
+    if (_this.onStateChange) {
+      if (!(0, _shallowEqual["default"])(newState, prevState)) {
+        _this.onStateChange(newState);
+      }
+    } // Update `<tbody/>` `padding`.
+    // (`<tbody/>` is different in a way that it can't have `margin`, only `padding`).
+    // https://gitlab.com/catamphetamine/virtual-scroller/-/issues/1
+
+
+    if (_this.tbody) {
+      (0, _tbody.setTbodyPadding)(_this.getItemsContainerElement(), newState.beforeItemsHeight, newState.afterItemsHeight);
+    }
+
+    if (!prevState) {
+      return;
+    } // `this.resetStateUpdateFlags()` must be called before calling
+    // `this.measureItemHeightsAndSpacing()`.
+
+
+    var _resetStateUpdateFlag = resetStateUpdateFlags.call(_this),
+        nonMeasuredItemsHaveBeenRendered = _resetStateUpdateFlag.nonMeasuredItemsHaveBeenRendered,
+        widthHasChanged = _resetStateUpdateFlag.widthHasChanged;
+
+    var layoutUpdateReason; // If the `VirtualScroller`, while calculating layout parameters, encounters
+    // a not-shown item with a non-measured height, it calls `updateState()` just to
+    // render that item first, and then, after the list has been re-rendered, it measures
+    // the item's height and then proceeds with calculating the correct layout parameters.
+
+    if (nonMeasuredItemsHaveBeenRendered) {
+      layoutUpdateReason = _Layout.LAYOUT_REASON.NON_MEASURED_ITEMS_HAVE_BEEN_MEASURED;
+    } // If scrollable container width has changed, and it has been re-rendered,
+    // then it's time to measure the new item heights and then perform a re-layout
+    // with the correctly calculated layout parameters.
+    //
+    // A re-layout is required because the layout parameters calculated on resize
+    // are approximate ones, and the exact item heights aren't known at that point.
+    // So on resize, it calls `updateState()` just to re-render the `VirtualScroller`.
+    // After it has been re-rendered, it will measure item heights and then calculate
+    // correct layout parameters.
+    //
+
+
+    if (widthHasChanged) {
+      layoutUpdateReason = _Layout.LAYOUT_REASON.VIEWPORT_WIDTH_CHANGED; // Reset measured item heights on viewport width change.
+
+      _this.itemHeights.reset(); // Reset `verticalSpacing` (will be re-measured).
+
+
+      _this.verticalSpacing = undefined;
+    }
+
+    var previousItems = prevState.items;
+    var newItems = newState.items; // Even if `this.newItemsWillBeRendered` flag is `true`,
+    // `newItems` could still be equal to `previousItems`.
+    // For example, when `updateState()` calls don't update `state` immediately
+    // and a developer first calls `setItems(newItems)` and then calls `setItems(oldItems)`:
+    // in that case, `this.newItemsWillBeRendered` flag will be `true` but the actual `items`
+    // in state wouldn't have changed due to the first `updateState()` call being overwritten
+    // by the second `updateState()` call (that's called "batching state updates" in React).
+
+    if (newItems !== previousItems) {
+      var itemsDiff = _this.getItemsDiff(previousItems, newItems);
+
+      if (itemsDiff) {
+        // The call to `.onPrepend()` must precede the call to `.measureItemHeights()`
+        // which is called in `.onRender()`.
+        // `this.itemHeights.onPrepend()` updates `firstMeasuredItemIndex`
+        // and `lastMeasuredItemIndex` of `this.itemHeights`.
+        var prependedItemsCount = itemsDiff.prependedItemsCount;
+
+        _this.itemHeights.onPrepend(prependedItemsCount);
+      } else {
+        _this.itemHeights.reset();
+      }
+
+      if (!widthHasChanged) {
+        // The call to `this.onNewItemsRendered()` must precede the call to
+        // `.measureItemHeights()` which is called in `.onRender()` because
+        // `this.onNewItemsRendered()` updates `firstMeasuredItemIndex` and
+        // `lastMeasuredItemIndex` of `this.itemHeights` in case of a prepend.
+        //
+        // If after prepending items the scroll position
+        // should be "restored" so that there's no "jump" of content
+        // then it means that all previous items have just been rendered
+        // in a single pass, and there's no need to update layout again.
+        //
+        if (onNewItemsRendered.call(_this, itemsDiff, newState) !== 'SEAMLESS_PREPEND') {
+          layoutUpdateReason = _Layout.LAYOUT_REASON.ITEMS_CHANGED;
+        }
+      }
+    }
+
+    var stateUpdate; // Re-measure item heights.
+    // Also, measure vertical spacing (if not measured) and fix `<table/>` padding.
+    //
+    // This block should go after `if (newItems !== previousItems) {}`
+    // because `this.itemHeights` can get `.reset()` there, which would
+    // discard all the measurements done here, and having currently shown
+    // item height measurements is required.
+    //
+
+    if (newState.firstShownItemIndex !== prevState.firstShownItemIndex || newState.lastShownItemIndex !== prevState.lastShownItemIndex || newState.items !== prevState.items || widthHasChanged) {
+      var verticalSpacingStateUpdate = _this.measureItemHeightsAndSpacing();
+
+      if (verticalSpacingStateUpdate) {
+        stateUpdate = _objectSpread(_objectSpread({}, stateUpdate), verticalSpacingStateUpdate);
+      }
+    } // Clean up "before resize" item heights and adjust the scroll position accordingly.
+    // Calling `this.beforeResize.cleanUpBeforeResizeItemHeights()` might trigger
+    // a `this.updateState()` call but that wouldn't matter because `beforeResize`
+    // properties have already been modified directly in `state` (a hacky technique)
+
+
+    var cleanedUpBeforeResize = _this.beforeResize.cleanUpBeforeResizeItemHeights();
+
+    if (cleanedUpBeforeResize !== undefined) {
+      var scrollBy = cleanedUpBeforeResize.scrollBy,
+          beforeResize = cleanedUpBeforeResize.beforeResize;
+      (0, _debug["default"])('Correct scroll position by', scrollBy);
+
+      _this.scroll.scrollByY(scrollBy);
+
+      stateUpdate = _objectSpread(_objectSpread({}, stateUpdate), {}, {
+        beforeResize: beforeResize
+      });
+    }
+
+    if (!_this._isActive) {
+      _this._stoppedStateUpdate = stateUpdate;
+      return;
+    }
+
+    if (layoutUpdateReason) {
+      updateStateRightAfterRender.call(_this, {
+        stateUpdate: stateUpdate,
+        reason: layoutUpdateReason
+      });
+    } else if (stateUpdate) {
+      _this.updateState(stateUpdate);
+    } else {
+      (0, _debug["default"])('~ Finished Layout ~');
+    }
+  }; // After a new set of items has been rendered:
+  //
+  // * Restores scroll position when using `preserveScrollPositionOnPrependItems`
+  //   and items have been prepended.
+  //
+  // * Applies any "pending" `itemHeights` updates — those ones that happened
+  //   while an asynchronous `updateState()` call in `setItems()` was pending.
+  //
+  // * Either creates or resets the snapshot of the current layout.
+  //
+  //   The current layout snapshot could be stored as a "previously calculated layout" variable
+  //   so that it could theoretically be used when calculating new layout incrementally
+  //   rather than from scratch, which would be an optimization.
+  //
+  //   The "previously calculated layout" feature is not currently used.
+  //
+
+
+  function onNewItemsRendered(itemsDiff, newLayout) {
+    // If it's an "incremental" update.
+    if (itemsDiff) {
+      var prependedItemsCount = itemsDiff.prependedItemsCount,
+          appendedItemsCount = itemsDiff.appendedItemsCount;
+
+      var _this$getState = this.getState(),
+          itemHeights = _this$getState.itemHeights,
+          itemStates = _this$getState.itemStates; // See if any items' heights changed while new items were being rendered.
+
+
+      if (this.itemHeightsThatChangedWhileNewItemsWereBeingRendered) {
+        for (var _i = 0, _Object$keys = Object.keys(this.itemHeightsThatChangedWhileNewItemsWereBeingRendered); _i < _Object$keys.length; _i++) {
+          var i = _Object$keys[_i];
+          itemHeights[prependedItemsCount + parseInt(i)] = this.itemHeightsThatChangedWhileNewItemsWereBeingRendered[i];
+        }
+      } // See if any items' states changed while new items were being rendered.
+
+
+      if (this.itemStatesThatChangedWhileNewItemsWereBeingRendered) {
+        for (var _i2 = 0, _Object$keys2 = Object.keys(this.itemStatesThatChangedWhileNewItemsWereBeingRendered); _i2 < _Object$keys2.length; _i2++) {
+          var _i3 = _Object$keys2[_i2];
+          itemStates[prependedItemsCount + parseInt(_i3)] = this.itemStatesThatChangedWhileNewItemsWereBeingRendered[_i3];
+        }
+      }
+
+      if (prependedItemsCount === 0) {
+        // Adjust `this.previouslyCalculatedLayout`.
+        if (this.previouslyCalculatedLayout) {
+          if (this.previouslyCalculatedLayout.firstShownItemIndex === newLayout.firstShownItemIndex && this.previouslyCalculatedLayout.lastShownItemIndex === newLayout.lastShownItemIndex) {// `this.previouslyCalculatedLayout` stays the same.
+            // `firstShownItemIndex` / `lastShownItemIndex` didn't get changed in `setItems()`,
+            // so `beforeItemsHeight` and `shownItemsHeight` also stayed the same.
+          } else {
+            (0, _debug.warn)('Unexpected (non-matching) "firstShownItemIndex" or "lastShownItemIndex" encountered in "onRender()" after appending items');
+            (0, _debug.warn)('Previously calculated layout', this.previouslyCalculatedLayout);
+            (0, _debug.warn)('New layout', newLayout);
+            this.previouslyCalculatedLayout = undefined;
+          }
+        }
+
+        return 'SEAMLESS_APPEND';
+      } else {
+        if (this.listHeightMeasurement.hasSnapshot()) {
+          if (newLayout.firstShownItemIndex === 0) {
+            // Restore (adjust) scroll position.
+            (0, _debug["default"])('~ Restore Scroll Position ~');
+            var listBottomOffsetChange = this.listHeightMeasurement.getListBottomOffsetChange({
+              beforeItemsHeight: newLayout.beforeItemsHeight
+            });
+            this.listHeightMeasurement.reset();
+
+            if (listBottomOffsetChange) {
+              (0, _debug["default"])('Scroll down by', listBottomOffsetChange);
+              this.scroll.scrollByY(listBottomOffsetChange);
+            } else {
+              (0, _debug["default"])('Scroll position hasn\'t changed');
+            } // Create new `this.previouslyCalculatedLayout`.
+
+
+            if (this.previouslyCalculatedLayout) {
+              if (this.previouslyCalculatedLayout.firstShownItemIndex === 0 && this.previouslyCalculatedLayout.lastShownItemIndex === newLayout.lastShownItemIndex - prependedItemsCount) {
+                this.previouslyCalculatedLayout = {
+                  beforeItemsHeight: 0,
+                  shownItemsHeight: this.previouslyCalculatedLayout.shownItemsHeight + listBottomOffsetChange,
+                  firstShownItemIndex: 0,
+                  lastShownItemIndex: newLayout.lastShownItemIndex
+                };
+              } else {
+                (0, _debug.warn)('Unexpected (non-matching) "firstShownItemIndex" or "lastShownItemIndex" encountered in "onRender()" after prepending items');
+                (0, _debug.warn)('Previously calculated layout', this.previouslyCalculatedLayout);
+                (0, _debug.warn)('New layout', newLayout);
+                this.previouslyCalculatedLayout = undefined;
+              }
+            }
+
+            return 'SEAMLESS_PREPEND';
+          } else {
+            (0, _debug.warn)("Unexpected \"firstShownItemIndex\" ".concat(newLayout.firstShownItemIndex, " encountered in \"onRender()\" after prepending items. Expected 0."));
+          }
+        }
+      }
+    } // Reset `this.previouslyCalculatedLayout` in any case other than
+    // SEAMLESS_PREPEND or SEAMLESS_APPEND.
+
+
+    this.previouslyCalculatedLayout = undefined;
+  }
+
+  function updateStateRightAfterRender(_ref) {
+    var reason = _ref.reason,
+        stateUpdate = _ref.stateUpdate;
+
+    // In React, `setTimeout()` is used to prevent a React error:
+    // "Maximum update depth exceeded.
+    //  This can happen when a component repeatedly calls
+    //  `.updateState()` inside `componentWillUpdate()` or `componentDidUpdate()`.
+    //  React limits the number of nested updates to prevent infinite loops."
+    if (this._useTimeoutInRenderLoop) {
+      // Cancel a previously scheduled re-layout.
+      stateUpdate = this.cancelLayoutTimer({
+        stateUpdate: stateUpdate
+      }); // Schedule a new re-layout.
+
+      this.scheduleLayoutTimer({
+        reason: reason,
+        stateUpdate: stateUpdate
+      });
+    } else {
+      this.onUpdateShownItemIndexes({
+        reason: reason,
+        stateUpdate: stateUpdate
+      });
+    }
+  }
+
+  function resetStateUpdateFlags() {
+    // Read and reset `this.widthHasChanged` flag.
+    //
+    // If `this.widthHasChanged` flag was reset after calling
+    // `this.measureWidthHeightsAndSpacingAndUpdateTablePadding()`
+    // then there would be a bug because
+    // `this.measureWidthHeightsAndSpacingAndUpdateTablePadding()`
+    // calls `this.updateState({ verticalSpacing })` which calls
+    // `this.onRender()` immediately, so `this.widthHasChanged`
+    // flag wouldn't be reset by that time and would trigger things
+    // like `this.itemHeights.reset()` a second time.
+    //
+    // So, instead read the value of `this.widthHasChanged` flag
+    // and reset it right away to prevent any such potential bugs.
+    //
+    var widthHasChanged = Boolean(this.widthHasChanged); //
+    // Reset `this.widthHasChanged` flag.
+
+    this.widthHasChanged = undefined; // Read `this.firstNonMeasuredItemIndex` flag.
+
+    var nonMeasuredItemsHaveBeenRendered = this.firstNonMeasuredItemIndex !== undefined; // Reset `this.firstNonMeasuredItemIndex` flag.
+
+    this.firstNonMeasuredItemIndex = undefined; // Reset `this.newItemsWillBeRendered` flag.
+
+    this.newItemsWillBeRendered = undefined; // Reset `this.itemHeightsThatChangedWhileNewItemsWereBeingRendered`.
+
+    this.itemHeightsThatChangedWhileNewItemsWereBeingRendered = undefined; // Reset `this.itemStatesThatChangedWhileNewItemsWereBeingRendered`.
+
+    this.itemStatesThatChangedWhileNewItemsWereBeingRendered = undefined;
+    return {
+      nonMeasuredItemsHaveBeenRendered: nonMeasuredItemsHaveBeenRendered,
+      widthHasChanged: widthHasChanged
+    };
+  }
+}
+//# sourceMappingURL=VirtualScroller.onRender.js.map

package/commonjs/VirtualScroller.onRender.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"VirtualScroller.onRender.js","names":["_onRender","newState","prevState","log","isDebug","getStateSnapshot","onStateChange","shallowEqual","tbody","setTbodyPadding","getItemsContainerElement","beforeItemsHeight","afterItemsHeight","resetStateUpdateFlags","call","nonMeasuredItemsHaveBeenRendered","widthHasChanged","layoutUpdateReason","LAYOUT_REASON","NON_MEASURED_ITEMS_HAVE_BEEN_MEASURED","VIEWPORT_WIDTH_CHANGED","itemHeights","reset","verticalSpacing","undefined","previousItems","items","newItems","itemsDiff","getItemsDiff","prependedItemsCount","onPrepend","onNewItemsRendered","ITEMS_CHANGED","stateUpdate","firstShownItemIndex","lastShownItemIndex","verticalSpacingStateUpdate","measureItemHeightsAndSpacing","cleanedUpBeforeResize","beforeResize","cleanUpBeforeResizeItemHeights","scrollBy","scroll","scrollByY","_isActive","_stoppedStateUpdate","updateStateRightAfterRender","reason","updateState","newLayout","appendedItemsCount","getState","itemStates","itemHeightsThatChangedWhileNewItemsWereBeingRendered","Object","keys","i","parseInt","itemStatesThatChangedWhileNewItemsWereBeingRendered","previouslyCalculatedLayout","warn","listHeightMeasurement","hasSnapshot","listBottomOffsetChange","getListBottomOffsetChange","shownItemsHeight","_useTimeoutInRenderLoop","cancelLayoutTimer","scheduleLayoutTimer","onUpdateShownItemIndexes","Boolean","firstNonMeasuredItemIndex","newItemsWillBeRendered"],"sources":["../source/VirtualScroller.onRender.js"],"sourcesContent":["import log, { warn, isDebug } from './utility/debug.js'\r\nimport getStateSnapshot from './utility/getStateSnapshot.js'\r\nimport shallowEqual from './utility/shallowEqual.js'\r\nimport { LAYOUT_REASON } from './Layout.js'\r\nimport { setTbodyPadding } from './DOM/tbody.js'\r\n\r\nexport default function() {\r\n\t/**\r\n\t * Should be called right after updates to `state` have been rendered.\r\n\t * @param  {object} newState\r\n\t * @param  {object} [prevState]\r\n\t */\r\n\tthis._onRender = (newState, prevState) => {\r\n\t\tlog('~ Rendered ~')\r\n\t\tif (isDebug()) {\r\n\t\t\tlog('State', getStateSnapshot(newState))\r\n\t\t}\r\n\r\n\t\tif (this.onStateChange) {\r\n\t\t\tif (!shallowEqual(newState, prevState)) {\r\n\t\t\t\tthis.onStateChange(newState)\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t// Update `<tbody/>` `padding`.\r\n\t\t// (`<tbody/>` is different in a way that it can't have `margin`, only `padding`).\r\n\t\t// https://gitlab.com/catamphetamine/virtual-scroller/-/issues/1\r\n\t\tif (this.tbody) {\r\n\t\t\tsetTbodyPadding(\r\n\t\t\t\tthis.getItemsContainerElement(),\r\n\t\t\t\tnewState.beforeItemsHeight,\r\n\t\t\t\tnewState.afterItemsHeight\r\n\t\t\t)\r\n\t\t}\r\n\r\n\t\tif (!prevState) {\r\n\t\t\treturn\r\n\t\t}\r\n\r\n\t\t// `this.resetStateUpdateFlags()` must be called before calling\r\n\t\t// `this.measureItemHeightsAndSpacing()`.\r\n\t\tconst {\r\n\t\t\tnonMeasuredItemsHaveBeenRendered,\r\n\t\t\twidthHasChanged\r\n\t\t} = resetStateUpdateFlags.call(this)\r\n\r\n\t\tlet layoutUpdateReason\r\n\r\n\t\t// If the `VirtualScroller`, while calculating layout parameters, encounters\r\n\t\t// a not-shown item with a non-measured height, it calls `updateState()` just to\r\n\t\t// render that item first, and then, after the list has been re-rendered, it measures\r\n\t\t// the item's height and then proceeds with calculating the correct layout parameters.\r\n\t\tif (nonMeasuredItemsHaveBeenRendered) {\r\n\t\t\tlayoutUpdateReason = LAYOUT_REASON.NON_MEASURED_ITEMS_HAVE_BEEN_MEASURED\r\n\t\t}\r\n\r\n\t\t// If scrollable container width has changed, and it has been re-rendered,\r\n\t\t// then it's time to measure the new item heights and then perform a re-layout\r\n\t\t// with the correctly calculated layout parameters.\r\n\t\t//\r\n\t\t// A re-layout is required because the layout parameters calculated on resize\r\n\t\t// are approximate ones, and the exact item heights aren't known at that point.\r\n\t\t// So on resize, it calls `updateState()` just to re-render the `VirtualScroller`.\r\n\t\t// After it has been re-rendered, it will measure item heights and then calculate\r\n\t\t// correct layout parameters.\r\n\t\t//\r\n\t\tif (widthHasChanged) {\r\n\t\t\tlayoutUpdateReason = LAYOUT_REASON.VIEWPORT_WIDTH_CHANGED\r\n\r\n\t\t\t// Reset measured item heights on viewport width change.\r\n\t\t\tthis.itemHeights.reset()\r\n\r\n\t\t\t// Reset `verticalSpacing` (will be re-measured).\r\n\t\t\tthis.verticalSpacing = undefined\r\n\t\t}\r\n\r\n\t\tconst { items: previousItems } = prevState\r\n\t\tconst { items: newItems } = newState\r\n\t\t// Even if `this.newItemsWillBeRendered` flag is `true`,\r\n\t\t// `newItems` could still be equal to `previousItems`.\r\n\t\t// For example, when `updateState()` calls don't update `state` immediately\r\n\t\t// and a developer first calls `setItems(newItems)` and then calls `setItems(oldItems)`:\r\n\t\t// in that case, `this.newItemsWillBeRendered` flag will be `true` but the actual `items`\r\n\t\t// in state wouldn't have changed due to the first `updateState()` call being overwritten\r\n\t\t// by the second `updateState()` call (that's called \"batching state updates\" in React).\r\n\t\tif (newItems !== previousItems) {\r\n\t\t\tconst itemsDiff = this.getItemsDiff(previousItems, newItems)\r\n\t\t\tif (itemsDiff) {\r\n\t\t\t\t// The call to `.onPrepend()` must precede the call to `.measureItemHeights()`\r\n\t\t\t\t// which is called in `.onRender()`.\r\n\t\t\t\t// `this.itemHeights.onPrepend()` updates `firstMeasuredItemIndex`\r\n\t\t\t\t// and `lastMeasuredItemIndex` of `this.itemHeights`.\r\n\t\t\t\tconst { prependedItemsCount } = itemsDiff\r\n\t\t\t\tthis.itemHeights.onPrepend(prependedItemsCount)\r\n\t\t\t} else {\r\n\t\t\t\tthis.itemHeights.reset()\r\n\t\t\t}\r\n\r\n\t\t\tif (!widthHasChanged) {\r\n\t\t\t\t// The call to `this.onNewItemsRendered()` must precede the call to\r\n\t\t\t\t// `.measureItemHeights()` which is called in `.onRender()` because\r\n\t\t\t\t// `this.onNewItemsRendered()` updates `firstMeasuredItemIndex` and\r\n\t\t\t\t// `lastMeasuredItemIndex` of `this.itemHeights` in case of a prepend.\r\n\t\t\t\t//\r\n\t\t\t\t// If after prepending items the scroll position\r\n\t\t\t\t// should be \"restored\" so that there's no \"jump\" of content\r\n\t\t\t\t// then it means that all previous items have just been rendered\r\n\t\t\t\t// in a single pass, and there's no need to update layout again.\r\n\t\t\t\t//\r\n\t\t\t\tif (onNewItemsRendered.call(this, itemsDiff, newState) !== 'SEAMLESS_PREPEND') {\r\n\t\t\t\t\tlayoutUpdateReason = LAYOUT_REASON.ITEMS_CHANGED\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tlet stateUpdate\r\n\r\n\t\t// Re-measure item heights.\r\n\t\t// Also, measure vertical spacing (if not measured) and fix `<table/>` padding.\r\n\t\t//\r\n\t\t// This block should go after `if (newItems !== previousItems) {}`\r\n\t\t// because `this.itemHeights` can get `.reset()` there, which would\r\n\t\t// discard all the measurements done here, and having currently shown\r\n\t\t// item height measurements is required.\r\n\t\t//\r\n\t\tif (\r\n\t\t\tnewState.firstShownItemIndex !== prevState.firstShownItemIndex ||\r\n\t\t\tnewState.lastShownItemIndex !== prevState.lastShownItemIndex ||\r\n\t\t\tnewState.items !== prevState.items ||\r\n\t\t\twidthHasChanged\r\n\t\t) {\r\n\t\t\tconst verticalSpacingStateUpdate = this.measureItemHeightsAndSpacing()\r\n\t\t\tif (verticalSpacingStateUpdate) {\r\n\t\t\t\tstateUpdate = {\r\n\t\t\t\t\t...stateUpdate,\r\n\t\t\t\t\t...verticalSpacingStateUpdate\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t// Clean up \"before resize\" item heights and adjust the scroll position accordingly.\r\n\t\t// Calling `this.beforeResize.cleanUpBeforeResizeItemHeights()` might trigger\r\n\t\t// a `this.updateState()` call but that wouldn't matter because `beforeResize`\r\n\t\t// properties have already been modified directly in `state` (a hacky technique)\r\n\t\tconst cleanedUpBeforeResize = this.beforeResize.cleanUpBeforeResizeItemHeights()\r\n\t\tif (cleanedUpBeforeResize !== undefined) {\r\n\t\t\tconst { scrollBy, beforeResize } = cleanedUpBeforeResize\r\n\t\t\tlog('Correct scroll position by', scrollBy)\r\n\t\t\tthis.scroll.scrollByY(scrollBy)\r\n\t\t\tstateUpdate = {\r\n\t\t\t\t...stateUpdate,\r\n\t\t\t\tbeforeResize\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tif (!this._isActive) {\r\n\t\t\tthis._stoppedStateUpdate = stateUpdate\r\n\t\t\treturn\r\n\t\t}\r\n\r\n\t\tif (layoutUpdateReason) {\r\n\t\t\tupdateStateRightAfterRender.call(this, {\r\n\t\t\t\tstateUpdate,\r\n\t\t\t\treason: layoutUpdateReason\r\n\t\t\t})\r\n\t\t} else if (stateUpdate) {\r\n\t\t\tthis.updateState(stateUpdate)\r\n\t\t} else {\r\n\t\t\tlog('~ Finished Layout ~')\r\n\t\t}\r\n\t}\r\n\r\n\t// After a new set of items has been rendered:\r\n\t//\r\n\t// * Restores scroll position when using `preserveScrollPositionOnPrependItems`\r\n\t//   and items have been prepended.\r\n\t//\r\n\t// * Applies any \"pending\" `itemHeights` updates — those ones that happened\r\n\t//   while an asynchronous `updateState()` call in `setItems()` was pending.\r\n\t//\r\n\t// * Either creates or resets the snapshot of the current layout.\r\n\t//\r\n\t//   The current layout snapshot could be stored as a \"previously calculated layout\" variable\r\n\t//   so that it could theoretically be used when calculating new layout incrementally\r\n\t//   rather than from scratch, which would be an optimization.\r\n\t//\r\n\t//   The \"previously calculated layout\" feature is not currently used.\r\n\t//\r\n\tfunction onNewItemsRendered(itemsDiff, newLayout) {\r\n\t\t// If it's an \"incremental\" update.\r\n\t\tif (itemsDiff) {\r\n\t\t\tconst {\r\n\t\t\t\tprependedItemsCount,\r\n\t\t\t\tappendedItemsCount\r\n\t\t\t} = itemsDiff\r\n\r\n\t\t\tconst {\r\n\t\t\t\titemHeights,\r\n\t\t\t\titemStates\r\n\t\t\t} = this.getState()\r\n\r\n\t\t\t// See if any items' heights changed while new items were being rendered.\r\n\t\t\tif (this.itemHeightsThatChangedWhileNewItemsWereBeingRendered) {\r\n\t\t\t\tfor (const i of Object.keys(this.itemHeightsThatChangedWhileNewItemsWereBeingRendered)) {\r\n\t\t\t\t\titemHeights[prependedItemsCount + parseInt(i)] = this.itemHeightsThatChangedWhileNewItemsWereBeingRendered[i]\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\t// See if any items' states changed while new items were being rendered.\r\n\t\t\tif (this.itemStatesThatChangedWhileNewItemsWereBeingRendered) {\r\n\t\t\t\tfor (const i of Object.keys(this.itemStatesThatChangedWhileNewItemsWereBeingRendered)) {\r\n\t\t\t\t\titemStates[prependedItemsCount + parseInt(i)] = this.itemStatesThatChangedWhileNewItemsWereBeingRendered[i]\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\tif (prependedItemsCount === 0) {\r\n\t\t\t\t// Adjust `this.previouslyCalculatedLayout`.\r\n\t\t\t\tif (this.previouslyCalculatedLayout) {\r\n\t\t\t\t\tif (\r\n\t\t\t\t\t\tthis.previouslyCalculatedLayout.firstShownItemIndex === newLayout.firstShownItemIndex &&\r\n\t\t\t\t\t\tthis.previouslyCalculatedLayout.lastShownItemIndex === newLayout.lastShownItemIndex\r\n\t\t\t\t\t) {\r\n\t\t\t\t\t\t// `this.previouslyCalculatedLayout` stays the same.\r\n\t\t\t\t\t\t// `firstShownItemIndex` / `lastShownItemIndex` didn't get changed in `setItems()`,\r\n\t\t\t\t\t\t// so `beforeItemsHeight` and `shownItemsHeight` also stayed the same.\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\twarn('Unexpected (non-matching) \"firstShownItemIndex\" or \"lastShownItemIndex\" encountered in \"onRender()\" after appending items')\r\n\t\t\t\t\t\twarn('Previously calculated layout', this.previouslyCalculatedLayout)\r\n\t\t\t\t\t\twarn('New layout', newLayout)\r\n\t\t\t\t\t\tthis.previouslyCalculatedLayout = undefined\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\treturn 'SEAMLESS_APPEND'\r\n\t\t\t} else {\r\n\t\t\t\tif (this.listHeightMeasurement.hasSnapshot()) {\r\n\t\t\t\t\tif (newLayout.firstShownItemIndex === 0) {\r\n\t\t\t\t\t\t// Restore (adjust) scroll position.\r\n\t\t\t\t\t\tlog('~ Restore Scroll Position ~')\r\n\t\t\t\t\t\tconst listBottomOffsetChange = this.listHeightMeasurement.getListBottomOffsetChange({\r\n\t\t\t\t\t\t\tbeforeItemsHeight: newLayout.beforeItemsHeight\r\n\t\t\t\t\t\t})\r\n\t\t\t\t\t\tthis.listHeightMeasurement.reset()\r\n\t\t\t\t\t\tif (listBottomOffsetChange) {\r\n\t\t\t\t\t\t\tlog('Scroll down by', listBottomOffsetChange)\r\n\t\t\t\t\t\t\tthis.scroll.scrollByY(listBottomOffsetChange)\r\n\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\tlog('Scroll position hasn\\'t changed')\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\t// Create new `this.previouslyCalculatedLayout`.\r\n\t\t\t\t\t\tif (this.previouslyCalculatedLayout) {\r\n\t\t\t\t\t\t\tif (\r\n\t\t\t\t\t\t\t\tthis.previouslyCalculatedLayout.firstShownItemIndex === 0 &&\r\n\t\t\t\t\t\t\t\tthis.previouslyCalculatedLayout.lastShownItemIndex === newLayout.lastShownItemIndex - prependedItemsCount\r\n\t\t\t\t\t\t\t) {\r\n\t\t\t\t\t\t\t\tthis.previouslyCalculatedLayout = {\r\n\t\t\t\t\t\t\t\t\tbeforeItemsHeight: 0,\r\n\t\t\t\t\t\t\t\t\tshownItemsHeight: this.previouslyCalculatedLayout.shownItemsHeight + listBottomOffsetChange,\r\n\t\t\t\t\t\t\t\t\tfirstShownItemIndex: 0,\r\n\t\t\t\t\t\t\t\t\tlastShownItemIndex: newLayout.lastShownItemIndex\r\n\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\t\twarn('Unexpected (non-matching) \"firstShownItemIndex\" or \"lastShownItemIndex\" encountered in \"onRender()\" after prepending items')\r\n\t\t\t\t\t\t\t\twarn('Previously calculated layout', this.previouslyCalculatedLayout)\r\n\t\t\t\t\t\t\t\twarn('New layout', newLayout)\r\n\t\t\t\t\t\t\t\tthis.previouslyCalculatedLayout = undefined\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\treturn 'SEAMLESS_PREPEND'\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\twarn(`Unexpected \"firstShownItemIndex\" ${newLayout.firstShownItemIndex} encountered in \"onRender()\" after prepending items. Expected 0.`)\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t// Reset `this.previouslyCalculatedLayout` in any case other than\r\n\t\t// SEAMLESS_PREPEND or SEAMLESS_APPEND.\r\n\t\tthis.previouslyCalculatedLayout = undefined\r\n\t}\r\n\r\n\tfunction updateStateRightAfterRender({\r\n\t\treason,\r\n\t\tstateUpdate\r\n\t}) {\r\n\t\t// In React, `setTimeout()` is used to prevent a React error:\r\n\t\t// \"Maximum update depth exceeded.\r\n\t\t//  This can happen when a component repeatedly calls\r\n\t\t//  `.updateState()` inside `componentWillUpdate()` or `componentDidUpdate()`.\r\n\t\t//  React limits the number of nested updates to prevent infinite loops.\"\r\n\t\tif (this._useTimeoutInRenderLoop) {\r\n\t\t\t// Cancel a previously scheduled re-layout.\r\n\t\t\tstateUpdate = this.cancelLayoutTimer({ stateUpdate })\r\n\t\t\t// Schedule a new re-layout.\r\n\t\t\tthis.scheduleLayoutTimer({\r\n\t\t\t\treason,\r\n\t\t\t\tstateUpdate\r\n\t\t\t})\r\n\t\t} else {\r\n\t\t\tthis.onUpdateShownItemIndexes({\r\n\t\t\t\treason,\r\n\t\t\t\tstateUpdate\r\n\t\t\t})\r\n\t\t}\r\n\t}\r\n\r\n\tfunction resetStateUpdateFlags() {\r\n\t\t// Read and reset `this.widthHasChanged` flag.\r\n\t\t//\r\n\t\t// If `this.widthHasChanged` flag was reset after calling\r\n\t\t// `this.measureWidthHeightsAndSpacingAndUpdateTablePadding()`\r\n\t\t// then there would be a bug because\r\n\t\t// `this.measureWidthHeightsAndSpacingAndUpdateTablePadding()`\r\n\t\t// calls `this.updateState({ verticalSpacing })` which calls\r\n\t\t// `this.onRender()` immediately, so `this.widthHasChanged`\r\n\t\t// flag wouldn't be reset by that time and would trigger things\r\n\t\t// like `this.itemHeights.reset()` a second time.\r\n\t\t//\r\n\t\t// So, instead read the value of `this.widthHasChanged` flag\r\n\t\t// and reset it right away to prevent any such potential bugs.\r\n\t\t//\r\n\t\tconst widthHasChanged = Boolean(this.widthHasChanged)\r\n\t\t//\r\n\t\t// Reset `this.widthHasChanged` flag.\r\n\t\tthis.widthHasChanged = undefined\r\n\r\n\t\t// Read `this.firstNonMeasuredItemIndex` flag.\r\n\t\tconst nonMeasuredItemsHaveBeenRendered = this.firstNonMeasuredItemIndex !== undefined\r\n\t\t// Reset `this.firstNonMeasuredItemIndex` flag.\r\n\t\tthis.firstNonMeasuredItemIndex = undefined\r\n\r\n\t\t// Reset `this.newItemsWillBeRendered` flag.\r\n\t\tthis.newItemsWillBeRendered = undefined\r\n\r\n\t\t// Reset `this.itemHeightsThatChangedWhileNewItemsWereBeingRendered`.\r\n\t\tthis.itemHeightsThatChangedWhileNewItemsWereBeingRendered = undefined\r\n\r\n\t\t// Reset `this.itemStatesThatChangedWhileNewItemsWereBeingRendered`.\r\n\t\tthis.itemStatesThatChangedWhileNewItemsWereBeingRendered = undefined\r\n\r\n\t\treturn {\r\n\t\t\tnonMeasuredItemsHaveBeenRendered,\r\n\t\t\twidthHasChanged\r\n\t\t}\r\n\t}\r\n}"],"mappings":"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"}

package/commonjs/VirtualScroller.resize.js

@@ -0,0 +1,186 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = _default;
+
+var _debug = _interopRequireDefault(require("./utility/debug.js"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _default() {
+  var _this = this;
+
+  this.onResize = function () {
+    // Reset "previously calculated layout".
+    //
+    // The "previously calculated layout" feature is not currently used.
+    //
+    // The current layout snapshot could be stored as a "previously calculated layout" variable
+    // so that it could theoretically be used when calculating new layout incrementally
+    // rather than from scratch, which would be an optimization.
+    //
+    _this.previouslyCalculatedLayout = undefined; // Cancel any potential scheduled scroll position restoration.
+
+    _this.listHeightMeasurement.reset(); // Get the most recent items count.
+    // If there're a "pending" `setItems()` call then use the items count from that call
+    // instead of using the count of currently shown `items` from `state`.
+    // A `setItems()` call is "pending" when `updateState()` operation is "asynchronous", that is
+    // when `updateState()` calls aren't applied immediately, like in React.
+
+
+    var itemsCount = _this.newItemsWillBeRendered ? _this.newItemsWillBeRendered.count : _this.getState().itemHeights.length; // If layout values have been calculated as a result of a "pending" `setItems()` call,
+    // then don't discard those new layout values and use them instead of the ones from `state`.
+    //
+    // A `setItems()` call is "pending" when `updateState()` operation is "asynchronous", that is
+    // when `updateState()` calls aren't applied immediately, like in React.
+    //
+
+    var layout = _this.newItemsWillBeRendered ? _this.newItemsWillBeRendered.layout : _this.getState(); // Update `VirtualScroller` state.
+
+    var newState = {
+      scrollableContainerWidth: _this.scrollableContainer.getWidth(),
+      // This state update should also overwrite all the `state` properties
+      // that are also updated in the "on scroll" handler (`getShownItemIndexes()`):
+      //
+      // * `firstShownItemIndex`
+      // * `lastShownItemIndex`
+      // * `beforeItemsHeight`
+      // * `afterItemsHeight`
+      //
+      // That's because this `updateState()` update has a higher priority
+      // than that of the "on scroll" handler, so it should overwrite
+      // any potential state changes dispatched by the "on scroll" handler.
+      //
+      // All these properties might have changed, but they're not
+      // recalculated here becase they'll be recalculated after
+      // this new state is applied (rendered).
+      //
+      firstShownItemIndex: layout.firstShownItemIndex,
+      lastShownItemIndex: layout.lastShownItemIndex,
+      beforeItemsHeight: layout.beforeItemsHeight,
+      afterItemsHeight: layout.afterItemsHeight,
+      // Reset item heights, because if scrollable container's width (or height)
+      // has changed, then the list width (or height) most likely also has changed,
+      // and also some CSS `@media()` rules might have been added or removed.
+      // So re-render the list entirely.
+      itemHeights: new Array(itemsCount),
+      columnsCount: _this.getActualColumnsCountForState(),
+      // Re-measure vertical spacing after render because new CSS styles
+      // might be applied for the new window width.
+      verticalSpacing: undefined
+    };
+    var firstShownItemIndex = layout.firstShownItemIndex,
+        lastShownItemIndex = layout.lastShownItemIndex; // Get the `columnsCount` for the new window width.
+
+    var newColumnsCount = _this.getActualColumnsCount(); // Re-calculate `firstShownItemIndex` and `lastShownItemIndex`
+    // based on the new `columnsCount` so that the whole row is visible.
+
+
+    var newFirstShownItemIndex = Math.floor(firstShownItemIndex / newColumnsCount) * newColumnsCount;
+    var newLastShownItemIndex = Math.min(Math.ceil((lastShownItemIndex + 1) / newColumnsCount) * newColumnsCount, itemsCount) - 1; // Potentially update `firstShownItemIndex` if it needs to be adjusted in order to
+    // correspond to the new `columnsCount`.
+
+    if (newFirstShownItemIndex !== firstShownItemIndex) {
+      (0, _debug["default"])('Columns Count changed from', _this.getState().columnsCount || 1, 'to', newColumnsCount);
+      (0, _debug["default"])('First Shown Item Index needs to change from', firstShownItemIndex, 'to', newFirstShownItemIndex);
+    } // Always rewrite `firstShownItemIndex` and `lastShownItemIndex`
+    // as part of the `state` update, even if it hasn't been modified.
+    //
+    // The reason is that there could be two subsequent `onResize()` calls:
+    // the first one could be user resizing the window to half of its width,
+    // resulting in an "asynchronous" `updateState()` call, and then, before that
+    // `updateState()` call is applied, a second resize event happens when the user
+    // has resized the window back to its original width, meaning that the
+    // `columnsCount` is back to its original value.
+    // In that case, the final `newFirstShownItemIndex` will be equal to the
+    // original `firstShownItemIndex` that was in `state` before the user
+    // has started resizing the window, so, in the end, `state.firstShownItemIndex`
+    // property wouldn't have changed, but it still has to be part of the final
+    // state update in order to overwrite the previous update of `firstShownItemIndex`
+    // property that has been scheduled to be applied in state after the first resize
+    // happened.
+    //
+
+
+    newState.firstShownItemIndex = newFirstShownItemIndex;
+    newState.lastShownItemIndex = newLastShownItemIndex;
+
+    var verticalSpacing = _this.getVerticalSpacing();
+
+    var columnsCount = _this.getColumnsCount(); // `beforeResize` is always overwritten in `state` here.
+    // (once it has started being tracked in `state`)
+
+
+    if (_this.shouldDiscardBeforeResizeItemHeights() || newFirstShownItemIndex === 0) {
+      if (_this.beforeResize.shouldIncludeBeforeResizeValuesInState()) {
+        newState.beforeResize = undefined;
+      }
+    } // Snapshot "before resize" values in order to preserve the currently
+    // shown items' vertical position on screen so that there's no "content jumping".
+    else {
+      // Keep "before resize" values in order to preserve the currently
+      // shown items' vertical position on screen so that there's no
+      // "content jumping". These "before resize" values will be discarded
+      // when (if) the user scrolls back to the top of the list.
+      newState.beforeResize = {
+        verticalSpacing: verticalSpacing,
+        columnsCount: columnsCount,
+        itemHeights: _this.beforeResize.snapshotBeforeResizeItemHeights({
+          firstShownItemIndex: firstShownItemIndex,
+          newFirstShownItemIndex: newFirstShownItemIndex,
+          newColumnsCount: newColumnsCount
+        })
+      };
+    } // `this.widthHasChanged` tells `VirtualScroller` that it should
+    // temporarily stop other updates (like "on scroll" updates) and wait
+    // for the new `state` to be applied, after which the `onRender()`
+    // function will clear this flag and perform a re-layout.
+    //
+    // A re-layout is required because the layout parameters calculated above
+    // are approximate ones, and the exact item heights aren't known at this point.
+    // So the `updateState()` call below is just to re-render the `VirtualScroller`.
+    // After it has been re-rendered, it will measure item heights and then calculate
+    // correct layout parameters.
+    //
+
+
+    _this.widthHasChanged = {
+      stateUpdate: newState
+    }; // Rerender.
+
+    _this.updateState(newState);
+  }; // Returns whether "before resize" item heights should be discarded
+  // as a result of calling `setItems()` with a new set of items
+  // when an asynchronous `updateState()` call inside that function
+  // hasn't been applied yet.
+  //
+  // If `setItems()` update was an "incremental" one and no items
+  // have been prepended, then `firstShownItemIndex` is preserved,
+  // and all items' heights before it should be kept in order to
+  // preserve the top offset of the first shown item so that there's
+  // no "content jumping".
+  //
+  // If `setItems()` update was an "incremental" one but there're
+  // some prepended items, then it means that now there're new items
+  // with unknown heights at the top, so the top offset of the first
+  // shown item won't be preserved because there're no "before resize"
+  // heights of those items.
+  //
+  // If `setItems()` update was not an "incremental" one, then don't
+  // attempt to restore previous item heights after a potential window
+  // width change because all item heights have been reset.
+  //
+
+
+  this.shouldDiscardBeforeResizeItemHeights = function () {
+    if (_this.newItemsWillBeRendered) {
+      var _this$newItemsWillBeR = _this.newItemsWillBeRendered,
+          prepend = _this$newItemsWillBeR.prepend,
+          replace = _this$newItemsWillBeR.replace;
+      return prepend || replace;
+    }
+  };
+}
+//# sourceMappingURL=VirtualScroller.resize.js.map

package/commonjs/VirtualScroller.resize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"VirtualScroller.resize.js","names":["onResize","previouslyCalculatedLayout","undefined","listHeightMeasurement","reset","itemsCount","newItemsWillBeRendered","count","getState","itemHeights","length","layout","newState","scrollableContainerWidth","scrollableContainer","getWidth","firstShownItemIndex","lastShownItemIndex","beforeItemsHeight","afterItemsHeight","Array","columnsCount","getActualColumnsCountForState","verticalSpacing","newColumnsCount","getActualColumnsCount","newFirstShownItemIndex","Math","floor","newLastShownItemIndex","min","ceil","log","getVerticalSpacing","getColumnsCount","shouldDiscardBeforeResizeItemHeights","beforeResize","shouldIncludeBeforeResizeValuesInState","snapshotBeforeResizeItemHeights","widthHasChanged","stateUpdate","updateState","prepend","replace"],"sources":["../source/VirtualScroller.resize.js"],"sourcesContent":["import log from './utility/debug.js'\r\n\r\nexport default function() {\r\n\tthis.onResize = () => {\r\n\t\t// Reset \"previously calculated layout\".\r\n\t\t//\r\n\t\t// The \"previously calculated layout\" feature is not currently used.\r\n\t\t//\r\n\t\t// The current layout snapshot could be stored as a \"previously calculated layout\" variable\r\n\t\t// so that it could theoretically be used when calculating new layout incrementally\r\n\t\t// rather than from scratch, which would be an optimization.\r\n\t\t//\r\n\t\tthis.previouslyCalculatedLayout = undefined\r\n\r\n\t\t// Cancel any potential scheduled scroll position restoration.\r\n\t\tthis.listHeightMeasurement.reset()\r\n\r\n\t\t// Get the most recent items count.\r\n\t\t// If there're a \"pending\" `setItems()` call then use the items count from that call\r\n\t\t// instead of using the count of currently shown `items` from `state`.\r\n\t\t// A `setItems()` call is \"pending\" when `updateState()` operation is \"asynchronous\", that is\r\n\t\t// when `updateState()` calls aren't applied immediately, like in React.\r\n\t\tconst itemsCount = this.newItemsWillBeRendered\r\n\t\t\t? this.newItemsWillBeRendered.count\r\n\t\t\t: this.getState().itemHeights.length\r\n\r\n\t\t// If layout values have been calculated as a result of a \"pending\" `setItems()` call,\r\n\t\t// then don't discard those new layout values and use them instead of the ones from `state`.\r\n\t\t//\r\n\t\t// A `setItems()` call is \"pending\" when `updateState()` operation is \"asynchronous\", that is\r\n\t\t// when `updateState()` calls aren't applied immediately, like in React.\r\n\t\t//\r\n\t\tconst layout = this.newItemsWillBeRendered\r\n\t\t\t? this.newItemsWillBeRendered.layout\r\n\t\t\t: this.getState()\r\n\r\n\t\t// Update `VirtualScroller` state.\r\n\t\tconst newState = {\r\n\t\t\tscrollableContainerWidth: this.scrollableContainer.getWidth(),\r\n\r\n\t\t\t// This state update should also overwrite all the `state` properties\r\n\t\t\t// that are also updated in the \"on scroll\" handler (`getShownItemIndexes()`):\r\n\t\t\t//\r\n\t\t\t// * `firstShownItemIndex`\r\n\t\t\t// * `lastShownItemIndex`\r\n\t\t\t// * `beforeItemsHeight`\r\n\t\t\t// * `afterItemsHeight`\r\n\t\t\t//\r\n\t\t\t// That's because this `updateState()` update has a higher priority\r\n\t\t\t// than that of the \"on scroll\" handler, so it should overwrite\r\n\t\t\t// any potential state changes dispatched by the \"on scroll\" handler.\r\n\t\t\t//\r\n\t\t\t// All these properties might have changed, but they're not\r\n\t\t\t// recalculated here becase they'll be recalculated after\r\n\t\t\t// this new state is applied (rendered).\r\n\t\t\t//\r\n\t\t\tfirstShownItemIndex: layout.firstShownItemIndex,\r\n\t\t\tlastShownItemIndex: layout.lastShownItemIndex,\r\n\t\t\tbeforeItemsHeight: layout.beforeItemsHeight,\r\n\t\t\tafterItemsHeight: layout.afterItemsHeight,\r\n\r\n\t\t\t// Reset item heights, because if scrollable container's width (or height)\r\n\t\t\t// has changed, then the list width (or height) most likely also has changed,\r\n\t\t\t// and also some CSS `@media()` rules might have been added or removed.\r\n\t\t\t// So re-render the list entirely.\r\n\t\t\titemHeights: new Array(itemsCount),\r\n\r\n\t\t\tcolumnsCount: this.getActualColumnsCountForState(),\r\n\r\n\t\t\t// Re-measure vertical spacing after render because new CSS styles\r\n\t\t\t// might be applied for the new window width.\r\n\t\t\tverticalSpacing: undefined\r\n\t\t}\r\n\r\n\t\tconst { firstShownItemIndex, lastShownItemIndex } = layout\r\n\r\n\t\t// Get the `columnsCount` for the new window width.\r\n\t\tconst newColumnsCount = this.getActualColumnsCount()\r\n\r\n\t\t// Re-calculate `firstShownItemIndex` and `lastShownItemIndex`\r\n\t\t// based on the new `columnsCount` so that the whole row is visible.\r\n\t\tconst newFirstShownItemIndex = Math.floor(firstShownItemIndex / newColumnsCount) * newColumnsCount\r\n\t\tconst newLastShownItemIndex = Math.min(\r\n\t\t\tMath.ceil((lastShownItemIndex + 1) / newColumnsCount) * newColumnsCount,\r\n\t\t\titemsCount\r\n\t\t) - 1\r\n\r\n\t\t// Potentially update `firstShownItemIndex` if it needs to be adjusted in order to\r\n\t\t// correspond to the new `columnsCount`.\r\n\t\tif (newFirstShownItemIndex !== firstShownItemIndex) {\r\n\t\t\tlog('Columns Count changed from', this.getState().columnsCount || 1, 'to', newColumnsCount)\r\n\t\t\tlog('First Shown Item Index needs to change from', firstShownItemIndex, 'to', newFirstShownItemIndex)\r\n\t\t}\r\n\r\n\t\t// Always rewrite `firstShownItemIndex` and `lastShownItemIndex`\r\n\t\t// as part of the `state` update, even if it hasn't been modified.\r\n\t\t//\r\n\t\t// The reason is that there could be two subsequent `onResize()` calls:\r\n\t\t// the first one could be user resizing the window to half of its width,\r\n\t\t// resulting in an \"asynchronous\" `updateState()` call, and then, before that\r\n\t\t// `updateState()` call is applied, a second resize event happens when the user\r\n\t\t// has resized the window back to its original width, meaning that the\r\n\t\t// `columnsCount` is back to its original value.\r\n\t\t// In that case, the final `newFirstShownItemIndex` will be equal to the\r\n\t\t// original `firstShownItemIndex` that was in `state` before the user\r\n\t\t// has started resizing the window, so, in the end, `state.firstShownItemIndex`\r\n\t\t// property wouldn't have changed, but it still has to be part of the final\r\n\t\t// state update in order to overwrite the previous update of `firstShownItemIndex`\r\n\t\t// property that has been scheduled to be applied in state after the first resize\r\n\t\t// happened.\r\n\t\t//\r\n\t\tnewState.firstShownItemIndex = newFirstShownItemIndex\r\n\t\tnewState.lastShownItemIndex = newLastShownItemIndex\r\n\r\n\t\tconst verticalSpacing = this.getVerticalSpacing()\r\n\t\tconst columnsCount = this.getColumnsCount()\r\n\r\n\t\t// `beforeResize` is always overwritten in `state` here.\r\n\t\t// (once it has started being tracked in `state`)\r\n\t\tif (this.shouldDiscardBeforeResizeItemHeights() || newFirstShownItemIndex === 0) {\r\n\t\t\tif (this.beforeResize.shouldIncludeBeforeResizeValuesInState()) {\r\n\t\t\t\tnewState.beforeResize = undefined\r\n\t\t\t}\r\n\t\t}\r\n\t\t// Snapshot \"before resize\" values in order to preserve the currently\r\n\t\t// shown items' vertical position on screen so that there's no \"content jumping\".\r\n\t\telse {\r\n\t\t\t// Keep \"before resize\" values in order to preserve the currently\r\n\t\t\t// shown items' vertical position on screen so that there's no\r\n\t\t\t// \"content jumping\". These \"before resize\" values will be discarded\r\n\t\t\t// when (if) the user scrolls back to the top of the list.\r\n\t\t\tnewState.beforeResize = {\r\n\t\t\t\tverticalSpacing,\r\n\t\t\t\tcolumnsCount,\r\n\t\t\t\titemHeights: this.beforeResize.snapshotBeforeResizeItemHeights({\r\n\t\t\t\t\tfirstShownItemIndex,\r\n\t\t\t\t\tnewFirstShownItemIndex,\r\n\t\t\t\t\tnewColumnsCount\r\n\t\t\t\t})\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t// `this.widthHasChanged` tells `VirtualScroller` that it should\r\n\t\t// temporarily stop other updates (like \"on scroll\" updates) and wait\r\n\t\t// for the new `state` to be applied, after which the `onRender()`\r\n\t\t// function will clear this flag and perform a re-layout.\r\n\t\t//\r\n\t\t// A re-layout is required because the layout parameters calculated above\r\n\t\t// are approximate ones, and the exact item heights aren't known at this point.\r\n\t\t// So the `updateState()` call below is just to re-render the `VirtualScroller`.\r\n\t\t// After it has been re-rendered, it will measure item heights and then calculate\r\n\t\t// correct layout parameters.\r\n\t\t//\r\n\t\tthis.widthHasChanged = {\r\n\t\t\tstateUpdate: newState\r\n\t\t}\r\n\r\n\t\t// Rerender.\r\n\t\tthis.updateState(newState)\r\n\t}\r\n\r\n\t// Returns whether \"before resize\" item heights should be discarded\r\n\t// as a result of calling `setItems()` with a new set of items\r\n\t// when an asynchronous `updateState()` call inside that function\r\n\t// hasn't been applied yet.\r\n\t//\r\n\t// If `setItems()` update was an \"incremental\" one and no items\r\n\t// have been prepended, then `firstShownItemIndex` is preserved,\r\n\t// and all items' heights before it should be kept in order to\r\n\t// preserve the top offset of the first shown item so that there's\r\n\t// no \"content jumping\".\r\n\t//\r\n\t// If `setItems()` update was an \"incremental\" one but there're\r\n\t// some prepended items, then it means that now there're new items\r\n\t// with unknown heights at the top, so the top offset of the first\r\n\t// shown item won't be preserved because there're no \"before resize\"\r\n\t// heights of those items.\r\n\t//\r\n\t// If `setItems()` update was not an \"incremental\" one, then don't\r\n\t// attempt to restore previous item heights after a potential window\r\n\t// width change because all item heights have been reset.\r\n\t//\r\n\tthis.shouldDiscardBeforeResizeItemHeights = () => {\r\n\t\tif (this.newItemsWillBeRendered) {\r\n\t\t\tconst { prepend, replace } = this.newItemsWillBeRendered\r\n\t\t\treturn prepend || replace\r\n\t\t}\r\n\t}\r\n}"],"mappings":";;;;;;;AAAA;;;;AAEe,oBAAW;EAAA;;EACzB,KAAKA,QAAL,GAAgB,YAAM;IACrB;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,KAAI,CAACC,0BAAL,GAAkCC,SAAlC,CATqB,CAWrB;;IACA,KAAI,CAACC,qBAAL,CAA2BC,KAA3B,GAZqB,CAcrB;IACA;IACA;IACA;IACA;;;IACA,IAAMC,UAAU,GAAG,KAAI,CAACC,sBAAL,GAChB,KAAI,CAACA,sBAAL,CAA4BC,KADZ,GAEhB,KAAI,CAACC,QAAL,GAAgBC,WAAhB,CAA4BC,MAF/B,CAnBqB,CAuBrB;IACA;IACA;IACA;IACA;IACA;;IACA,IAAMC,MAAM,GAAG,KAAI,CAACL,sBAAL,GACZ,KAAI,CAACA,sBAAL,CAA4BK,MADhB,GAEZ,KAAI,CAACH,QAAL,EAFH,CA7BqB,CAiCrB;;IACA,IAAMI,QAAQ,GAAG;MAChBC,wBAAwB,EAAE,KAAI,CAACC,mBAAL,CAAyBC,QAAzB,EADV;MAGhB;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACAC,mBAAmB,EAAEL,MAAM,CAACK,mBAnBZ;MAoBhBC,kBAAkB,EAAEN,MAAM,CAACM,kBApBX;MAqBhBC,iBAAiB,EAAEP,MAAM,CAACO,iBArBV;MAsBhBC,gBAAgB,EAAER,MAAM,CAACQ,gBAtBT;MAwBhB;MACA;MACA;MACA;MACAV,WAAW,EAAE,IAAIW,KAAJ,CAAUf,UAAV,CA5BG;MA8BhBgB,YAAY,EAAE,KAAI,CAACC,6BAAL,EA9BE;MAgChB;MACA;MACAC,eAAe,EAAErB;IAlCD,CAAjB;IAqCA,IAAQc,mBAAR,GAAoDL,MAApD,CAAQK,mBAAR;IAAA,IAA6BC,kBAA7B,GAAoDN,MAApD,CAA6BM,kBAA7B,CAvEqB,CAyErB;;IACA,IAAMO,eAAe,GAAG,KAAI,CAACC,qBAAL,EAAxB,CA1EqB,CA4ErB;IACA;;;IACA,IAAMC,sBAAsB,GAAGC,IAAI,CAACC,KAAL,CAAWZ,mBAAmB,GAAGQ,eAAjC,IAAoDA,eAAnF;IACA,IAAMK,qBAAqB,GAAGF,IAAI,CAACG,GAAL,CAC7BH,IAAI,CAACI,IAAL,CAAU,CAACd,kBAAkB,GAAG,CAAtB,IAA2BO,eAArC,IAAwDA,eAD3B,EAE7BnB,UAF6B,IAG1B,CAHJ,CA/EqB,CAoFrB;IACA;;IACA,IAAIqB,sBAAsB,KAAKV,mBAA/B,EAAoD;MACnD,IAAAgB,iBAAA,EAAI,4BAAJ,EAAkC,KAAI,CAACxB,QAAL,GAAgBa,YAAhB,IAAgC,CAAlE,EAAqE,IAArE,EAA2EG,eAA3E;MACA,IAAAQ,iBAAA,EAAI,6CAAJ,EAAmDhB,mBAAnD,EAAwE,IAAxE,EAA8EU,sBAA9E;IACA,CAzFoB,CA2FrB;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;;;IACAd,QAAQ,CAACI,mBAAT,GAA+BU,sBAA/B;IACAd,QAAQ,CAACK,kBAAT,GAA8BY,qBAA9B;;IAEA,IAAMN,eAAe,GAAG,KAAI,CAACU,kBAAL,EAAxB;;IACA,IAAMZ,YAAY,GAAG,KAAI,CAACa,eAAL,EAArB,CAhHqB,CAkHrB;IACA;;;IACA,IAAI,KAAI,CAACC,oCAAL,MAA+CT,sBAAsB,KAAK,CAA9E,EAAiF;MAChF,IAAI,KAAI,CAACU,YAAL,CAAkBC,sCAAlB,EAAJ,EAAgE;QAC/DzB,QAAQ,CAACwB,YAAT,GAAwBlC,SAAxB;MACA;IACD,CAJD,CAKA;IACA;IANA,KAOK;MACJ;MACA;MACA;MACA;MACAU,QAAQ,CAACwB,YAAT,GAAwB;QACvBb,eAAe,EAAfA,eADuB;QAEvBF,YAAY,EAAZA,YAFuB;QAGvBZ,WAAW,EAAE,KAAI,CAAC2B,YAAL,CAAkBE,+BAAlB,CAAkD;UAC9DtB,mBAAmB,EAAnBA,mBAD8D;UAE9DU,sBAAsB,EAAtBA,sBAF8D;UAG9DF,eAAe,EAAfA;QAH8D,CAAlD;MAHU,CAAxB;IASA,CAzIoB,CA2IrB;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;;;IACA,KAAI,CAACe,eAAL,GAAuB;MACtBC,WAAW,EAAE5B;IADS,CAAvB,CAtJqB,CA0JrB;;IACA,KAAI,CAAC6B,WAAL,CAAiB7B,QAAjB;EACA,CA5JD,CADyB,CA+JzB;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;EACA,KAAKuB,oCAAL,GAA4C,YAAM;IACjD,IAAI,KAAI,CAAC7B,sBAAT,EAAiC;MAChC,4BAA6B,KAAI,CAACA,sBAAlC;MAAA,IAAQoC,OAAR,yBAAQA,OAAR;MAAA,IAAiBC,OAAjB,yBAAiBA,OAAjB;MACA,OAAOD,OAAO,IAAIC,OAAlB;IACA;EACD,CALD;AAMA"}