virtual-scroller 1.7.6 → 1.8.0

package/modules/utility/px.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../source/utility/px.js"],"names":["px","number","toFixed"],"mappings":"AAAA;;;;;;;AAOA,eAAe,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;AACA,eAAe,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/modules/utility/px.test.js

@@ -0,0 +1,9 @@
+import px from './px';
+describe('utility/px', function () {
+  it('should truncate px values', function () {
+    px(0).should.equal('0px');
+    px(1).should.equal('1px');
+    px(1.2345).should.equal('1.23px');
+  });
+});
+//# sourceMappingURL=px.test.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../source/utility/px.test.js"],"names":["px","describe","it","should","equal"],"mappings":"AAAA,OAAOA,EAAP,MAAe,MAAf;AAEAC,QAAQ,CAAC,YAAD,EAAe,YAAW;AACjCC,EAAAA,EAAE,CAAC,2BAAD,EAA8B,YAAW;AAC1CF,IAAAA,EAAE,CAAC,CAAD,CAAF,CAAMG,MAAN,CAAaC,KAAb,CAAmB,KAAnB;AACAJ,IAAAA,EAAE,CAAC,CAAD,CAAF,CAAMG,MAAN,CAAaC,KAAb,CAAmB,KAAnB;AACAJ,IAAAA,EAAE,CAAC,MAAD,CAAF,CAAWG,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/modules/utility/shallowEqual.js

@@ -15,7 +15,7 @@
 /*eslint-disable no-self-compare */
 'use strict';
 
-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/modules/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;;;;;;;AAKA,eAAe,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;;;AACA,eAAe,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/modules/utility/throttle.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../source/utility/throttle.js"],"names":["setTimeout","clearTimeout","throttle","func","interval","timeout","executedAt","scheduled","undefined","Date","now","remaining"],"mappings":"AAAA;AACA;AACA;AACA;AACA,SAASA,UAAT,EAAqBC,YAArB,QAAyC,iCAAzC;AAEA;;;;;;;AAMA,eAAe,SAASC,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;AACZJ,QAAAA,YAAY,CAACI,OAAD,CAAZ;AACAA,QAAAA,OAAO,GAAGG,SAAV;AACA;;AACDF,MAAAA,UAAU,GAAGI,GAAb;AACAP,MAAAA,IAAI;AACJ,KAPD,MAOO,IAAI,CAACE,OAAL,EAAc;AACpBA,MAAAA,OAAO,GAAGL,UAAU,CAACO,SAAD,EAAYI,SAAZ,CAApB;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":["setTimeout","clearTimeout","throttle","func","interval","timeout","executedAt","scheduled","undefined","Date","now","remaining"],"mappings":"AAAA;AACA;AACA;AACA;AACA,SAASA,UAAT,EAAqBC,YAArB,QAAyC,iCAAzC;AAEA;AACA;AACA;AACA;AACA;AACA;;AACA,eAAe,SAASC,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;AACZJ,QAAAA,YAAY,CAACI,OAAD,CAAZ;AACAA,QAAAA,OAAO,GAAGG,SAAV;AACA;;AACDF,MAAAA,UAAU,GAAGI,GAAb;AACAP,MAAAA,IAAI;AACJ,KAPD,MAOO,IAAI,CAACE,OAAL,EAAc;AACpBA,MAAAA,OAAO,GAAGL,UAAU,CAACO,SAAD,EAAYI,SAAZ,CAApB;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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "virtual-scroller",
-  "version": "1.7.6",
+  "version": "1.8.0",
   "description": "A component for efficiently rendering large lists of variable height items",
   "main": "index.commonjs.js",
   "module": "index.js",
