@html-next/vertical-collection 4.0.1 → 5.0.0

package/{addon → src}/-private/data-view/radar/radar.js

@@ -6,26 +6,26 @@ import { DEBUG } from '@glimmer/env';
 
 import { Token, scheduler } from 'ember-raf-scheduler';
 
-import VirtualComponent from '../elements/virtual-component';
-import OccludedContent from '../elements/occluded-content';
-import insertRangeBefore from '../utils/insert-range-before';
-import objectAt from '../utils/object-at';
-import roundTo from '../utils/round-to';
-import { isPrepend, isAppend } from '../utils/mutation-checkers';
+import VirtualComponent from '../elements/virtual-component.js';
+import OccludedContent from '../elements/occluded-content.js';
+import insertRangeBefore from '../utils/insert-range-before.js';
+import objectAt from '../utils/object-at.js';
+import roundTo from '../utils/round-to.js';
+import { isPrepend, isAppend } from '../utils/mutation-checkers.js';
 
 import {
   addScrollHandler,
-  removeScrollHandler
-} from '../utils/scroll-handler';
+  removeScrollHandler,
+} from '../utils/scroll-handler.js';
 
-import ViewportContainer from '../viewport-container';
+import ViewportContainer from '../viewport-container.js';
 
-import closestElement from '../../utils/element/closest';
-import estimateElementHeight from '../../utils/element/estimate-element-height';
-import getScaledClientRect from '../../utils/element/get-scaled-client-rect';
-import keyForItem from '../../ember-internals/key-for-item';
+import closestElement from '../../utils/element/closest.js';
+import estimateElementHeight from '../../utils/element/estimate-element-height.js';
+import getScaledClientRect from '../../utils/element/get-scaled-client-rect.js';
+import keyForItem from '../../ember-internals/key-for-item.js';
 
