virtual-scroller 1.7.6 → 1.8.0

package/commonjs/utility/px.js

@@ -14,6 +14,6 @@ exports["default"] = px;
  */
 function px(number) {
   // Fractional pixels are used on "retina" screens.
-  return number.toFixed(2) + 'px';
+  return (number % 1 === 0 ? number : number.toFixed(2)) + 'px';
 }
 //# sourceMappingURL=px.js.map

package/commonjs/utility/px.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../source/utility/px.js"],"names":["px","number","toFixed"],"mappings":";;;;;;;AAAA;;;;;;;AAOe,SAASA,EAAT,CAAYC,MAAZ,EAAoB;AAClC;AACC,SAAOA,MAAM,CAACC,OAAP,CAAe,CAAf,IAAoB,IAA3B;AACD","sourcesContent":["/**\r\n * Rounds coordinates upto 4th decimal place (after dot) and appends \"px\".\r\n * Small numbers could be printed as `\"1.2345e-50\"` unless rounded:\r\n * that would be invalid \"px\" value in CSS.\r\n * @param {number}\r\n * @return {string}\r\n */\r\nexport default function px(number) {\r\n\t// Fractional pixels are used on \"retina\" screens.\r\n  return number.toFixed(2) + 'px'\r\n}"],"file":"px.js"}
+{"version":3,"sources":["../../source/utility/px.js"],"names":["px","number","toFixed"],"mappings":";;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASA,EAAT,CAAYC,MAAZ,EAAoB;AAClC;AACC,SAAO,CAACA,MAAM,GAAG,CAAT,KAAe,CAAf,GAAmBA,MAAnB,GAA4BA,MAAM,CAACC,OAAP,CAAe,CAAf,CAA7B,IAAkD,IAAzD;AACD","sourcesContent":["/**\r\n * Rounds coordinates upto 4th decimal place (after dot) and appends \"px\".\r\n * Small numbers could be printed as `\"1.2345e-50\"` unless rounded:\r\n * that would be invalid \"px\" value in CSS.\r\n * @param {number}\r\n * @return {string}\r\n */\r\nexport default function px(number) {\r\n\t// Fractional pixels are used on \"retina\" screens.\r\n  return (number % 1 === 0 ? number : number.toFixed(2)) + 'px'\r\n}"],"file":"px.js"}

package/commonjs/utility/px.test.js

@@ -0,0 +1,14 @@
+"use strict";
+
+var _px = _interopRequireDefault(require("./px"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+describe('utility/px', function () {
+  it('should truncate px values', function () {
+    (0, _px["default"])(0).should.equal('0px');
+    (0, _px["default"])(1).should.equal('1px');
+    (0, _px["default"])(1.2345).should.equal('1.23px');
+  });
+});
+//# sourceMappingURL=px.test.js.map

package/commonjs/utility/px.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../source/utility/px.test.js"],"names":["describe","it","should","equal"],"mappings":";;AAAA;;;;AAEAA,QAAQ,CAAC,YAAD,EAAe,YAAW;AACjCC,EAAAA,EAAE,CAAC,2BAAD,EAA8B,YAAW;AAC1C,wBAAG,CAAH,EAAMC,MAAN,CAAaC,KAAb,CAAmB,KAAnB;AACA,wBAAG,CAAH,EAAMD,MAAN,CAAaC,KAAb,CAAmB,KAAnB;AACA,wBAAG,MAAH,EAAWD,MAAX,CAAkBC,KAAlB,CAAwB,QAAxB;AACA,GAJC,CAAF;AAKA,CANO,CAAR","sourcesContent":["import px from './px'\r\n\r\ndescribe('utility/px', function() {\r\n\tit('should truncate px values', function() {\r\n\t\tpx(0).should.equal('0px')\r\n\t\tpx(1).should.equal('1px')\r\n\t\tpx(1.2345).should.equal('1.23px')\r\n\t})\r\n})"],"file":"px.test.js"}

package/commonjs/utility/shallowEqual.js

@@ -20,7 +20,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports["default"] = shallowEqual;
 
-function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
 
 var hasOwnProperty = Object.prototype.hasOwnProperty;
 /**

package/commonjs/utility/shallowEqual.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../source/utility/shallowEqual.js"],"names":["hasOwnProperty","Object","prototype","is","x","y","shallowEqual","objA","objB","keysA","keys","keysB","length","i","call"],"mappings":"AAAA;AACA;;AAEA;;;;;;;;;;;AAWA;AAEA;;;;;;;;;AAEA,IAAMA,cAAc,GAAGC,MAAM,CAACC,SAAP,CAAiBF,cAAxC;AAEA;;;;;AAIA,SAASG,EAAT,CAAYC,CAAZ,EAAeC,CAAf,EAAkB;AAChB;AACA,MAAID,CAAC,KAAKC,CAAV,EAAa;AAAE;AACb;AACA;AACA,WAAOD,CAAC,KAAK,CAAN,IAAWC,CAAC,KAAK,CAAjB,IAAsB,IAAID,CAAJ,KAAU,IAAIC,CAA3C;AACD,GAJD,MAIO;AACL;AACA,WAAOD,CAAC,KAAKA,CAAN,IAAWC,CAAC,KAAKA,CAAxB;AACD;AACF;AAED;;;;;;;AAKe,SAASC,YAAT,CAAsBC,IAAtB,EAA4BC,IAA5B,EAAkC;AAC/C,MAAIL,EAAE,CAACI,IAAD,EAAOC,IAAP,CAAN,EAAoB;AAClB,WAAO,IAAP;AACD;;AAED,MAAI,QAAOD,IAAP,MAAgB,QAAhB,IAA4BA,IAAI,KAAK,IAArC,IACA,QAAOC,IAAP,MAAgB,QADhB,IAC4BA,IAAI,KAAK,IADzC,EAC+C;AAC7C,WAAO,KAAP;AACD;;AAED,MAAMC,KAAK,GAAGR,MAAM,CAACS,IAAP,CAAYH,IAAZ,CAAd;AACA,MAAMI,KAAK,GAAGV,MAAM,CAACS,IAAP,CAAYF,IAAZ,CAAd;;AAEA,MAAIC,KAAK,CAACG,MAAN,KAAiBD,KAAK,CAACC,MAA3B,EAAmC;AACjC,WAAO,KAAP;AACD,GAf8C,CAiB/C;;;AACA,OAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGJ,KAAK,CAACG,MAA1B,EAAkCC,CAAC,EAAnC,EAAuC;AACrC,QACE,CAACb,cAAc,CAACc,IAAf,CAAoBN,IAApB,EAA0BC,KAAK,CAACI,CAAD,CAA/B,CAAD,IACA,CAACV,EAAE,CAACI,IAAI,CAACE,KAAK,CAACI,CAAD,CAAN,CAAL,EAAiBL,IAAI,CAACC,KAAK,CAACI,CAAD,CAAN,CAArB,CAFL,EAGE;AACA,aAAO,KAAP;AACD;AACF;;AAED,SAAO,IAAP;AACD","sourcesContent":["// https://github.com/lodash/lodash/issues/2340\r\n// https://github.com/facebook/fbjs/blob/master/packages/fbjs/src/core/shallowEqual.js\r\n\r\n/**\r\n * Copyright (c) 2013-present, Facebook, Inc.\r\n *\r\n * This source code is licensed under the MIT license found in the\r\n * LICENSE file in the root directory of this source tree.\r\n *\r\n * @providesModule shallowEqual\r\n * @typechecks\r\n * @flow\r\n */\r\n\r\n/*eslint-disable no-self-compare */\r\n\r\n'use strict';\r\n\r\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\r\n\r\n/**\r\n * inlined Object.is polyfill to avoid requiring consumers ship their own\r\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\r\n */\r\nfunction is(x, y) {\r\n  // SameValue algorithm\r\n  if (x === y) { // Steps 1-5, 7-10\r\n    // Steps 6.b-6.e: +0 != -0\r\n    // Added the nonzero y check to make Flow happy, but it is redundant\r\n    return x !== 0 || y !== 0 || 1 / x === 1 / y;\r\n  } else {\r\n    // Step 6.a: NaN == NaN\r\n    return x !== x && y !== y;\r\n  }\r\n}\r\n\r\n/**\r\n * Performs equality by iterating through keys on an object and returning false\r\n * when any key has values which are not strictly equal between the arguments.\r\n * Returns true when the values of all keys are strictly equal.\r\n */\r\nexport default function shallowEqual(objA, objB) {\r\n  if (is(objA, objB)) {\r\n    return true;\r\n  }\r\n\r\n  if (typeof objA !== 'object' || objA === null ||\r\n      typeof objB !== 'object' || objB === null) {\r\n    return false;\r\n  }\r\n\r\n  const keysA = Object.keys(objA);\r\n  const keysB = Object.keys(objB);\r\n\r\n  if (keysA.length !== keysB.length) {\r\n    return false;\r\n  }\r\n\r\n  // Test for A's keys different from B.\r\n  for (let i = 0; i < keysA.length; i++) {\r\n    if (\r\n      !hasOwnProperty.call(objB, keysA[i]) ||\r\n      !is(objA[keysA[i]], objB[keysA[i]])\r\n    ) {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  return true;\r\n}"],"file":"shallowEqual.js"}
+{"version":3,"sources":["../../source/utility/shallowEqual.js"],"names":["hasOwnProperty","Object","prototype","is","x","y","shallowEqual","objA","objB","keysA","keys","keysB","length","i","call"],"mappings":"AAAA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AAEA;;;;;;;;;AAEA,IAAMA,cAAc,GAAGC,MAAM,CAACC,SAAP,CAAiBF,cAAxC;AAEA;AACA;AACA;AACA;;AACA,SAASG,EAAT,CAAYC,CAAZ,EAAeC,CAAf,EAAkB;AAChB;AACA,MAAID,CAAC,KAAKC,CAAV,EAAa;AAAE;AACb;AACA;AACA,WAAOD,CAAC,KAAK,CAAN,IAAWC,CAAC,KAAK,CAAjB,IAAsB,IAAID,CAAJ,KAAU,IAAIC,CAA3C;AACD,GAJD,MAIO;AACL;AACA,WAAOD,CAAC,KAAKA,CAAN,IAAWC,CAAC,KAAKA,CAAxB;AACD;AACF;AAED;AACA;AACA;AACA;AACA;;;AACe,SAASC,YAAT,CAAsBC,IAAtB,EAA4BC,IAA5B,EAAkC;AAC/C,MAAIL,EAAE,CAACI,IAAD,EAAOC,IAAP,CAAN,EAAoB;AAClB,WAAO,IAAP;AACD;;AAED,MAAI,QAAOD,IAAP,MAAgB,QAAhB,IAA4BA,IAAI,KAAK,IAArC,IACA,QAAOC,IAAP,MAAgB,QADhB,IAC4BA,IAAI,KAAK,IADzC,EAC+C;AAC7C,WAAO,KAAP;AACD;;AAED,MAAMC,KAAK,GAAGR,MAAM,CAACS,IAAP,CAAYH,IAAZ,CAAd;AACA,MAAMI,KAAK,GAAGV,MAAM,CAACS,IAAP,CAAYF,IAAZ,CAAd;;AAEA,MAAIC,KAAK,CAACG,MAAN,KAAiBD,KAAK,CAACC,MAA3B,EAAmC;AACjC,WAAO,KAAP;AACD,GAf8C,CAiB/C;;;AACA,OAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGJ,KAAK,CAACG,MAA1B,EAAkCC,CAAC,EAAnC,EAAuC;AACrC,QACE,CAACb,cAAc,CAACc,IAAf,CAAoBN,IAApB,EAA0BC,KAAK,CAACI,CAAD,CAA/B,CAAD,IACA,CAACV,EAAE,CAACI,IAAI,CAACE,KAAK,CAACI,CAAD,CAAN,CAAL,EAAiBL,IAAI,CAACC,KAAK,CAACI,CAAD,CAAN,CAArB,CAFL,EAGE;AACA,aAAO,KAAP;AACD;AACF;;AAED,SAAO,IAAP;AACD","sourcesContent":["// https://github.com/lodash/lodash/issues/2340\r\n// https://github.com/facebook/fbjs/blob/master/packages/fbjs/src/core/shallowEqual.js\r\n\r\n/**\r\n * Copyright (c) 2013-present, Facebook, Inc.\r\n *\r\n * This source code is licensed under the MIT license found in the\r\n * LICENSE file in the root directory of this source tree.\r\n *\r\n * @providesModule shallowEqual\r\n * @typechecks\r\n * @flow\r\n */\r\n\r\n/*eslint-disable no-self-compare */\r\n\r\n'use strict';\r\n\r\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\r\n\r\n/**\r\n * inlined Object.is polyfill to avoid requiring consumers ship their own\r\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\r\n */\r\nfunction is(x, y) {\r\n  // SameValue algorithm\r\n  if (x === y) { // Steps 1-5, 7-10\r\n    // Steps 6.b-6.e: +0 != -0\r\n    // Added the nonzero y check to make Flow happy, but it is redundant\r\n    return x !== 0 || y !== 0 || 1 / x === 1 / y;\r\n  } else {\r\n    // Step 6.a: NaN == NaN\r\n    return x !== x && y !== y;\r\n  }\r\n}\r\n\r\n/**\r\n * Performs equality by iterating through keys on an object and returning false\r\n * when any key has values which are not strictly equal between the arguments.\r\n * Returns true when the values of all keys are strictly equal.\r\n */\r\nexport default function shallowEqual(objA, objB) {\r\n  if (is(objA, objB)) {\r\n    return true;\r\n  }\r\n\r\n  if (typeof objA !== 'object' || objA === null ||\r\n      typeof objB !== 'object' || objB === null) {\r\n    return false;\r\n  }\r\n\r\n  const keysA = Object.keys(objA);\r\n  const keysB = Object.keys(objB);\r\n\r\n  if (keysA.length !== keysB.length) {\r\n    return false;\r\n  }\r\n\r\n  // Test for A's keys different from B.\r\n  for (let i = 0; i < keysA.length; i++) {\r\n    if (\r\n      !hasOwnProperty.call(objB, keysA[i]) ||\r\n      !is(objA[keysA[i]], objB[keysA[i]])\r\n    ) {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  return true;\r\n}"],"file":"shallowEqual.js"}

package/commonjs/utility/throttle.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../source/utility/throttle.js"],"names":["throttle","func","interval","timeout","executedAt","scheduled","undefined","Date","now","remaining"],"mappings":";;;;;;;AAIA;;AAJA;AACA;AACA;AACA;;AAGA;;;;;;AAMe,SAASA,QAAT,CAAkBC,IAAlB,EAAwBC,QAAxB,EAAkC;AAChD,MAAIC,OAAJ;AACA,MAAIC,UAAU,GAAG,CAAjB;;AACA,MAAIC,SAAS,GAAG,SAAZA,SAAY,GAAW;AAC1BF,IAAAA,OAAO,GAAGG,SAAV;AACAF,IAAAA,UAAU,GAAGG,IAAI,CAACC,GAAL,EAAb;AACAP,IAAAA,IAAI;AACJ,GAJD;;AAKA,SAAO,YAAW;AACjB,QAAMO,GAAG,GAAGD,IAAI,CAACC,GAAL,EAAZ;AACA,QAAMC,SAAS,GAAGP,QAAQ,IAAIM,GAAG,GAAGJ,UAAV,CAA1B;;AACA,QAAIK,SAAS,IAAI,CAAjB,EAAoB;AACnB,UAAIN,OAAJ,EAAa;AACZ,wDAAaA,OAAb;AACAA,QAAAA,OAAO,GAAGG,SAAV;AACA;;AACDF,MAAAA,UAAU,GAAGI,GAAb;AACAP,MAAAA,IAAI;AACJ,KAPD,MAOO,IAAI,CAACE,OAAL,EAAc;AACpBA,MAAAA,OAAO,GAAG,8CAAWE,SAAX,EAAsBI,SAAtB,CAAV;AACA;AACD,GAbD;AAcA","sourcesContent":["// For some weird reason, in Chrome, `setTimeout()` would lag up to a second (or more) behind.\r\n// Turns out, Chrome developers have deprecated `setTimeout()` API entirely without asking anyone.\r\n// Replacing `setTimeout()` with `requestAnimationFrame()` can work around that Chrome bug.\r\n// https://github.com/bvaughn/react-virtualized/issues/722\r\nimport { setTimeout, clearTimeout } from 'request-animation-frame-timeout'\r\n\r\n/**\r\n * Same as `lodash`'s `throttle()` for functions with no arguments.\r\n * @param  {function} func\r\n * @param  {number} interval\r\n * @return {function}\r\n */\r\nexport default function throttle(func, interval) {\r\n\tlet timeout\r\n\tlet executedAt = 0\r\n\tlet scheduled = function() {\r\n\t\ttimeout = undefined\r\n\t\texecutedAt = Date.now()\r\n\t\tfunc()\r\n\t}\r\n\treturn function() {\r\n\t\tconst now = Date.now()\r\n\t\tconst remaining = interval - (now - executedAt)\r\n\t\tif (remaining <= 0) {\r\n\t\t\tif (timeout) {\r\n\t\t\t\tclearTimeout(timeout)\r\n\t\t\t\ttimeout = undefined\r\n\t\t\t}\r\n\t\t\texecutedAt = now\r\n\t\t\tfunc()\r\n\t\t} else if (!timeout) {\r\n\t\t\ttimeout = setTimeout(scheduled, remaining)\r\n\t\t}\r\n\t}\r\n}"],"file":"throttle.js"}
+{"version":3,"sources":["../../source/utility/throttle.js"],"names":["throttle","func","interval","timeout","executedAt","scheduled","undefined","Date","now","remaining"],"mappings":";;;;;;;AAIA;;AAJA;AACA;AACA;AACA;;AAGA;AACA;AACA;AACA;AACA;AACA;AACe,SAASA,QAAT,CAAkBC,IAAlB,EAAwBC,QAAxB,EAAkC;AAChD,MAAIC,OAAJ;AACA,MAAIC,UAAU,GAAG,CAAjB;;AACA,MAAIC,SAAS,GAAG,SAAZA,SAAY,GAAW;AAC1BF,IAAAA,OAAO,GAAGG,SAAV;AACAF,IAAAA,UAAU,GAAGG,IAAI,CAACC,GAAL,EAAb;AACAP,IAAAA,IAAI;AACJ,GAJD;;AAKA,SAAO,YAAW;AACjB,QAAMO,GAAG,GAAGD,IAAI,CAACC,GAAL,EAAZ;AACA,QAAMC,SAAS,GAAGP,QAAQ,IAAIM,GAAG,GAAGJ,UAAV,CAA1B;;AACA,QAAIK,SAAS,IAAI,CAAjB,EAAoB;AACnB,UAAIN,OAAJ,EAAa;AACZ,wDAAaA,OAAb;AACAA,QAAAA,OAAO,GAAGG,SAAV;AACA;;AACDF,MAAAA,UAAU,GAAGI,GAAb;AACAP,MAAAA,IAAI;AACJ,KAPD,MAOO,IAAI,CAACE,OAAL,EAAc;AACpBA,MAAAA,OAAO,GAAG,8CAAWE,SAAX,EAAsBI,SAAtB,CAAV;AACA;AACD,GAbD;AAcA","sourcesContent":["// For some weird reason, in Chrome, `setTimeout()` would lag up to a second (or more) behind.\r\n// Turns out, Chrome developers have deprecated `setTimeout()` API entirely without asking anyone.\r\n// Replacing `setTimeout()` with `requestAnimationFrame()` can work around that Chrome bug.\r\n// https://github.com/bvaughn/react-virtualized/issues/722\r\nimport { setTimeout, clearTimeout } from 'request-animation-frame-timeout'\r\n\r\n/**\r\n * Same as `lodash`'s `throttle()` for functions with no arguments.\r\n * @param  {function} func\r\n * @param  {number} interval\r\n * @return {function}\r\n */\r\nexport default function throttle(func, interval) {\r\n\tlet timeout\r\n\tlet executedAt = 0\r\n\tlet scheduled = function() {\r\n\t\ttimeout = undefined\r\n\t\texecutedAt = Date.now()\r\n\t\tfunc()\r\n\t}\r\n\treturn function() {\r\n\t\tconst now = Date.now()\r\n\t\tconst remaining = interval - (now - executedAt)\r\n\t\tif (remaining <= 0) {\r\n\t\t\tif (timeout) {\r\n\t\t\t\tclearTimeout(timeout)\r\n\t\t\t\ttimeout = undefined\r\n\t\t\t}\r\n\t\t\texecutedAt = now\r\n\t\t\tfunc()\r\n\t\t} else if (!timeout) {\r\n\t\t\ttimeout = setTimeout(scheduled, remaining)\r\n\t\t}\r\n\t}\r\n}"],"file":"throttle.js"}

package/dom/index.d.ts

@@ -0,0 +1,23 @@
+import { State, VirtualScrollerCommonOptions, VirtualScrollerSetItemsOptions } from '../index.d.ts';
+
+export { State, ItemState } from '../index.d.ts';
+
+import * as React from 'react';
+
+interface Options<Item> extends VirtualScrollerCommonOptions<HTMLElement, Item> {
+	onMount?: () => void;
+	onItemUnmount?: () => void;
+}
+
+export default class VirtualScroller<Item> {
+	constructor(
+		itemsContainerElement: HTMLElement,
+		items: Item[],
+		renderItem: (item: Item) => HTMLElement,
+		options?: Options<Item>
+	);
+
+	stop(): void;
+	setItems(newItems: Item[], options?: VirtualScrollerSetItemsOptions): void;
+  onItemHeightChange(i: number): void;
+}

package/index.d.ts

@@ -0,0 +1,84 @@
+export type ItemHeight = number | undefined;
+export type ItemState = any | undefined;
+
+export interface State<Item> {
+	items: Item[];
+	firstShownItemIndex: number;
+	lastShownItemIndex: number;
+	beforeItemsHeight: number;
+	afterItemsHeight: number;
+	itemStates: ItemState[];
+	itemHeights: ItemHeight[];
+	verticalSpacing?: number;
+	columnsCount?: number;
+}
+
+export interface ItemsContainer<Element> {
+	constructor(getElement: () => Element);
+	getNthRenderedItemTopOffset(renderedElementIndex: number): number;
+	getNthRenderedItemHeight(renderedElementIndex: number): number;
+	getHeight(): number;
+	clear(): void;
+}
+
+export interface ScrollableContainer<Element> {
+	constructor(element: Element, getItemsContainerElement: () => Element);
+	getWidth(): number;
+	getHeight(): number;
+	getItemsContainerTopOffset(): number;
+	getScrollY(): number;
+	scrollToY(scrollY: number): void;
+	onScroll(onScroll: () => void): () => void;
+	onResize(onResize: () => void): () => void;
+}
+
+export interface Engine<Element> {
+	createItemsContainer(getItemsContainerElement: () => Element): ItemsContainer<Element>;
+	createScrollableContainer(scrollableContainer: Element, getItemsContainerElement: () => Element): ScrollableContainer<Element>;
+}
+
+export interface VirtualScrollerCommonOptionsWithoutInitialState<Element, Item> {
+	bypass?: boolean;
+	onStateChange?(newState: State<Item>, prevState?: State<Item>);
+	measureItemsBatchSize?: number;
+	estimatedItemHeight?: number;
+	initialScrollPosition?: number;
+	onScrollPositionChange?(scrollY: number): void;
+	onItemInitialRender?(item: Item): void;
+	getItemId?(item: Item): any;
+	getColumnsCount?(scrollableContainer: Element): number;
+}
+
+export interface VirtualScrollerCommonOptions<Element, Item> extends VirtualScrollerCommonOptionsWithoutInitialState<Element, Item> {
+	state?: State<Item>;
+	customState?: object;
+}
+
+interface Options<Element, Item> extends VirtualScrollerCommonOptions<Element, Item> {
+	getState?(): State<Item>;
+	setState?(stateUpdate: Partial<State<Item>>): void;
+	engine?: Engine<Element>;
+	tbody?: boolean;
+}
+
+export interface VirtualScrollerSetItemsOptions {
+	preserveScrollPositionOnPrependItems?: boolean;
+}
+
+export default class VirtualScroller<Element, Item> {
+	constructor(
+		getItemsContainerElement: () => Element,
+		items: Item[],
+		options?: Options<Element, Item>
+	);
+
+	listen(): void;
+	stop(): void;
+	willUpdateState(newState: State<Item>, prevState: State<Item>): void;
+	didUpdateState(prevState: State<Item>): void;
+	updateLayout(): void;
+	setItems(newItems: Item[], options?: VirtualScrollerSetItemsOptions): void;
+  onItemHeightChange(i: number): void;
+  onItemStateChange(i: number, itemState?: object): void;
+  getItemScrollPosition(i: number): number | undefined;
+}

package/modules/BeforeResize.js

@@ -0,0 +1,310 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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 _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, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+import log from './utility/debug';
+
+var BeforeResize = /*#__PURE__*/function () {
+  function BeforeResize(_ref) {
+    var getState = _ref.getState,
+        getVerticalSpacing = _ref.getVerticalSpacing,
+        getColumnsCount = _ref.getColumnsCount;
+
+    _classCallCheck(this, BeforeResize);
+
+    this.getState = getState;
+    this.getVerticalSpacing = getVerticalSpacing;
+    this.getColumnsCount = getColumnsCount;
+  } // Possibly clean up "before resize" property in state.
+  // "Before resize" state property is cleaned up when all "before resize" item heights
+  // have been re-measured in an asynchronous `this.setState({ beforeResize: undefined })` call.
+  // If `VirtualScroller` state was snapshotted externally before that `this.setState()` call
+  // has been applied, then "before resize" property might have not been cleaned up properly.
+
+
+  _createClass(BeforeResize, [{
+    key: "onInitialState",
+    value: function onInitialState(state) {
+      if (state) {
+        if (state.beforeResize) {
+          if (state.beforeResize.itemHeights.length === 0) {
+            state.beforeResize = undefined;
+          }
+        }
+
+        if (state.beforeResize) {
+          this._includesBeforeResizeInState = true;
+        }
+      }
+    } // Cleans up "before resize" item heights and adjusts the scroll position accordingly.
+    //
+    // Hypothetically, it could also wait for the user to stop scrolling and only then
+    // adjust the scroll position. The rationale is that if `window.scrollTo()` is called
+    // while the user is scrolling, the user would occasionally experience "lost" mouse wheel
+    // events when scrolling with a mouse wheel.
+    //
+    // Seems like Twitter's website waits for the user to stop scrolling before applying
+    // the scroll position correction after a window resize. This library could do that too,
+    // but that would require rewriting "before items height" top padding calculation
+    // so that it doesn't re-calculate it on every re-render and instead does so incrementally,
+    // and then, when the user stops, it re-calculates it from scratch removing the error
+    // and adjusting the scroll position accordingly so that there's no "jump of content".
+    //
+    // But, seems like it works fine as it is and there's no need to rewrite anything.
+    //
+
+  }, {
+    key: "cleanUpBeforeResizeItemHeights",
+    value: function cleanUpBeforeResizeItemHeights(prevState) {
+      var _this$getState = this.getState(),
+          firstShownItemIndex = _this$getState.firstShownItemIndex,
+          lastShownItemIndex = _this$getState.lastShownItemIndex,
+          itemHeights = _this$getState.itemHeights,
+          beforeResize = _this$getState.beforeResize; // If there're "before resize" properties in `state`
+      // then it means that the corresponding items are waiting to be
+      // re-measured after container resize. Since the resize,
+      // some of those non-re-measured items might have just been measured,
+      // so see if that's true, and if it is, remove those now-obsolete
+      // "before resize" item heights and ajust the scroll position
+      // so that there's no "content jumping".
+
+
+      if (beforeResize) {
+        // If the user has scrolled up to reveal a previously hidden item
+        // that has not yet been re-measured after a previous resize.
+        if (firstShownItemIndex < beforeResize.itemHeights.length) {
+          log('~ Clean up "before resize" item heights and correct scroll position ~'); // Some of the "before" items have been un-hidden and re-measured.
+          // Un-hiding those items would result in a "jump of content"
+          // because "before resize" heights of those un-hidden items
+          // could (and most likely will) be different from the current ones,
+          // or because "before resize" columns count is different from
+          // the current one.
+          // To prevent a "jump of content", calculate the scroll position
+          // difference and adjust the scroll position.
+          // The height of the item rows that have transitioned
+          // from hidden to shown.
+
+          var newlyShownItemRowsHeight = 0; // Some of the `itemHeights` between the current `firstShownItemIndex` and
+          // the previous `firstShownItemIndex` could stay `undefined` if the user
+          // scrolled "abruptly": for example, by using a `window.scrollTo()` call.
+          // In that case, the items below the visible ones won't be rendered and measured.
+          // In such case, limit the items being iterated over to the current `lastShownItemIndex`
+          // rather than the previous `firstShownItemIndex`.
+
+          var prevFirstReMeasuredItemsRowIndex = Math.floor(beforeResize.itemHeights.length / this.getColumnsCount());
+          var newlyShownItemsToIndex = Math.min(prevFirstReMeasuredItemsRowIndex * this.getColumnsCount() - 1, lastShownItemIndex);
+          var i = firstShownItemIndex;
+
+          while (i <= newlyShownItemsToIndex) {
+            // Calculate newly shown row height.
+            var rowHeight = 0;
+            var columnIndex = 0;
+
+            while (columnIndex < this.getColumnsCount() && i <= newlyShownItemsToIndex) {
+              var itemHeight = itemHeights[i];
+
+              if (itemHeight === undefined) {
+                // `itemHeight` can only be `undefined` when not `beforeResize`.
+                // Use the current "average item height" as a substitute.
+                itemHeight = this.getAverageItemHeight();
+              }
+
+              rowHeight = Math.max(rowHeight, itemHeight);
+              i++;
+              columnIndex++;
+            } // Append to the total "newly shown item rows height".
+
+
+            newlyShownItemRowsHeight += rowHeight;
+            newlyShownItemRowsHeight += this.getVerticalSpacing();
+          } // The height of the "before resize" item rows
+          // that will be "cleaned up" in this function call.
+
+
+          var cleanedUpBeforeResizeItemRowsHeight = 0; // Some of the `beforeResize` item rows might have been skipped if the user
+          // scrolled up "abruptly": for example, by using a `window.scrollTo()` call.
+          // In that case, the "before resize" items below the bottom border of the screen
+          // shouldn't be accounted for when calculating the scrollbar adjustment shift
+          // because items after `lastShownItemIndex` aren't participating in the calculation
+          // of `newlyShownItemRowsHeight`.
+
+          var maxParticipatingBeforeResizeItemsCount = Math.min(beforeResize.itemHeights.length, lastShownItemIndex + 1);
+          var participatingBeforeResizeItemRowsCount = Math.ceil(maxParticipatingBeforeResizeItemsCount / beforeResize.columnsCount);
+          var firstCleanedUpBeforeResizeItemsRowIndex = firstShownItemIndex === 0 ? 0 : Math.floor((firstShownItemIndex - 1) / beforeResize.columnsCount) + 1;
+          var k = firstCleanedUpBeforeResizeItemsRowIndex;
+
+          while (k < participatingBeforeResizeItemRowsCount) {
+            var _rowHeight = beforeResize.itemHeights[k * beforeResize.columnsCount];
+            cleanedUpBeforeResizeItemRowsHeight += _rowHeight;
+            cleanedUpBeforeResizeItemRowsHeight += beforeResize.verticalSpacing;
+            k++;
+          } // Schedule an asynchronous `this.setState()` call that will update
+          // `beforeResize` property of `state`. Ideally, it should be updated
+          // immediately, but since `this.setState()` calls are asynchronous,
+          // the code updates just the underlying `beforeResize.itemHeights`
+          // array immediately instead, which is still a hack but still a lesser one.
+
+
+          if (firstShownItemIndex === 0) {
+            log('Drop all "before resize" item heights');
+          } else {
+            var firstDroppedBeforeResizeItemIndex = firstShownItemIndex;
+            var lastDroppedBeforeResizeItemIndex = beforeResize.itemHeights.length - 1;
+
+            if (firstDroppedBeforeResizeItemIndex === lastDroppedBeforeResizeItemIndex) {
+              log('For item index', firstDroppedBeforeResizeItemIndex, '— drop "before resize" height', beforeResize.itemHeights[firstDroppedBeforeResizeItemIndex]);
+            } else {
+              log('For item indexes from', firstDroppedBeforeResizeItemIndex, 'to', lastDroppedBeforeResizeItemIndex, '— drop "before resize" heights', beforeResize.itemHeights.slice(firstDroppedBeforeResizeItemIndex));
+            }
+          } // Immediately update `beforeResize.itemHeights`
+          // so that the component isn't left in an inconsistent state
+          // before a `this.setState()` call below is applied.
+
+
+          beforeResize.itemHeights.splice(firstShownItemIndex, beforeResize.itemHeights.length - firstShownItemIndex); // Return the "scroll by" amount that would correct the scroll position.
+          // Also return a state update.
+
+          return {
+            scrollBy: newlyShownItemRowsHeight - cleanedUpBeforeResizeItemRowsHeight,
+            beforeResize: firstShownItemIndex === 0 ? undefined : _objectSpread({}, beforeResize)
+          };
+        }
+      }
+    } // Snapshots "before resize" values in order to preserve the currently
+    // shown items' vertical position on screen so that there's no "content jumping".
+    //
+    // `newFirstShownItemIndex` is `> 0`.
+    //
+
+  }, {
+    key: "snapshotBeforeResizeItemHeights",
+    value: function snapshotBeforeResizeItemHeights(_ref2) {
+      var firstShownItemIndex = _ref2.firstShownItemIndex,
+          newFirstShownItemIndex = _ref2.newFirstShownItemIndex,
+          newColumnsCount = _ref2.newColumnsCount;
+      var columnsCount = this.getColumnsCount();
+      var verticalSpacing = this.getVerticalSpacing();
+      this._includesBeforeResizeInState = true;
+
+      var _this$getState2 = this.getState(),
+          prevBeforeResize = _this$getState2.beforeResize,
+          itemHeights = _this$getState2.itemHeights;
+
+      var prevBeforeResizeItemsCount = prevBeforeResize ? prevBeforeResize.itemHeights.length : 0; // If there already are "before resize" values in `state`
+      // then it means that those should be merged with the new ones.
+      //
+      // `beforeResize.itemHeights` could be empty in an edge case
+      // when there's a pending state update that sets `beforeResize`
+      // to `undefined`, and in that case empty `beforeResize.itemHeights`
+      // signals about that type of a situation.
+      //
+
+      if (prevBeforeResizeItemsCount > 0) {
+        // Because the "previous" before resize values might have been captured
+        // for a window width corresponding to a layout with a different columns count
+        // and different vertical spacing, re-calculate those item heights as if
+        // they corresponded to the current columns count and current vertical spacing,
+        // since "previous" and "new" before resize item heights are gonna be merged.
+        if (prevBeforeResize.columnsCount !== columnsCount || prevBeforeResize.verticalSpacing !== verticalSpacing) {
+          var prevBeforeResizeBeforeItemsHeight = 0;
+          var prevBeforeResizeItemRowsCount = Math.ceil(prevBeforeResizeItemsCount / prevBeforeResize.columnsCount);
+          var rowIndex = 0;
+
+          while (rowIndex < prevBeforeResizeItemRowsCount) {
+            // Since all "before resize" item heights are equal within a row,
+            // the height of the first "before resize" item in a row is that row's height.
+            var rowHeight = prevBeforeResize.itemHeights[rowIndex * prevBeforeResize.columnsCount];
+            prevBeforeResizeBeforeItemsHeight += rowHeight;
+            prevBeforeResizeBeforeItemsHeight += prevBeforeResize.verticalSpacing;
+            rowIndex++;
+          }
+
+          var newBeforeResizeAdditionalBeforeItemsHeight = 0;
+          var i = firstShownItemIndex;
+
+          while (i < newFirstShownItemIndex) {
+            var _rowHeight2 = 0;
+            var k = 0;
+
+            while (k < columnsCount && i < newFirstShownItemIndex) {
+              _rowHeight2 = Math.max(_rowHeight2, itemHeights[i]);
+              k++;
+              i++;
+            }
+
+            newBeforeResizeAdditionalBeforeItemsHeight += _rowHeight2;
+            newBeforeResizeAdditionalBeforeItemsHeight += verticalSpacing;
+          }
+
+          var newBeforeResizeBeforeItemsHeight = prevBeforeResizeBeforeItemsHeight + newBeforeResizeAdditionalBeforeItemsHeight;
+          var newBeforeResizeBeforeItemRowsCount = Math.ceil(newFirstShownItemIndex / columnsCount);
+          return new Array(newFirstShownItemIndex).fill( // Re-calculate "before resize" item heights so that "previous" and "new" ones
+          // correspond to the same (new) columns count.
+          // Also don't occasionally set item heights to `< 0`.
+          Math.max(0, newBeforeResizeBeforeItemsHeight / newBeforeResizeBeforeItemRowsCount - verticalSpacing));
+        } else {
+          // Add new item heights to the previously snapshotted ones.
+          return prevBeforeResize.itemHeights.concat(equalizeItemHeights(itemHeights, newFirstShownItemIndex, columnsCount).slice(prevBeforeResize.itemHeights.length));
+        }
+      } else {
+        return equalizeItemHeights(itemHeights, newFirstShownItemIndex, columnsCount);
+      }
+    }
+  }, {
+    key: "shouldIncludeBeforeResizeValuesInState",
+    value: function shouldIncludeBeforeResizeValuesInState() {
+      return this._includesBeforeResizeInState;
+    }
+  }]);
+
+  return BeforeResize;
+}(); // Equalizes all item heights within a given row, for each row.
+//
+// The reason is that `beforeResize.itemHeights` is not necessarily divisible by
+// `beforeResize.columnsCount`, which would result in varying last row height
+// as items get removed from `beforeResize.itemHeights` as the user scrolls up.
+//
+// By equalizing all item heights within a given row, for each row, such "jumping"
+// last "before resize" row height is prevented when the user scrolls up.
+//
+
+
+export { BeforeResize as default };
+
+function equalizeItemHeights(itemHeights, maxItemsCount, columnsCount) {
+  itemHeights = itemHeights.slice(0, Math.ceil(maxItemsCount / columnsCount) * columnsCount);
+  var rowIndex = 0;
+
+  while (rowIndex * columnsCount < maxItemsCount) {
+    // Calculate row height.
+    var rowHeight = 0;
+    var k = 0;
+
+    while (k < columnsCount) {
+      rowHeight = Math.max(rowHeight, itemHeights[rowIndex * columnsCount + k]);
+      k++;
+    } // Equalize all item heights within the row.
+
+
+    k = 0;
+
+    while (k < columnsCount) {
+      itemHeights[rowIndex * columnsCount + k] = rowHeight;
+      k++;
+    } // Proceed with the next row.
+
+
+    rowIndex++;
+  }
+
+  return itemHeights.slice(0, maxItemsCount);
+}
+//# sourceMappingURL=BeforeResize.js.map

package/modules/BeforeResize.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../source/BeforeResize.js"],"names":["log","BeforeResize","getState","getVerticalSpacing","getColumnsCount","state","beforeResize","itemHeights","length","undefined","_includesBeforeResizeInState","prevState","firstShownItemIndex","lastShownItemIndex","newlyShownItemRowsHeight","prevFirstReMeasuredItemsRowIndex","Math","floor","newlyShownItemsToIndex","min","i","rowHeight","columnIndex","itemHeight","getAverageItemHeight","max","cleanedUpBeforeResizeItemRowsHeight","maxParticipatingBeforeResizeItemsCount","participatingBeforeResizeItemRowsCount","ceil","columnsCount","firstCleanedUpBeforeResizeItemsRowIndex","k","verticalSpacing","firstDroppedBeforeResizeItemIndex","lastDroppedBeforeResizeItemIndex","slice","splice","scrollBy","newFirstShownItemIndex","newColumnsCount","prevBeforeResize","prevBeforeResizeItemsCount","prevBeforeResizeBeforeItemsHeight","prevBeforeResizeItemRowsCount","rowIndex","newBeforeResizeAdditionalBeforeItemsHeight","newBeforeResizeBeforeItemsHeight","newBeforeResizeBeforeItemRowsCount","Array","fill","concat","equalizeItemHeights","maxItemsCount"],"mappings":";;;;;;;;;;;;AAAA,OAAOA,GAAP,MAAgB,iBAAhB;;IAEqBC,Y;AACpB,8BAIG;AAAA,QAHFC,QAGE,QAHFA,QAGE;AAAA,QAFFC,kBAEE,QAFFA,kBAEE;AAAA,QADFC,eACE,QADFA,eACE;;AAAA;;AACF,SAAKF,QAAL,GAAgBA,QAAhB;AACA,SAAKC,kBAAL,GAA0BA,kBAA1B;AACA,SAAKC,eAAL,GAAuBA,eAAvB;AACA,G,CAED;AACA;AACA;AACA;AACA;;;;;WACA,wBAAeC,KAAf,EAAsB;AACrB,UAAIA,KAAJ,EAAW;AACV,YAAIA,KAAK,CAACC,YAAV,EAAwB;AACvB,cAAID,KAAK,CAACC,YAAN,CAAmBC,WAAnB,CAA+BC,MAA/B,KAA0C,CAA9C,EAAiD;AAChDH,YAAAA,KAAK,CAACC,YAAN,GAAqBG,SAArB;AACA;AACD;;AACD,YAAIJ,KAAK,CAACC,YAAV,EAAwB;AACvB,eAAKI,4BAAL,GAAoC,IAApC;AACA;AACD;AACD,K,CAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACA,wCAA+BC,SAA/B,EAA0C;AACzC,2BAKI,KAAKT,QAAL,EALJ;AAAA,UACCU,mBADD,kBACCA,mBADD;AAAA,UAECC,kBAFD,kBAECA,kBAFD;AAAA,UAGCN,WAHD,kBAGCA,WAHD;AAAA,UAICD,YAJD,kBAICA,YAJD,CADyC,CAQzC;AACA;AACA;AACA;AACA;AACA;AACA;;;AAEA,UAAIA,YAAJ,EAAkB;AACjB;AACA;AACA,YAAIM,mBAAmB,GAAGN,YAAY,CAACC,WAAb,CAAyBC,MAAnD,EAA2D;AAC1DR,UAAAA,GAAG,CAAC,uEAAD,CAAH,CAD0D,CAG1D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;;AACA,cAAIc,wBAAwB,GAAG,CAA/B,CAd0D,CAgB1D;AACA;AACA;AACA;AACA;AACA;;AACA,cAAMC,gCAAgC,GAAGC,IAAI,CAACC,KAAL,CAAWX,YAAY,CAACC,WAAb,CAAyBC,MAAzB,GAAkC,KAAKJ,eAAL,EAA7C,CAAzC;AACA,cAAMc,sBAAsB,GAAGF,IAAI,CAACG,GAAL,CAC9BJ,gCAAgC,GAAG,KAAKX,eAAL,EAAnC,GAA4D,CAD9B,EAE9BS,kBAF8B,CAA/B;AAKA,cAAIO,CAAC,GAAGR,mBAAR;;AACA,iBAAOQ,CAAC,IAAIF,sBAAZ,EAAoC;AACnC;AACA,gBAAIG,SAAS,GAAG,CAAhB;AACA,gBAAIC,WAAW,GAAG,CAAlB;;AACA,mBAAOA,WAAW,GAAG,KAAKlB,eAAL,EAAd,IAAwCgB,CAAC,IAAIF,sBAApD,EAA4E;AAC3E,kBAAIK,UAAU,GAAGhB,WAAW,CAACa,CAAD,CAA5B;;AACA,kBAAIG,UAAU,KAAKd,SAAnB,EAA8B;AAC7B;AACA;AACAc,gBAAAA,UAAU,GAAG,KAAKC,oBAAL,EAAb;AACA;;AACDH,cAAAA,SAAS,GAAGL,IAAI,CAACS,GAAL,CAASJ,SAAT,EAAoBE,UAApB,CAAZ;AACAH,cAAAA,CAAC;AACDE,cAAAA,WAAW;AACX,aAdkC,CAenC;;;AACAR,YAAAA,wBAAwB,IAAIO,SAA5B;AACAP,YAAAA,wBAAwB,IAAI,KAAKX,kBAAL,EAA5B;AACA,WA/CyD,CAiD1D;AACA;;;AACA,cAAIuB,mCAAmC,GAAG,CAA1C,CAnD0D,CAqD1D;AACA;AACA;AACA;AACA;AACA;;AACA,cAAMC,sCAAsC,GAAGX,IAAI,CAACG,GAAL,CAASb,YAAY,CAACC,WAAb,CAAyBC,MAAlC,EAA0CK,kBAAkB,GAAG,CAA/D,CAA/C;AACA,cAAMe,sCAAsC,GAAGZ,IAAI,CAACa,IAAL,CAAUF,sCAAsC,GAAGrB,YAAY,CAACwB,YAAhE,CAA/C;AAEA,cAAMC,uCAAuC,GAAGnB,mBAAmB,KAAK,CAAxB,GAC7C,CAD6C,GAE7CI,IAAI,CAACC,KAAL,CAAW,CAACL,mBAAmB,GAAG,CAAvB,IAA4BN,YAAY,CAACwB,YAApD,IAAoE,CAFvE;AAIA,cAAIE,CAAC,GAAGD,uCAAR;;AACA,iBAAOC,CAAC,GAAGJ,sCAAX,EAAmD;AAClD,gBAAMP,UAAS,GAAGf,YAAY,CAACC,WAAb,CAAyByB,CAAC,GAAG1B,YAAY,CAACwB,YAA1C,CAAlB;AACAJ,YAAAA,mCAAmC,IAAIL,UAAvC;AACAK,YAAAA,mCAAmC,IAAIpB,YAAY,CAAC2B,eAApD;AACAD,YAAAA,CAAC;AACD,WAxEyD,CA0E1D;AACA;AACA;AACA;AACA;;;AACA,cAAIpB,mBAAmB,KAAK,CAA5B,EAA+B;AAC9BZ,YAAAA,GAAG,CAAC,uCAAD,CAAH;AACA,WAFD,MAEO;AACN,gBAAMkC,iCAAiC,GAAGtB,mBAA1C;AACA,gBAAMuB,gCAAgC,GAAG7B,YAAY,CAACC,WAAb,CAAyBC,MAAzB,GAAkC,CAA3E;;AACA,gBAAI0B,iCAAiC,KAAKC,gCAA1C,EAA4E;AAC3EnC,cAAAA,GAAG,CAAC,gBAAD,EAAmBkC,iCAAnB,EAAsD,+BAAtD,EAAuF5B,YAAY,CAACC,WAAb,CAAyB2B,iCAAzB,CAAvF,CAAH;AACA,aAFD,MAEO;AACNlC,cAAAA,GAAG,CAAC,uBAAD,EAA0BkC,iCAA1B,EAA6D,IAA7D,EAAmEC,gCAAnE,EAAqG,gCAArG,EAAuI7B,YAAY,CAACC,WAAb,CAAyB6B,KAAzB,CAA+BF,iCAA/B,CAAvI,CAAH;AACA;AACD,WAzFyD,CA2F1D;AACA;AACA;;;AACA5B,UAAAA,YAAY,CAACC,WAAb,CAAyB8B,MAAzB,CACCzB,mBADD,EAECN,YAAY,CAACC,WAAb,CAAyBC,MAAzB,GAAkCI,mBAFnC,EA9F0D,CAmG1D;AACA;;AACA,iBAAO;AACN0B,YAAAA,QAAQ,EAAExB,wBAAwB,GAAGY,mCAD/B;AAENpB,YAAAA,YAAY,EAAEM,mBAAmB,KAAK,CAAxB,GAA4BH,SAA5B,qBAIVH,YAJU;AAFR,WAAP;AASA;AACD;AACD,K,CAED;AACA;AACA;AACA;AACA;;;;WACA,gDAIG;AAAA,UAHFM,mBAGE,SAHFA,mBAGE;AAAA,UAFF2B,sBAEE,SAFFA,sBAEE;AAAA,UADFC,eACE,SADFA,eACE;AACF,UAAMV,YAAY,GAAG,KAAK1B,eAAL,EAArB;AACA,UAAM6B,eAAe,GAAG,KAAK9B,kBAAL,EAAxB;AAEA,WAAKO,4BAAL,GAAoC,IAApC;;AAEA,4BAGI,KAAKR,QAAL,EAHJ;AAAA,UACeuC,gBADf,mBACCnC,YADD;AAAA,UAECC,WAFD,mBAECA,WAFD;;AAKA,UAAMmC,0BAA0B,GAAGD,gBAAgB,GAChDA,gBAAgB,CAAClC,WAAjB,CAA6BC,MADmB,GAEhD,CAFH,CAXE,CAeF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,UAAIkC,0BAA0B,GAAG,CAAjC,EAAoC;AACnC;AACA;AACA;AACA;AACA;AACA,YACCD,gBAAgB,CAACX,YAAjB,KAAkCA,YAAlC,IACAW,gBAAgB,CAACR,eAAjB,KAAqCA,eAFtC,EAGE;AACD,cAAIU,iCAAiC,GAAG,CAAxC;AAEA,cAAMC,6BAA6B,GAAG5B,IAAI,CAACa,IAAL,CAAUa,0BAA0B,GAAGD,gBAAgB,CAACX,YAAxD,CAAtC;AACA,cAAIe,QAAQ,GAAG,CAAf;;AACA,iBAAOA,QAAQ,GAAGD,6BAAlB,EAAiD;AAChD;AACA;AACA,gBAAMvB,SAAS,GAAGoB,gBAAgB,CAAClC,WAAjB,CAA6BsC,QAAQ,GAAGJ,gBAAgB,CAACX,YAAzD,CAAlB;AACAa,YAAAA,iCAAiC,IAAItB,SAArC;AACAsB,YAAAA,iCAAiC,IAAIF,gBAAgB,CAACR,eAAtD;AACAY,YAAAA,QAAQ;AACR;;AAED,cAAIC,0CAA0C,GAAG,CAAjD;AACA,cAAI1B,CAAC,GAAGR,mBAAR;;AACA,iBAAOQ,CAAC,GAAGmB,sBAAX,EAAmC;AAClC,gBAAIlB,WAAS,GAAG,CAAhB;AACA,gBAAIW,CAAC,GAAG,CAAR;;AACA,mBAAOA,CAAC,GAAGF,YAAJ,IAAoBV,CAAC,GAAGmB,sBAA/B,EAAuD;AACtDlB,cAAAA,WAAS,GAAGL,IAAI,CAACS,GAAL,CAASJ,WAAT,EAAoBd,WAAW,CAACa,CAAD,CAA/B,CAAZ;AACAY,cAAAA,CAAC;AACDZ,cAAAA,CAAC;AACD;;AACD0B,YAAAA,0CAA0C,IAAIzB,WAA9C;AACAyB,YAAAA,0CAA0C,IAAIb,eAA9C;AACA;;AAED,cAAMc,gCAAgC,GAAGJ,iCAAiC,GAAGG,0CAA7E;AACA,cAAME,kCAAkC,GAAGhC,IAAI,CAACa,IAAL,CAAUU,sBAAsB,GAAGT,YAAnC,CAA3C;AAEA,iBAAO,IAAImB,KAAJ,CAAUV,sBAAV,EAAkCW,IAAlC,EACN;AACA;AACA;AACAlC,UAAAA,IAAI,CAACS,GAAL,CAAS,CAAT,EAAYsB,gCAAgC,GAAGC,kCAAnC,GAAwEf,eAApF,CAJM,CAAP;AAMA,SAxCD,MAwCO;AACN;AACA,iBAAOQ,gBAAgB,CAAClC,WAAjB,CAA6B4C,MAA7B,CACNC,mBAAmB,CAClB7C,WADkB,EAElBgC,sBAFkB,EAGlBT,YAHkB,CAAnB,CAIEM,KAJF,CAIQK,gBAAgB,CAAClC,WAAjB,CAA6BC,MAJrC,CADM,CAAP;AAOA;AACD,OAxDD,MAwDO;AACN,eAAO4C,mBAAmB,CACzB7C,WADyB,EAEzBgC,sBAFyB,EAGzBT,YAHyB,CAA1B;AAKA;AACD;;;WAED,kDAAyC;AACxC,aAAO,KAAKpB,4BAAZ;AACA;;;;KAGF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;SAhSqBT,Y;;AAiSrB,SAASmD,mBAAT,CAA6B7C,WAA7B,EAA0C8C,aAA1C,EAAyDvB,YAAzD,EAAuE;AACtEvB,EAAAA,WAAW,GAAGA,WAAW,CAAC6B,KAAZ,CAAkB,CAAlB,EAAqBpB,IAAI,CAACa,IAAL,CAAUwB,aAAa,GAAGvB,YAA1B,IAA0CA,YAA/D,CAAd;AAEA,MAAIe,QAAQ,GAAG,CAAf;;AACA,SAAOA,QAAQ,GAAGf,YAAX,GAA0BuB,aAAjC,EAAgD;AAC/C;AACA,QAAIhC,SAAS,GAAG,CAAhB;AACA,QAAIW,CAAC,GAAG,CAAR;;AACA,WAAOA,CAAC,GAAGF,YAAX,EAAyB;AACxBT,MAAAA,SAAS,GAAGL,IAAI,CAACS,GAAL,CAASJ,SAAT,EAAoBd,WAAW,CAACsC,QAAQ,GAAGf,YAAX,GAA0BE,CAA3B,CAA/B,CAAZ;AACAA,MAAAA,CAAC;AACD,KAP8C,CAS/C;;;AACAA,IAAAA,CAAC,GAAG,CAAJ;;AACA,WAAOA,CAAC,GAAGF,YAAX,EAAyB;AACxBvB,MAAAA,WAAW,CAACsC,QAAQ,GAAGf,YAAX,GAA0BE,CAA3B,CAAX,GAA2CX,SAA3C;AACAW,MAAAA,CAAC;AACD,KAd8C,CAgB/C;;;AACAa,IAAAA,QAAQ;AACR;;AAED,SAAOtC,WAAW,CAAC6B,KAAZ,CAAkB,CAAlB,EAAqBiB,aAArB,CAAP;AACA","sourcesContent":["import log from './utility/debug'\r\n\r\nexport default class BeforeResize {\r\n\tconstructor({\r\n\t\tgetState,\r\n\t\tgetVerticalSpacing,\r\n\t\tgetColumnsCount\r\n\t}) {\r\n\t\tthis.getState = getState\r\n\t\tthis.getVerticalSpacing = getVerticalSpacing\r\n\t\tthis.getColumnsCount = getColumnsCount\r\n\t}\r\n\r\n\t// Possibly clean up \"before resize\" property in state.\r\n\t// \"Before resize\" state property is cleaned up when all \"before resize\" item heights\r\n\t// have been re-measured in an asynchronous `this.setState({ beforeResize: undefined })` call.\r\n\t// If `VirtualScroller` state was snapshotted externally before that `this.setState()` call\r\n\t// has been applied, then \"before resize\" property might have not been cleaned up properly.\r\n\tonInitialState(state) {\r\n\t\tif (state) {\r\n\t\t\tif (state.beforeResize) {\r\n\t\t\t\tif (state.beforeResize.itemHeights.length === 0) {\r\n\t\t\t\t\tstate.beforeResize = undefined\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tif (state.beforeResize) {\r\n\t\t\t\tthis._includesBeforeResizeInState = true\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\t// Cleans up \"before resize\" item heights and adjusts the scroll position accordingly.\r\n\t//\r\n\t// Hypothetically, it could also wait for the user to stop scrolling and only then\r\n\t// adjust the scroll position. The rationale is that if `window.scrollTo()` is called\r\n\t// while the user is scrolling, the user would occasionally experience \"lost\" mouse wheel\r\n\t// events when scrolling with a mouse wheel.\r\n\t//\r\n\t// Seems like Twitter's website waits for the user to stop scrolling before applying\r\n\t// the scroll position correction after a window resize. This library could do that too,\r\n\t// but that would require rewriting \"before items height\" top padding calculation\r\n\t// so that it doesn't re-calculate it on every re-render and instead does so incrementally,\r\n\t// and then, when the user stops, it re-calculates it from scratch removing the error\r\n\t// and adjusting the scroll position accordingly so that there's no \"jump of content\".\r\n\t//\r\n\t// But, seems like it works fine as it is and there's no need to rewrite anything.\r\n\t//\r\n\tcleanUpBeforeResizeItemHeights(prevState) {\r\n\t\tconst {\r\n\t\t\tfirstShownItemIndex,\r\n\t\t\tlastShownItemIndex,\r\n\t\t\titemHeights,\r\n\t\t\tbeforeResize\r\n\t\t} = this.getState()\r\n\r\n\t\t// If there're \"before resize\" properties in `state`\r\n\t\t// then it means that the corresponding items are waiting to be\r\n\t\t// re-measured after container resize. Since the resize,\r\n\t\t// some of those non-re-measured items might have just been measured,\r\n\t\t// so see if that's true, and if it is, remove those now-obsolete\r\n\t\t// \"before resize\" item heights and ajust the scroll position\r\n\t\t// so that there's no \"content jumping\".\r\n\r\n\t\tif (beforeResize) {\r\n\t\t\t// If the user has scrolled up to reveal a previously hidden item\r\n\t\t\t// that has not yet been re-measured after a previous resize.\r\n\t\t\tif (firstShownItemIndex < beforeResize.itemHeights.length) {\r\n\t\t\t\tlog('~ Clean up \"before resize\" item heights and correct scroll position ~')\r\n\r\n\t\t\t\t// Some of the \"before\" items have been un-hidden and re-measured.\r\n\t\t\t\t// Un-hiding those items would result in a \"jump of content\"\r\n\t\t\t\t// because \"before resize\" heights of those un-hidden items\r\n\t\t\t\t// could (and most likely will) be different from the current ones,\r\n\t\t\t\t// or because \"before resize\" columns count is different from\r\n\t\t\t\t// the current one.\r\n\t\t\t\t// To prevent a \"jump of content\", calculate the scroll position\r\n\t\t\t\t// difference and adjust the scroll position.\r\n\r\n\t\t\t\t// The height of the item rows that have transitioned\r\n\t\t\t\t// from hidden to shown.\r\n\t\t\t\tlet newlyShownItemRowsHeight = 0\r\n\r\n\t\t\t\t// Some of the `itemHeights` between the current `firstShownItemIndex` and\r\n\t\t\t\t// the previous `firstShownItemIndex` could stay `undefined` if the user\r\n\t\t\t\t// scrolled \"abruptly\": for example, by using a `window.scrollTo()` call.\r\n\t\t\t\t// In that case, the items below the visible ones won't be rendered and measured.\r\n\t\t\t\t// In such case, limit the items being iterated over to the current `lastShownItemIndex`\r\n\t\t\t\t// rather than the previous `firstShownItemIndex`.\r\n\t\t\t\tconst prevFirstReMeasuredItemsRowIndex = Math.floor(beforeResize.itemHeights.length / this.getColumnsCount())\r\n\t\t\t\tconst newlyShownItemsToIndex = Math.min(\r\n\t\t\t\t\tprevFirstReMeasuredItemsRowIndex * this.getColumnsCount() - 1,\r\n\t\t\t\t\tlastShownItemIndex\r\n\t\t\t\t)\r\n\r\n\t\t\t\tlet i = firstShownItemIndex\r\n\t\t\t\twhile (i <= newlyShownItemsToIndex) {\r\n\t\t\t\t\t// Calculate newly shown row height.\r\n\t\t\t\t\tlet rowHeight = 0\r\n\t\t\t\t\tlet columnIndex = 0\r\n\t\t\t\t\twhile (columnIndex < this.getColumnsCount() && i <= newlyShownItemsToIndex) {\r\n\t\t\t\t\t\tlet itemHeight = itemHeights[i]\r\n\t\t\t\t\t\tif (itemHeight === undefined) {\r\n\t\t\t\t\t\t\t// `itemHeight` can only be `undefined` when not `beforeResize`.\r\n\t\t\t\t\t\t\t// Use the current \"average item height\" as a substitute.\r\n\t\t\t\t\t\t\titemHeight = this.getAverageItemHeight()\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\trowHeight = Math.max(rowHeight, itemHeight)\r\n\t\t\t\t\t\ti++\r\n\t\t\t\t\t\tcolumnIndex++\r\n\t\t\t\t\t}\r\n\t\t\t\t\t// Append to the total \"newly shown item rows height\".\r\n\t\t\t\t\tnewlyShownItemRowsHeight += rowHeight\r\n\t\t\t\t\tnewlyShownItemRowsHeight += this.getVerticalSpacing()\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// The height of the \"before resize\" item rows\r\n\t\t\t\t// that will be \"cleaned up\" in this function call.\r\n\t\t\t\tlet cleanedUpBeforeResizeItemRowsHeight = 0\r\n\r\n\t\t\t\t// Some of the `beforeResize` item rows might have been skipped if the user\r\n\t\t\t\t// scrolled up \"abruptly\": for example, by using a `window.scrollTo()` call.\r\n\t\t\t\t// In that case, the \"before resize\" items below the bottom border of the screen\r\n\t\t\t\t// shouldn't be accounted for when calculating the scrollbar adjustment shift\r\n\t\t\t\t// because items after `lastShownItemIndex` aren't participating in the calculation\r\n\t\t\t\t// of `newlyShownItemRowsHeight`.\r\n\t\t\t\tconst maxParticipatingBeforeResizeItemsCount = Math.min(beforeResize.itemHeights.length, lastShownItemIndex + 1)\r\n\t\t\t\tconst participatingBeforeResizeItemRowsCount = Math.ceil(maxParticipatingBeforeResizeItemsCount / beforeResize.columnsCount)\r\n\r\n\t\t\t\tconst firstCleanedUpBeforeResizeItemsRowIndex = firstShownItemIndex === 0\r\n\t\t\t\t\t? 0\r\n\t\t\t\t\t: Math.floor((firstShownItemIndex - 1) / beforeResize.columnsCount) + 1\r\n\r\n\t\t\t\tlet k = firstCleanedUpBeforeResizeItemsRowIndex\r\n\t\t\t\twhile (k < participatingBeforeResizeItemRowsCount) {\r\n\t\t\t\t\tconst rowHeight = beforeResize.itemHeights[k * beforeResize.columnsCount]\r\n\t\t\t\t\tcleanedUpBeforeResizeItemRowsHeight += rowHeight\r\n\t\t\t\t\tcleanedUpBeforeResizeItemRowsHeight += beforeResize.verticalSpacing\r\n\t\t\t\t\tk++\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// Schedule an asynchronous `this.setState()` call that will update\r\n\t\t\t\t// `beforeResize` property of `state`. Ideally, it should be updated\r\n\t\t\t\t// immediately, but since `this.setState()` calls are asynchronous,\r\n\t\t\t\t// the code updates just the underlying `beforeResize.itemHeights`\r\n\t\t\t\t// array immediately instead, which is still a hack but still a lesser one.\r\n\t\t\t\tif (firstShownItemIndex === 0) {\r\n\t\t\t\t\tlog('Drop all \"before resize\" item heights')\r\n\t\t\t\t} else {\r\n\t\t\t\t\tconst firstDroppedBeforeResizeItemIndex = firstShownItemIndex\r\n\t\t\t\t\tconst lastDroppedBeforeResizeItemIndex = beforeResize.itemHeights.length - 1\r\n\t\t\t\t\tif (firstDroppedBeforeResizeItemIndex === lastDroppedBeforeResizeItemIndex) {\r\n\t\t\t\t\t\tlog('For item index', firstDroppedBeforeResizeItemIndex, '— drop \"before resize\" height', beforeResize.itemHeights[firstDroppedBeforeResizeItemIndex], )\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tlog('For item indexes from', firstDroppedBeforeResizeItemIndex, 'to', lastDroppedBeforeResizeItemIndex, '— drop \"before resize\" heights', beforeResize.itemHeights.slice(firstDroppedBeforeResizeItemIndex))\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// Immediately update `beforeResize.itemHeights`\r\n\t\t\t\t// so that the component isn't left in an inconsistent state\r\n\t\t\t\t// before a `this.setState()` call below is applied.\r\n\t\t\t\tbeforeResize.itemHeights.splice(\r\n\t\t\t\t\tfirstShownItemIndex,\r\n\t\t\t\t\tbeforeResize.itemHeights.length - firstShownItemIndex\r\n\t\t\t\t)\r\n\r\n\t\t\t\t// Return the \"scroll by\" amount that would correct the scroll position.\r\n\t\t\t\t// Also return a state update.\r\n\t\t\t\treturn {\r\n\t\t\t\t\tscrollBy: newlyShownItemRowsHeight - cleanedUpBeforeResizeItemRowsHeight,\r\n\t\t\t\t\tbeforeResize: firstShownItemIndex === 0 ? undefined : {\r\n\t\t\t\t\t\t// Simply change the \"reference\" to `beforeResize` while leaving\r\n\t\t\t\t\t\t// its contents unchanged. That simply indicates that it has been updated:\r\n\t\t\t\t\t\t// `beforeResize.itemHeights` array length has been changed \"directly\".\r\n\t\t\t\t\t\t...beforeResize\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\t// Snapshots \"before resize\" values in order to preserve the currently\r\n\t// shown items' vertical position on screen so that there's no \"content jumping\".\r\n\t//\r\n\t// `newFirstShownItemIndex` is `> 0`.\r\n\t//\r\n\tsnapshotBeforeResizeItemHeights({\r\n\t\tfirstShownItemIndex,\r\n\t\tnewFirstShownItemIndex,\r\n\t\tnewColumnsCount\r\n\t}) {\r\n\t\tconst columnsCount = this.getColumnsCount()\r\n\t\tconst verticalSpacing = this.getVerticalSpacing()\r\n\r\n\t\tthis._includesBeforeResizeInState = true\r\n\r\n\t\tconst {\r\n\t\t\tbeforeResize: prevBeforeResize,\r\n\t\t\titemHeights\r\n\t\t} = this.getState()\r\n\r\n\t\tconst prevBeforeResizeItemsCount = prevBeforeResize\r\n\t\t\t? prevBeforeResize.itemHeights.length\r\n\t\t\t: 0\r\n\r\n\t\t// If there already are \"before resize\" values in `state`\r\n\t\t// then it means that those should be merged with the new ones.\r\n\t\t//\r\n\t\t// `beforeResize.itemHeights` could be empty in an edge case\r\n\t\t// when there's a pending state update that sets `beforeResize`\r\n\t\t// to `undefined`, and in that case empty `beforeResize.itemHeights`\r\n\t\t// signals about that type of a situation.\r\n\t\t//\r\n\t\tif (prevBeforeResizeItemsCount > 0) {\r\n\t\t\t// Because the \"previous\" before resize values might have been captured\r\n\t\t\t// for a window width corresponding to a layout with a different columns count\r\n\t\t\t// and different vertical spacing, re-calculate those item heights as if\r\n\t\t\t// they corresponded to the current columns count and current vertical spacing,\r\n\t\t\t// since \"previous\" and \"new\" before resize item heights are gonna be merged.\r\n\t\t\tif (\r\n\t\t\t\tprevBeforeResize.columnsCount !== columnsCount ||\r\n\t\t\t\tprevBeforeResize.verticalSpacing !== verticalSpacing\r\n\t\t\t) {\r\n\t\t\t\tlet prevBeforeResizeBeforeItemsHeight = 0\r\n\r\n\t\t\t\tconst prevBeforeResizeItemRowsCount = Math.ceil(prevBeforeResizeItemsCount / prevBeforeResize.columnsCount)\r\n\t\t\t\tlet rowIndex = 0\r\n\t\t\t\twhile (rowIndex < prevBeforeResizeItemRowsCount) {\r\n\t\t\t\t\t// Since all \"before resize\" item heights are equal within a row,\r\n\t\t\t\t\t// the height of the first \"before resize\" item in a row is that row's height.\r\n\t\t\t\t\tconst rowHeight = prevBeforeResize.itemHeights[rowIndex * prevBeforeResize.columnsCount]\r\n\t\t\t\t\tprevBeforeResizeBeforeItemsHeight += rowHeight\r\n\t\t\t\t\tprevBeforeResizeBeforeItemsHeight += prevBeforeResize.verticalSpacing\r\n\t\t\t\t\trowIndex++\r\n\t\t\t\t}\r\n\r\n\t\t\t\tlet newBeforeResizeAdditionalBeforeItemsHeight = 0\r\n\t\t\t\tlet i = firstShownItemIndex\r\n\t\t\t\twhile (i < newFirstShownItemIndex) {\r\n\t\t\t\t\tlet rowHeight = 0\r\n\t\t\t\t\tlet k = 0\r\n\t\t\t\t\twhile (k < columnsCount && i < newFirstShownItemIndex) {\r\n\t\t\t\t\t\trowHeight = Math.max(rowHeight, itemHeights[i])\r\n\t\t\t\t\t\tk++\r\n\t\t\t\t\t\ti++\r\n\t\t\t\t\t}\r\n\t\t\t\t\tnewBeforeResizeAdditionalBeforeItemsHeight += rowHeight\r\n\t\t\t\t\tnewBeforeResizeAdditionalBeforeItemsHeight += verticalSpacing\r\n\t\t\t\t}\r\n\r\n\t\t\t\tconst newBeforeResizeBeforeItemsHeight = prevBeforeResizeBeforeItemsHeight + newBeforeResizeAdditionalBeforeItemsHeight\r\n\t\t\t\tconst newBeforeResizeBeforeItemRowsCount = Math.ceil(newFirstShownItemIndex / columnsCount)\r\n\r\n\t\t\t\treturn new Array(newFirstShownItemIndex).fill(\r\n\t\t\t\t\t// Re-calculate \"before resize\" item heights so that \"previous\" and \"new\" ones\r\n\t\t\t\t\t// correspond to the same (new) columns count.\r\n\t\t\t\t\t// Also don't occasionally set item heights to `< 0`.\r\n\t\t\t\t\tMath.max(0, newBeforeResizeBeforeItemsHeight / newBeforeResizeBeforeItemRowsCount - verticalSpacing)\r\n\t\t\t\t)\r\n\t\t\t} else {\r\n\t\t\t\t// Add new item heights to the previously snapshotted ones.\r\n\t\t\t\treturn prevBeforeResize.itemHeights.concat(\r\n\t\t\t\t\tequalizeItemHeights(\r\n\t\t\t\t\t\titemHeights,\r\n\t\t\t\t\t\tnewFirstShownItemIndex,\r\n\t\t\t\t\t\tcolumnsCount\r\n\t\t\t\t\t).slice(prevBeforeResize.itemHeights.length)\r\n\t\t\t\t)\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\treturn equalizeItemHeights(\r\n\t\t\t\titemHeights,\r\n\t\t\t\tnewFirstShownItemIndex,\r\n\t\t\t\tcolumnsCount\r\n\t\t\t)\r\n\t\t}\r\n\t}\r\n\r\n\tshouldIncludeBeforeResizeValuesInState() {\r\n\t\treturn this._includesBeforeResizeInState\r\n\t}\r\n}\r\n\r\n// Equalizes all item heights within a given row, for each row.\r\n//\r\n// The reason is that `beforeResize.itemHeights` is not necessarily divisible by\r\n// `beforeResize.columnsCount`, which would result in varying last row height\r\n// as items get removed from `beforeResize.itemHeights` as the user scrolls up.\r\n//\r\n// By equalizing all item heights within a given row, for each row, such \"jumping\"\r\n// last \"before resize\" row height is prevented when the user scrolls up.\r\n//\r\nfunction equalizeItemHeights(itemHeights, maxItemsCount, columnsCount) {\r\n\titemHeights = itemHeights.slice(0, Math.ceil(maxItemsCount / columnsCount) * columnsCount)\r\n\r\n\tlet rowIndex = 0\r\n\twhile (rowIndex * columnsCount < maxItemsCount) {\r\n\t\t// Calculate row height.\r\n\t\tlet rowHeight = 0\r\n\t\tlet k = 0\r\n\t\twhile (k < columnsCount) {\r\n\t\t\trowHeight = Math.max(rowHeight, itemHeights[rowIndex * columnsCount + k])\r\n\t\t\tk++\r\n\t\t}\r\n\r\n\t\t// Equalize all item heights within the row.\r\n\t\tk = 0\r\n\t\twhile (k < columnsCount) {\r\n\t\t\titemHeights[rowIndex * columnsCount + k] = rowHeight\r\n\t\t\tk++\r\n\t\t}\r\n\r\n\t\t// Proceed with the next row.\r\n\t\trowIndex++\r\n\t}\r\n\r\n\treturn itemHeights.slice(0, maxItemsCount)\r\n}"],"file":"BeforeResize.js"}

package/modules/DOM/Engine.js

@@ -0,0 +1,27 @@
+import ItemsContainer from './ItemsContainer';
+import ScrollableContainer, { ScrollableWindowContainer } from './ScrollableContainer';
+import ListTopOffsetWatcher from './ListTopOffsetWatcher';
+export default {
+  createItemsContainer: function createItemsContainer(getItemsContainerElement) {
+    return new ItemsContainer(getItemsContainerElement);
+  },
+  // Creates a `scrollableContainer`.
+  // On client side, `scrollableContainer` is always created.
+  // On server side, `scrollableContainer` is not created (and not used).
+  createScrollableContainer: function createScrollableContainer(scrollableContainer, getItemsContainerElement) {
+    if (scrollableContainer) {
+      return new ScrollableContainer(scrollableContainer, getItemsContainerElement);
+    } else if (typeof window !== 'undefined') {
+      return new ScrollableWindowContainer(getItemsContainerElement);
+    }
+  },
+  watchListTopOffset: function watchListTopOffset(_ref) {
+    var getListTopOffset = _ref.getListTopOffset,
+        onListTopOffsetChange = _ref.onListTopOffsetChange;
+    return new ListTopOffsetWatcher({
+      getListTopOffset: getListTopOffset,
+      onListTopOffsetChange: onListTopOffsetChange
+    });
+  }
+};
+//# sourceMappingURL=Engine.js.map

package/modules/DOM/Engine.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../source/DOM/Engine.js"],"names":["ItemsContainer","ScrollableContainer","ScrollableWindowContainer","ListTopOffsetWatcher","createItemsContainer","getItemsContainerElement","createScrollableContainer","scrollableContainer","window","watchListTopOffset","getListTopOffset","onListTopOffsetChange"],"mappings":"AAAA,OAAOA,cAAP,MAA2B,kBAA3B;AAEA,OAAOC,mBAAP,IACCC,yBADD,QAEO,uBAFP;AAIA,OAAOC,oBAAP,MAAiC,wBAAjC;AAEA,eAAe;AACdC,EAAAA,oBADc,gCACOC,wBADP,EACiC;AAC9C,WAAO,IAAIL,cAAJ,CAAmBK,wBAAnB,CAAP;AACA,GAHa;AAId;AACA;AACA;AACAC,EAAAA,yBAPc,qCAOYC,mBAPZ,EAOiCF,wBAPjC,EAO2D;AACxE,QAAIE,mBAAJ,EAAyB;AACxB,aAAO,IAAIN,mBAAJ,CAAwBM,mBAAxB,EAA6CF,wBAA7C,CAAP;AACA,KAFD,MAEO,IAAI,OAAOG,MAAP,KAAkB,WAAtB,EAAmC;AACzC,aAAO,IAAIN,yBAAJ,CAA8BG,wBAA9B,CAAP;AACA;AACD,GAba;AAcdI,EAAAA,kBAdc,oCAiBX;AAAA,QAFFC,gBAEE,QAFFA,gBAEE;AAAA,QADFC,qBACE,QADFA,qBACE;AACF,WAAO,IAAIR,oBAAJ,CAAyB;AAC/BO,MAAAA,gBAAgB,EAAhBA,gBAD+B;AAE/BC,MAAAA,qBAAqB,EAArBA;AAF+B,KAAzB,CAAP;AAIA;AAtBa,CAAf","sourcesContent":["import ItemsContainer from './ItemsContainer'\r\n\r\nimport ScrollableContainer, {\r\n\tScrollableWindowContainer\r\n} from './ScrollableContainer'\r\n\r\nimport ListTopOffsetWatcher from './ListTopOffsetWatcher'\r\n\r\nexport default {\r\n\tcreateItemsContainer(getItemsContainerElement) {\r\n\t\treturn new ItemsContainer(getItemsContainerElement)\r\n\t},\r\n\t// Creates a `scrollableContainer`.\r\n\t// On client side, `scrollableContainer` is always created.\r\n\t// On server side, `scrollableContainer` is not created (and not used).\r\n\tcreateScrollableContainer(scrollableContainer, getItemsContainerElement) {\r\n\t\tif (scrollableContainer) {\r\n\t\t\treturn new ScrollableContainer(scrollableContainer, getItemsContainerElement)\r\n\t\t} else if (typeof window !== 'undefined') {\r\n\t\t\treturn new ScrollableWindowContainer(getItemsContainerElement)\r\n\t\t}\r\n\t},\r\n\twatchListTopOffset({\r\n\t\tgetListTopOffset,\r\n\t\tonListTopOffsetChange\r\n\t}) {\r\n\t\treturn new ListTopOffsetWatcher({\r\n\t\t\tgetListTopOffset,\r\n\t\t\tonListTopOffsetChange\r\n\t\t})\r\n\t}\r\n}"],"file":"Engine.js"}