@@ -11,39 +11,41 @@
     "request-animation-frame-timeout": "^1.0.0"
   },
   "devDependencies": {
-    "@babel/cli": "^7.2.3",
-    "@babel/core": "^7.0.0",
-    "@babel/node": "^7.2.2",
-    "@babel/plugin-proposal-class-properties": "^7.0.0",
-    "@babel/plugin-proposal-object-rest-spread": "^7.2.0",
-    "@babel/plugin-transform-destructuring": "^7.1.2",
+    "@babel/cli": "^7.16.0",
+    "@babel/core": "^7.16.0",
+    "@babel/node": "^7.16.0",
+    "@babel/plugin-proposal-class-properties": "^7.16.0",
+    "@babel/plugin-proposal-object-rest-spread": "^7.16.0",
+    "@babel/plugin-transform-destructuring": "^7.16.0",
     "@babel/polyfill": "^7.0.0",
-    "@babel/preset-env": "^7.0.0",
-    "@babel/preset-react": "^7.0.0",
-    "@babel/register": "^7.0.0",
-    "autoprefixer": "^9.5.0",
+    "@babel/preset-env": "^7.16.4",
+    "@babel/preset-react": "^7.16.0",
+    "@babel/register": "^7.16.0",
     "babel-eslint": "^9.0.0",
-    "babel-loader": "^8.0.1",
-    "babel-plugin-istanbul": "^5.1.1",
-    "cross-env": "^5.1.4",
-    "npm-run-all": "^1.4.0",
-    "postcss": "^7.0.14",
-    "postcss-custom-properties": "^8.0.10",
-    "rimraf": "^2.5.0",
-    "rollup": "^1.9.0",
+    "babel-loader": "^8.2.3",
+    "babel-plugin-istanbul": "^6.1.1",
+    "chai": "^4.3.4",
+    "cross-env": "^7.0.3",
+    "mocha": "^9.1.3",
+    "npm-run-all": "^4.1.5",
+    "nyc": "^15.1.0",
+    "regenerator-runtime": "^0.13.9",
+    "rimraf": "^3.0.2",
+    "rollup": "^2.60.1",
     "rollup-plugin-commonjs": "^9.3.4",
     "rollup-plugin-node-resolve": "^4.2.3",
-    "rollup-plugin-terser": "^4.0.4"
+    "rollup-plugin-terser": "^7.0.2"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\"",
+    "test": "mocha --require ./babel.js --colors --bail --reporter spec --require ./test/setup.js \"source/**/*.test.js\" \"test/**/*.test.js\" --recursive",
+    "test-coverage": "cross-env NODE_ENV=test nyc mocha --require ./babel.js --bail --require ./test/setup.js \"source/**/*.test.js\" \"test/**/*.test.js\"",
     "coveralls": "nyc report --reporter=text-lcov | coveralls",
     "build:browser": "rollup --config rollup.config.js",
     "build:clean": "rimraf ./commonjs/**/* ./modules/**/*",
     "build:commonjs": "cross-env babel ./source --out-dir ./commonjs --source-maps --ignore *.test.js",
     "build:es6": "cross-env BABEL_ENV=es6 babel ./source --out-dir ./modules --source-maps --ignore *.test.js",
     "build": "npm-run-all build:clean build:commonjs build:es6 build:browser",
-    "prepublish": "npm-run-all build test"
+    "prepublishOnly": "npm-run-all build test"
   },
   "repository": {
     "type": "git",

package/react/index.d.ts

@@ -0,0 +1,27 @@
+import { State, VirtualScrollerCommonOptionsWithoutInitialState } from '../index.d.ts';
+
+export { State, ItemState } from '../index.d.ts';
+
+import * as React from 'react';
+
+interface Props<Item> extends VirtualScrollerCommonOptionsWithoutInitialState<HTMLElement, Item> {
+	as?: React.ReactType;
+	items: Item[];
+	itemComponent: React.ReactType;
+	itemComponentProps?: object;
+	className?: string;
+	initialCustomState?: object;
+	initialState?: State<Item>;
+	preserveScrollPositionOnPrependItems?: boolean;
+	onMount?: () => void;
+}
+
+type ReactVirtualScroller<Item> = React.ComponentClass<Props<Item>, State<Item>>
+
+// TypeScript doesn't know how to receive `<Item>` "generic":
+// declare const VirtualScroller<Item>: ReactVirtualScroller<Item>;
+//
+// Uses `<any>` instead:
+declare const VirtualScroller: ReactVirtualScroller<any>;
+
+export default VirtualScroller;

package/source/BeforeResize.js

@@ -0,0 +1,317 @@
+import log from './utility/debug'
+
+export default class BeforeResize {
+	constructor({
+		getState,
+		getVerticalSpacing,
+		getColumnsCount
+	}) {
+		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.
+	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.
+	//
+	cleanUpBeforeResizeItemHeights(prevState) {
+		const {
+			firstShownItemIndex,
+			lastShownItemIndex,
+			itemHeights,
+			beforeResize
+		} = this.getState()
+
+		// 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.
+				let 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`.
+				const prevFirstReMeasuredItemsRowIndex = Math.floor(beforeResize.itemHeights.length / this.getColumnsCount())
+				const newlyShownItemsToIndex = Math.min(
+					prevFirstReMeasuredItemsRowIndex * this.getColumnsCount() - 1,
+					lastShownItemIndex
+				)
+
+				let i = firstShownItemIndex
+				while (i <= newlyShownItemsToIndex) {
+					// Calculate newly shown row height.
+					let rowHeight = 0
+					let columnIndex = 0
+					while (columnIndex < this.getColumnsCount() && i <= newlyShownItemsToIndex) {
+						let 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.
+				let 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`.
+				const maxParticipatingBeforeResizeItemsCount = Math.min(beforeResize.itemHeights.length, lastShownItemIndex + 1)
+				const participatingBeforeResizeItemRowsCount = Math.ceil(maxParticipatingBeforeResizeItemsCount / beforeResize.columnsCount)
+
+				const firstCleanedUpBeforeResizeItemsRowIndex = firstShownItemIndex === 0
+					? 0
+					: Math.floor((firstShownItemIndex - 1) / beforeResize.columnsCount) + 1
+
+				let k = firstCleanedUpBeforeResizeItemsRowIndex
+				while (k < participatingBeforeResizeItemRowsCount) {
+					const 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 {
+					const firstDroppedBeforeResizeItemIndex = firstShownItemIndex
+					const 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 : {
+						// Simply change the "reference" to `beforeResize` while leaving
+						// its contents unchanged. That simply indicates that it has been updated:
+						// `beforeResize.itemHeights` array length has been changed "directly".
+						...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`.
+	//
+	snapshotBeforeResizeItemHeights({
+		firstShownItemIndex,
+		newFirstShownItemIndex,
+		newColumnsCount
+	}) {
+		const columnsCount = this.getColumnsCount()
+		const verticalSpacing = this.getVerticalSpacing()
+
+		this._includesBeforeResizeInState = true
+
+		const {
+			beforeResize: prevBeforeResize,
+			itemHeights
+		} = this.getState()
+
+		const 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
+			) {
+				let prevBeforeResizeBeforeItemsHeight = 0
+
+				const prevBeforeResizeItemRowsCount = Math.ceil(prevBeforeResizeItemsCount / prevBeforeResize.columnsCount)
+				let 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.
+					const rowHeight = prevBeforeResize.itemHeights[rowIndex * prevBeforeResize.columnsCount]
+					prevBeforeResizeBeforeItemsHeight += rowHeight
+					prevBeforeResizeBeforeItemsHeight += prevBeforeResize.verticalSpacing
+					rowIndex++
+				}
+
+				let newBeforeResizeAdditionalBeforeItemsHeight = 0
+				let i = firstShownItemIndex
+				while (i < newFirstShownItemIndex) {
+					let rowHeight = 0
+					let k = 0
+					while (k < columnsCount && i < newFirstShownItemIndex) {
+						rowHeight = Math.max(rowHeight, itemHeights[i])
+						k++
+						i++
+					}
+					newBeforeResizeAdditionalBeforeItemsHeight += rowHeight
+					newBeforeResizeAdditionalBeforeItemsHeight += verticalSpacing
+				}
+
+				const newBeforeResizeBeforeItemsHeight = prevBeforeResizeBeforeItemsHeight + newBeforeResizeAdditionalBeforeItemsHeight
+				const 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
+			)
+		}
+	}
+
+	shouldIncludeBeforeResizeValuesInState() {
+		return this._includesBeforeResizeInState
+	}
+}
+
+// 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.
+//
+function equalizeItemHeights(itemHeights, maxItemsCount, columnsCount) {
+	itemHeights = itemHeights.slice(0, Math.ceil(maxItemsCount / columnsCount) * columnsCount)
+
+	let rowIndex = 0
+	while (rowIndex * columnsCount < maxItemsCount) {
+		// Calculate row height.
+		let rowHeight = 0
+		let 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)
+}

package/source/DOM/Engine.js

@@ -0,0 +1,32 @@
+import ItemsContainer from './ItemsContainer'
+
+import ScrollableContainer, {
+	ScrollableWindowContainer
+} from './ScrollableContainer'
+
+import ListTopOffsetWatcher from './ListTopOffsetWatcher'
+
+export default {
+	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(scrollableContainer, getItemsContainerElement) {
+		if (scrollableContainer) {
+			return new ScrollableContainer(scrollableContainer, getItemsContainerElement)
+		} else if (typeof window !== 'undefined') {
+			return new ScrollableWindowContainer(getItemsContainerElement)
+		}
+	},
+	watchListTopOffset({
+		getListTopOffset,
+		onListTopOffsetChange
+	}) {
+		return new ListTopOffsetWatcher({
+			getListTopOffset,
+			onListTopOffsetChange
+		})
+	}
+}

package/source/DOM/ItemsContainer.js

@@ -0,0 +1,48 @@
+export default class ItemsContainer {
+	/**
+	 * Constructs a new "container" from an element.
+	 * @param {function} getElement
+	 */
+	constructor(getElement) {
+		this.getElement = getElement
+	}
+
+	/**
+	 * Returns an item element's "top offset", relative to the items `container`'s top edge.
+	 * @param  {number} renderedElementIndex — An index of an item relative to the "first shown item index". For example, if the list is showing items from index 8 to index 12 then `renderedElementIndex = 0` would mean the item at index `8`.
+	 * @return {number}
+	 */
+	getNthRenderedItemTopOffset(renderedElementIndex) {
+		return this.getElement().childNodes[renderedElementIndex].getBoundingClientRect().top - this.getElement().getBoundingClientRect().top
+	}
+
+	/**
+	 * Returns an item element's height.
+	 * @param  {number} renderedElementIndex — An index of an item relative to the "first shown item index". For example, if the list is showing items from index 8 to index 12 then `renderedElementIndex = 0` would mean the item at index `8`.
+	 * @return {number}
+	 */
+	getNthRenderedItemHeight(renderedElementIndex) {
+		// `offsetHeight` is not precise enough (doesn't return fractional pixels).
+		// return this.getElement().childNodes[renderedElementIndex].offsetHeight
+		return this.getElement().childNodes[renderedElementIndex].getBoundingClientRect().height
+	}
+
+	/**
+	 * Returns items container height.
+	 * @return {number}
+	 */
+	getHeight() {
+		// `offsetHeight` is not precise enough (doesn't return fractional pixels).
+		// return this.getElement().offsetHeight
+		return this.getElement().getBoundingClientRect().height
+	}
+
+	/**
+	 * Removes all item elements of an items container.
+	 */
+	clear() {
+		while (this.getElement().firstChild) {
+			this.getElement().removeChild(this.getElement().firstChild)
+		}
+	}
+}