-import document from '../../utils/document-shim';
+import document from '../../utils/document-shim.js';
 
 export default class Radar {
   constructor(
@@ -41,8 +41,8 @@ export default class Radar {
       renderFromLast,
       shouldRecycle,
       startingIndex,
-      occlusionTagName
-    }
+      occlusionTagName,
+    },
   ) {
     this.token = new Token(parentToken);
 
@@ -123,14 +123,17 @@ export default class Radar {
     }
 
     // Initialize virtual components
-    this.virtualComponents = A([this._occludedContentBefore, this._occludedContentAfter]);
+    this.virtualComponents = A([
+      this._occludedContentBefore,
+      this._occludedContentAfter,
+    ]);
     this.orderedComponents = [];
 
     this._updateVirtualComponents();
 
     // In older versions of Ember/IE, binding anything on an object in the template
     // adds observers which creates __ember_meta__
-    this.__ember_meta__ = null; // eslint-disable-line camelcase
+    this.__ember_meta__ = null;
 
     if (DEBUG) {
       this._debugDidUpdate = null;
@@ -145,8 +148,14 @@ export default class Radar {
     }
 
     // Boundaries
-    this._occludedContentBefore.removeEventListener('click', this._pageUpHandler);
-    this._occludedContentAfter.removeEventListener('click', this._pageDownHandler);
+    this._occludedContentBefore.removeEventListener(
+      'click',
+      this._pageUpHandler,
+    );
+    this._occludedContentAfter.removeEventListener(
+      'click',
+      this._pageDownHandler,
+    );
     this._occludedContentBefore.destroy();
     this._occludedContentAfter.destroy();
 
@@ -168,16 +177,15 @@ export default class Radar {
    * sets up initial scroll state, and
    */
   start() {
-    const {
-      startingIndex,
-      containerSelector,
-      _occludedContentBefore
-    } = this;
+    const { startingIndex, containerSelector, _occludedContentBefore } = this;
 
     // Use the occluded content element, which has been inserted into the DOM,
     // to find the item container and the scroll container
     this._itemContainer = _occludedContentBefore.element.parentNode;
-    this._scrollContainer = containerSelector === 'body' ? ViewportContainer : closestElement(this._itemContainer, containerSelector);
+    this._scrollContainer =
+      containerSelector === 'body'
+        ? ViewportContainer
+        : closestElement(this._itemContainer, containerSelector);
 
     this._updateConstants();
 
@@ -187,13 +195,14 @@ export default class Radar {
         renderFromLast,
         _calculatedEstimateHeight,
         _collectionOffset,
-        _calculatedScrollContainerHeight
+        _calculatedScrollContainerHeight,
       } = this;
 
       let startingScrollTop = startingIndex * _calculatedEstimateHeight;
 
       if (renderFromLast) {
-        startingScrollTop -= (_calculatedScrollContainerHeight - _calculatedEstimateHeight);
+        startingScrollTop -=
+          _calculatedScrollContainerHeight - _calculatedEstimateHeight;
       }
 
       // initialize the scrollTop value, which will be applied to the
@@ -309,7 +318,9 @@ export default class Radar {
    * pre-render and actual item size post-render.
    */
   _calculateScrollDiff() {
-    return (this._prependOffset + this._scrollTop) - this._scrollContainer.scrollTop;
+    return (
+      this._prependOffset + this._scrollTop - this._scrollContainer.scrollTop
+    );
   }
 
   _determineUpdateType() {
@@ -320,14 +331,16 @@ export default class Radar {
 
       _prevTotalItems,
       _prevFirstKey,
-      _prevLastKey
+      _prevLastKey,
     } = this;
 
     const lenDiff = totalItems - _prevTotalItems;
 
     if (isPrepend(lenDiff, items, key, _prevFirstKey, _prevLastKey) === true) {
       this.prepend(lenDiff);
-    } else if (isAppend(lenDiff, items, key, _prevFirstKey, _prevLastKey) === true) {
+    } else if (
+      isAppend(lenDiff, items, key, _prevFirstKey, _prevLastKey) === true
+    ) {
       this.append(lenDiff);
     } else {
       this.reset();
@@ -338,7 +351,8 @@ export default class Radar {
 
     this._prevTotalItems = totalItems;
     this._prevFirstKey = totalItems > 0 ? keyForItem(firstItem, key, 0) : 0;
-    this._prevLastKey = totalItems > 0 ? keyForItem(lastItem, key, totalItems - 1) : 0;
+    this._prevLastKey =
+      totalItems > 0 ? keyForItem(lastItem, key, totalItems - 1) : 0;
   }
 
   _updateConstants() {
@@ -346,57 +360,89 @@ export default class Radar {
       estimateHeight,
       _occludedContentBefore,
       _itemContainer,
-      _scrollContainer
+      _scrollContainer,
     } = this;
 
-    assert('Must provide a `estimateHeight` value to vertical-collection', estimateHeight !== null);
-    assert('itemContainer must be set on Radar before scheduling an update', _itemContainer !== null);
-    assert('scrollContainer must be set on Radar before scheduling an update', _scrollContainer !== null);
+    assert(
+      'Must provide a `estimateHeight` value to vertical-collection',
+      estimateHeight !== null,
+    );
+    assert(
+      'itemContainer must be set on Radar before scheduling an update',
+      _itemContainer !== null,
+    );
+    assert(
+      'scrollContainer must be set on Radar before scheduling an update',
+      _scrollContainer !== null,
+    );
 
     // The scroll container's offsetHeight will reflect the actual height of the element, while
     // it's measured height via bounding client rect will reflect the height with any transformations
     // applied. We use this to find out the scale of the items so we can store measurements at the
     // correct heights.
     const scrollContainerOffsetHeight = _scrollContainer.offsetHeight;
-    const { height: scrollContainerRenderedHeight } = _scrollContainer.getBoundingClientRect();
+    const { height: scrollContainerRenderedHeight } =
+      _scrollContainer.getBoundingClientRect();
 
     let transformScale;
 
     // transformScale represents the opposite of the scale, if any, applied to the collection. Check for equality
     // to guard against floating point errors, and check to make sure we're not dividing by zero (default to scale 1 if so)
-    if (scrollContainerOffsetHeight === scrollContainerRenderedHeight || scrollContainerRenderedHeight === 0) {
+    if (
+      scrollContainerOffsetHeight === scrollContainerRenderedHeight ||
+      scrollContainerRenderedHeight === 0
+    ) {
       transformScale = 1;
     } else {
-      transformScale = scrollContainerOffsetHeight / scrollContainerRenderedHeight;
+      transformScale =
+        scrollContainerOffsetHeight / scrollContainerRenderedHeight;
     }
 
-    const { top: scrollContentTop } = getScaledClientRect(_occludedContentBefore, transformScale);
-    const { top: scrollContainerTop } = getScaledClientRect(_scrollContainer, transformScale);
+    const { top: scrollContentTop } = getScaledClientRect(
+      _occludedContentBefore,
+      transformScale,
+    );
+    const { top: scrollContainerTop } = getScaledClientRect(
+      _scrollContainer,
+      transformScale,
+    );
 
     let scrollContainerMaxHeight = 0;
 
     if (_scrollContainer instanceof Element) {
-      const maxHeightStyle = window.getComputedStyle(_scrollContainer).maxHeight;
-
-      if (maxHeightStyle !== 'none') {
-        scrollContainerMaxHeight = estimateElementHeight(_scrollContainer.parentElement, maxHeightStyle);
+      const maxHeightStyle =
+        window.getComputedStyle(_scrollContainer).maxHeight;
+
+      if (maxHeightStyle && maxHeightStyle !== 'none') {
+        scrollContainerMaxHeight = estimateElementHeight(
+          _scrollContainer.parentElement,
+          maxHeightStyle,
+        );
       }
     }
 
-    const calculatedEstimateHeight = typeof estimateHeight === 'string'
-      ? estimateElementHeight(_itemContainer, estimateHeight)
-      : estimateHeight;
+    const calculatedEstimateHeight =
+      typeof estimateHeight === 'string' && estimateHeight
+        ? estimateElementHeight(_itemContainer, estimateHeight)
+        : estimateHeight;
 
-    assert(`calculatedEstimateHeight must be greater than 0, instead was "${calculatedEstimateHeight}" based on estimateHeight: ${estimateHeight}`, calculatedEstimateHeight > 0);
+    assert(
+      `calculatedEstimateHeight must be greater than 0, instead was "${calculatedEstimateHeight}" based on estimateHeight: ${estimateHeight}`,
+      calculatedEstimateHeight > 0,
+    );
 
     this._transformScale = transformScale;
     this._calculatedEstimateHeight = calculatedEstimateHeight;
-    this._calculatedScrollContainerHeight = roundTo(Math.max(scrollContainerOffsetHeight, scrollContainerMaxHeight));
+    this._calculatedScrollContainerHeight = roundTo(
+      Math.max(scrollContainerOffsetHeight, scrollContainerMaxHeight),
+    );
 
     // The offset between the top of the collection and the top of the scroll container. Determined by finding
     // the distance from the collection is from the top of the scroll container's content (scrollTop + actual position)
     // and subtracting the scroll containers actual top.
-    this._collectionOffset = roundTo((_scrollContainer.scrollTop + scrollContentTop) - scrollContainerTop);
+    this._collectionOffset = roundTo(
+      _scrollContainer.scrollTop + scrollContentTop - scrollContainerTop,
+    );
   }
 
   /*
@@ -433,10 +479,13 @@ export default class Radar {
 
       _occludedContentBefore,
       _occludedContentAfter,
-      totalItems
+      totalItems,
     } = this;
 
-    let renderedFirstItemIndex, renderedLastItemIndex, renderedTotalBefore, renderedTotalAfter;
+    let renderedFirstItemIndex,
+      renderedLastItemIndex,
+      renderedTotalBefore,
+      renderedTotalAfter;
 
     if (renderAll === true) {
       // All items should be rendered, set indexes based on total item count
@@ -444,31 +493,35 @@ export default class Radar {
       renderedLastItemIndex = totalItems - 1;
       renderedTotalBefore = 0;
       renderedTotalAfter = 0;
-
     } else if (_started === false) {
       // The Radar hasn't been started yet, render the initialRenderCount if it exists
       renderedFirstItemIndex = this.startingIndex;
       renderedLastItemIndex = this.startingIndex + this.initialRenderCount - 1;
       renderedTotalBefore = 0;
       renderedTotalAfter = 0;
-
     } else {
       renderedFirstItemIndex = this.firstItemIndex;
       renderedLastItemIndex = this.lastItemIndex;
       renderedTotalBefore = this.totalBefore;
       renderedTotalAfter = this.totalAfter;
-
     }
 
     // If there are less items available than rendered, we drop the last rendered item index
     renderedLastItemIndex = Math.min(renderedLastItemIndex, totalItems - 1);
 
     // Add components to be recycled to the pool
-    while (orderedComponents.length > 0 && orderedComponents[0].index < renderedFirstItemIndex) {
+    while (
+      orderedComponents.length > 0 &&
+      orderedComponents[0].index < renderedFirstItemIndex
+    ) {
       _componentPool.push(orderedComponents.shift());
     }
 
-    while (orderedComponents.length > 0 && orderedComponents[orderedComponents.length - 1].index > renderedLastItemIndex) {
+    while (
+      orderedComponents.length > 0 &&
+      orderedComponents[orderedComponents.length - 1].index >
+        renderedLastItemIndex
+    ) {
       _componentPool.unshift(orderedComponents.pop());
     }
 
@@ -488,8 +541,14 @@ export default class Radar {
       }
     }
 
-    let firstIndexInList = orderedComponents.length > 0 ? orderedComponents[0].index : renderedFirstItemIndex;
-    let lastIndexInList = orderedComponents.length > 0 ? orderedComponents[orderedComponents.length - 1].index : renderedFirstItemIndex - 1;
+    let firstIndexInList =
+      orderedComponents.length > 0
+        ? orderedComponents[0].index
+        : renderedFirstItemIndex;
+    let lastIndexInList =
+      orderedComponents.length > 0
+        ? orderedComponents[orderedComponents.length - 1].index
+        : renderedFirstItemIndex - 1;
 
     // Append as many items as needed to the rendered components
     while (lastIndexInList < renderedLastItemIndex) {
@@ -529,28 +588,33 @@ export default class Radar {
 
     // If there are any items remaining in the pool, remove them
     if (_componentPool.length > 0) {
-      if (shouldRecycle === true) {
-        // Grab the DOM of the remaining components and move it to temporary node disconnected from
-        // the body if the item can be reused later otherwise delete the component to avoid virtual re-rendering of the
-        // deleted item. If we end up using these components again, we'll grab their DOM and put it back
-        for (let i = _componentPool.length - 1; i >= 0; i--) {
-          const component = _componentPool[i];
-          const item = objectAt(items, component.index);
-          if (item) {
-            insertRangeBefore(this._domPool, null, component.realUpperBound, component.realLowerBound);
-          } else {
-            // Insert the virtual component bound back to make sure Glimmer is
-            // not confused about the state of the DOM.
-            insertRangeBefore(this._itemContainer, null, component.realUpperBound, component.realLowerBound);
-            run(() => {
-              virtualComponents.removeObject(component);
-            });
-            _componentPool.splice(i, 1);
-          }
+      // Grab the DOM of the remaining components and move it to temporary node disconnected from
+      // the body if the item can be reused later otherwise delete the component to avoid virtual re-rendering of the
+      // deleted item. If we end up using these components again, we'll grab their DOM and put it back
+      for (let i = _componentPool.length - 1; i >= 0; i--) {
+        const component = _componentPool[i];
+        const item = objectAt(items, component.index);
+        if (shouldRecycle === true && item) {
+          insertRangeBefore(
+            this._domPool,
+            null,
+            component.realUpperBound,
+            component.realLowerBound,
+          );
+        } else {
+          // Insert the virtual component bound back to make sure Glimmer is
+          // not confused about the state of the DOM.
+          insertRangeBefore(
+            this._itemContainer,
+            null,
+            component.realUpperBound,
+            component.realLowerBound,
+          );
+          run(() => {
+            virtualComponents.removeObject(component);
+          });
+          _componentPool.splice(i, 1);
         }
-      } else {
-        virtualComponents.removeObjects(_componentPool);
-        _componentPool.length = 0;
       }
     }
 
@@ -562,10 +626,16 @@ export default class Radar {
 
     // Set padding element heights.
     _occludedContentBefore.style.height = `${Math.max(renderedTotalBefore, 0)}px`;
-    _occludedContentBefore.innerHTML = totalItemsBefore > 0 ? `And ${totalItemsBefore} ${beforeItemsText} before` : '';
+    _occludedContentBefore.innerHTML =
+      totalItemsBefore > 0
+        ? `And ${totalItemsBefore} ${beforeItemsText} before`
+        : '';
 
     _occludedContentAfter.style.height = `${Math.max(renderedTotalAfter, 0)}px`;
-    _occludedContentAfter.innerHTML = totalItemsAfter > 0 ? `And ${totalItemsAfter} ${afterItemsText} after` : '';
+    _occludedContentAfter.innerHTML =
+      totalItemsAfter > 0
+        ? `And ${totalItemsAfter} ${afterItemsText} after`
+        : '';
   }
 
   _appendComponent(component) {
@@ -574,22 +644,27 @@ export default class Radar {
       _occludedContentAfter,
       _appendComponentPool,
       shouldRecycle,
-      _itemContainer
+      _itemContainer,
     } = this;
 
     const relativeNode = _occludedContentAfter.realUpperBound;
 
     if (component.rendered === true) {
-      insertRangeBefore(_itemContainer, relativeNode, component.realUpperBound, component.realLowerBound);
+      insertRangeBefore(
+        _itemContainer,
+        relativeNode,
+        component.realUpperBound,
+        component.realLowerBound,
+      );
     } else {
       virtualComponents.insertAt(virtualComponents.length - 1, component);
       component.rendered = true;
 
-      // shouldRecycle=false breaks UI when scrolling the elements fast. 
+      // shouldRecycle=false breaks UI when scrolling the elements fast.
       // Reference https://github.com/html-next/vertical-collection/issues/296
       // Components that are both new and appended still need to be rendered at the end because Glimmer.
       // We have to move them _after_ they render, so we schedule that if they exist
-      if(!shouldRecycle) {
+      if (!shouldRecycle) {
         _appendComponentPool.unshift(component);
 
         if (this._nextLayout === null) {
@@ -602,7 +677,12 @@ export default class Radar {
               // Changes with each inserted component
               const relativeNode = _occludedContentAfter.realUpperBound;
 
-              insertRangeBefore(this._itemContainer, relativeNode, component.realUpperBound, component.realLowerBound);
+              insertRangeBefore(
+                this._itemContainer,
+                relativeNode,
+                component.realUpperBound,
+                component.realLowerBound,
+              );
             }
           });
         }
@@ -615,13 +695,18 @@ export default class Radar {
       virtualComponents,
       _occludedContentBefore,
       _prependComponentPool,
-      _itemContainer
+      _itemContainer,
     } = this;
 
     const relativeNode = _occludedContentBefore.realLowerBound.nextSibling;
 
     if (component.rendered === true) {
-      insertRangeBefore(_itemContainer, relativeNode, component.realUpperBound, component.realLowerBound);
+      insertRangeBefore(
+        _itemContainer,
+        relativeNode,
+        component.realUpperBound,
+        component.realLowerBound,
+      );
     } else {
       virtualComponents.insertAt(virtualComponents.length - 1, component);
       component.rendered = true;
@@ -638,9 +723,15 @@ export default class Radar {
             const component = _prependComponentPool.pop();
 
             // Changes with each inserted component
-            const relativeNode = _occludedContentBefore.realLowerBound.nextSibling;
-
-            insertRangeBefore(_itemContainer, relativeNode, component.realUpperBound, component.realLowerBound);
+            const relativeNode =
+              _occludedContentBefore.realLowerBound.nextSibling;
+
+            insertRangeBefore(
+              _itemContainer,
+              relativeNode,
+              component.realUpperBound,
+              component.realLowerBound,
+            );
           }
         });
       }
@@ -661,7 +752,7 @@ export default class Radar {
 
       _firstReached,
       _lastReached,
-      _didReset
+      _didReset,
     } = this;
 
     if (_didReset || firstVisibleIndex !== _prevFirstVisibleIndex) {
@@ -687,7 +778,9 @@ export default class Radar {
     this._prevFirstItemIndex += numPrepended;
     this._prevLastItemIndex += numPrepended;
 
-    this.orderedComponents.forEach((c) => set(c, 'index', get(c, 'index') + numPrepended));
+    this.orderedComponents.forEach((c) =>
+      set(c, 'index', get(c, 'index') + numPrepended),
+    );
 
     this._firstReached = false;
 
@@ -709,14 +802,13 @@ export default class Radar {
       return; // All items rendered, no need to page up
     }
 
-    const {
-      bufferSize,
-      firstItemIndex,
-      totalComponents
-    } = this;
+    const { bufferSize, firstItemIndex, totalComponents } = this;
 
     if (firstItemIndex !== 0) {
-      const newFirstItemIndex = Math.max(firstItemIndex - totalComponents + bufferSize, 0);
+      const newFirstItemIndex = Math.max(
+        firstItemIndex - totalComponents + bufferSize,
+        0,
+      );
       const offset = this.getOffsetForIndex(newFirstItemIndex);
 
       this._scrollContainer.scrollTop = offset + this._collectionOffset;
@@ -729,15 +821,13 @@ export default class Radar {
       return; // All items rendered, no need to page down
     }
 
-    const {
-      bufferSize,
-      lastItemIndex,
-      totalComponents,
-      totalItems
-    } = this;
+    const { bufferSize, lastItemIndex, totalComponents, totalItems } = this;
 
     if (lastItemIndex !== totalItems - 1) {
-      const newFirstItemIndex = Math.min(lastItemIndex + bufferSize + 1, totalItems - totalComponents);
+      const newFirstItemIndex = Math.min(
+        lastItemIndex + bufferSize + 1,
+        totalItems - totalComponents,
+      );
       const offset = this.getOffsetForIndex(newFirstItemIndex);
 
       this._scrollContainer.scrollTop = offset + this._collectionOffset;
@@ -746,7 +836,10 @@ export default class Radar {
   }
 
   get totalComponents() {
-    return Math.min(this.totalItems, (this.lastItemIndex - this.firstItemIndex) + 1);
+    return Math.min(
+      this.totalItems,
+      this.lastItemIndex - this.firstItemIndex + 1,
+    );
   }
 
   /*
@@ -763,18 +856,24 @@ export default class Radar {
    * in this exact order.
    */
   get visibleTop() {
-    return Math.max(this._scrollTop - this._collectionOffset + this._prependOffset, 0);
+    return Math.max(
+      this._scrollTop - this._collectionOffset + this._prependOffset,
+      0,
+    );
   }
 
   get visibleMiddle() {
-    return this.visibleTop + (this._calculatedScrollContainerHeight / 2);
+    return this.visibleTop + this._calculatedScrollContainerHeight / 2;
   }
 
   get visibleBottom() {
     // There is a case where the container of this vertical collection could have height 0 at
     // initial render step but will be updated later. We want to return visibleBottom to be 0 rather
     // than -1.
-    return Math.max(this.visibleTop + this._calculatedScrollContainerHeight - 1, 0);
+    return Math.max(
+      this.visibleTop + this._calculatedScrollContainerHeight - 1,
+      0,
+    );
   }
 
   get totalItems() {

package/{addon → src}/-private/data-view/radar/static-radar.js

@@ -1,6 +1,6 @@
 import { DEBUG } from '@glimmer/env';
 
-import Radar from './radar';
+import Radar from './radar.js';
 
 export default class StaticRadar extends Radar {
   constructor(parentToken, options) {
@@ -20,7 +20,7 @@ export default class StaticRadar extends Radar {
       totalItems,
       visibleMiddle,
       _calculatedEstimateHeight,
-      _calculatedScrollContainerHeight
+      _calculatedScrollContainerHeight,
     } = this;
 
     if (totalItems === 0) {
@@ -32,9 +32,14 @@ export default class StaticRadar extends Radar {
 
     const maxIndex = totalItems - 1;
 
-    const middleItemIndex = Math.floor(visibleMiddle / _calculatedEstimateHeight);
+    const middleItemIndex = Math.floor(
+      visibleMiddle / _calculatedEstimateHeight,
+    );
 
-    const shouldRenderCount = Math.min(Math.ceil(_calculatedScrollContainerHeight / _calculatedEstimateHeight), totalItems);
+    const shouldRenderCount = Math.min(
+      Math.ceil(_calculatedScrollContainerHeight / _calculatedEstimateHeight),
+      totalItems,
+    );
 
     let firstItemIndex = middleItemIndex - Math.floor(shouldRenderCount / 2);
     let lastItemIndex = middleItemIndex + Math.ceil(shouldRenderCount / 2) - 1;
@@ -57,7 +62,7 @@ export default class StaticRadar extends Radar {
   }
 
   _didEarthquake(scrollDiff) {
-    return scrollDiff > (this._calculatedEstimateHeight / 2);
+    return scrollDiff > this._calculatedEstimateHeight / 2;
   }
 
   get total() {
@@ -69,7 +74,9 @@ export default class StaticRadar extends Radar {
   }
 
   get totalAfter() {
-    return this.total - ((this.lastItemIndex + 1) * this._calculatedEstimateHeight);
+    return (
+      this.total - (this.lastItemIndex + 1) * this._calculatedEstimateHeight
+    );
   }
 
   get firstItemIndex() {
@@ -85,7 +92,12 @@ export default class StaticRadar extends Radar {
   }
 
   get lastVisibleIndex() {
-    return Math.min(Math.ceil(this.visibleBottom / this._calculatedEstimateHeight), this.totalItems) - 1;
+    return (
+      Math.min(
+        Math.ceil(this.visibleBottom / this._calculatedEstimateHeight),
+        this.totalItems,
+      ) - 1
+    );
   }
 
   /*