@shopify/flash-list 2.0.0-rc.9 → 2.0.0

package/src/recyclerview/hooks/useRecyclerViewController.tsx

@@ -21,6 +21,7 @@ import { adjustOffsetForRTL } from "../utils/adjustOffsetForRTL";
 import { RVLayout } from "../layout-managers/LayoutManager";
 import { ScrollAnchorRef } from "../components/ScrollAnchor";
 import { PlatformConfig } from "../../native/config/PlatformHelper";
+import { WarningMessages } from "../../errors/WarningMessages";
 
 import { useUnmountFlag } from "./useUnmountFlag";
 import { useUnmountAwareTimeout } from "./useUnmountAwareCallbacks";
@@ -90,10 +91,9 @@ export function useRecyclerViewController<T>(
   );
 
   const computeFirstVisibleIndexForOffsetCorrection = useCallback(() => {
-    const { data, keyExtractor } = recyclerViewManager.props;
     if (
       recyclerViewManager.getIsFirstLayoutComplete() &&
-      keyExtractor &&
+      recyclerViewManager.hasStableDataKeys() &&
       recyclerViewManager.getDataLength() > 0 &&
       recyclerViewManager.shouldMaintainVisibleContentPosition()
     ) {
@@ -103,10 +103,8 @@ export function useRecyclerViewController<T>(
         recyclerViewManager.computeVisibleIndices().startIndex
       );
       if (firstVisibleIndex !== undefined && firstVisibleIndex >= 0) {
-        firstVisibleItemKey.current = keyExtractor(
-          data![firstVisibleIndex],
-          firstVisibleIndex
-        );
+        firstVisibleItemKey.current =
+          recyclerViewManager.getDataKey(firstVisibleIndex);
         firstVisibleItemLayout.current = {
           ...recyclerViewManager.getLayout(firstVisibleIndex),
         };
@@ -120,7 +118,7 @@ export function useRecyclerViewController<T>(
    * the user's current view position when new messages are added.
    */
   const applyOffsetCorrection = useCallback(() => {
-    const { horizontal, data, keyExtractor } = recyclerViewManager.props;
+    const { horizontal, data } = recyclerViewManager.props;
 
     // Execute all pending callbacks from previous scroll offset updates
     // This ensures any scroll operations that were waiting for render are completed
@@ -132,7 +130,7 @@ export function useRecyclerViewController<T>(
 
     if (
       recyclerViewManager.getIsFirstLayoutComplete() &&
-      keyExtractor &&
+      recyclerViewManager.hasStableDataKeys() &&
       currentDataLength > 0 &&
       recyclerViewManager.shouldMaintainVisibleContentPosition()
     ) {
@@ -144,13 +142,14 @@ export function useRecyclerViewController<T>(
             .getEngagedIndices()
             .findValue(
               (index) =>
-                keyExtractor?.(data![index], index) ===
+                recyclerViewManager.getDataKey(index) ===
                 firstVisibleItemKey.current
             ) ??
           (hasDataChanged
             ? data?.findIndex(
                 (item, index) =>
-                  keyExtractor?.(item, index) === firstVisibleItemKey.current
+                  recyclerViewManager.getDataKey(index) ===
+                  firstVisibleItemKey.current
               )
             : undefined);
 
@@ -281,10 +280,13 @@ export function useRecyclerViewController<T>(
       scrollToEnd: async ({ animated }: ScrollToEdgeParams = {}) => {
         const { data } = recyclerViewManager.props;
         if (data && data.length > 0) {
-          await handlerMethods.scrollToIndex({
-            index: data.length - 1,
-            animated,
-          });
+          const lastIndex = data.length - 1;
+          if (!recyclerViewManager.getEngagedIndices().includes(lastIndex)) {
+            await handlerMethods.scrollToIndex({
+              index: lastIndex,
+              animated,
+            });
+          }
         }
         setTimeout(() => {
           scrollViewRef.current!.scrollToEnd({ animated });
@@ -547,6 +549,9 @@ export function useRecyclerViewController<T>(
        * Disables item recycling in preparation for layout animations.
        */
       prepareForLayoutAnimationRender: () => {
+        if (!recyclerViewManager.props.keyExtractor) {
+          console.warn(WarningMessages.keyExtractorNotDefinedForAnimation);
+        }
         recyclerViewManager.animationOptimizationsEnabled = true;
       },
     };

package/src/recyclerview/layout-managers/LayoutManager.ts

@@ -7,6 +7,7 @@ import {
   findLastVisibleIndex,
 } from "../utils/findVisibleIndex";
 import { areDimensionsNotEqual } from "../utils/measureLayout";
+import { ErrorMessages } from "../../errors/ErrorMessages";
 
 /**
  * Base abstract class for layout managers in the recycler view system.
@@ -224,7 +225,7 @@ export abstract class RVLayoutManager {
    */
   getLayout(index: number): RVLayout {
     if (index >= this.layouts.length) {
-      throw new Error("index out of bounds, not enough layouts");
+      throw new Error(ErrorMessages.indexOutOfBounds);
     }
     let layout = this.layouts[index];
     if (!layout) {

package/src/{viewability → recyclerview/viewability}/ViewabilityHelper.ts

@@ -1,8 +1,7 @@
 import { ViewabilityConfig } from "react-native";
-import { Dimension, Layout } from "recyclerlistview";
 
-import CustomError from "../errors/CustomError";
-import ExceptionList from "../errors/ExceptionList";
+import { RVDimension, RVLayout } from "../layout-managers/LayoutManager";
+import { ErrorMessages } from "../../errors/ErrorMessages";
 
 /**
  * Helper class for computing viewable items based on the passed `viewabilityConfig`.
@@ -48,8 +47,8 @@ class ViewabilityHelper {
   public updateViewableItems(
     horizontal: boolean,
     scrollOffset: number,
-    listSize: Dimension,
-    getLayout: (index: number) => Layout | undefined,
+    listSize: RVDimension,
+    getLayout: (index: number) => RVLayout | undefined,
     viewableIndices?: number[]
   ) {
     if (viewableIndices !== undefined) {
@@ -61,8 +60,8 @@ class ViewabilityHelper {
       this.viewabilityConfig?.viewAreaCoveragePercentThreshold !== null &&
       this.viewabilityConfig?.viewAreaCoveragePercentThreshold !== undefined
     ) {
-      throw new CustomError(
-        ExceptionList.multipleViewabilityThresholdTypesNotSupported
+      throw new Error(
+        ErrorMessages.multipleViewabilityThresholdTypesNotSupported
       );
     }
     if (
@@ -126,10 +125,10 @@ class ViewabilityHelper {
     index: number,
     horizontal: boolean,
     scrollOffset: number,
-    listSize: Dimension,
+    listSize: RVDimension,
     viewAreaCoveragePercentThreshold: number | null | undefined,
     itemVisiblePercentThreshold: number | null | undefined,
-    getLayout: (index: number) => Layout | undefined
+    getLayout: (index: number) => RVLayout | undefined
   ) {
     const itemLayout = getLayout(index);
     if (itemLayout === undefined) {

package/src/{viewability → recyclerview/viewability}/ViewabilityManager.ts

@@ -1,6 +1,6 @@
 import { ViewabilityConfig } from "react-native";
 
-import FlashList from "../FlashList";
+import { RecyclerViewManager } from "../RecyclerViewManager";
 
 import ViewabilityHelper from "./ViewabilityHelper";
 import ViewToken from "./ViewToken";
@@ -9,31 +9,31 @@ import ViewToken from "./ViewToken";
  * Manager for viewability tracking. It holds multiple viewability callback pairs and keeps them updated.
  */
 export default class ViewabilityManager<T> {
-  private flashListRef: FlashList<T>;
+  private rvManager: RecyclerViewManager<T>;
   private viewabilityHelpers: ViewabilityHelper[] = [];
   private hasInteracted = false;
 
-  constructor(flashListRef: FlashList<T>) {
-    this.flashListRef = flashListRef;
+  constructor(rvManager: RecyclerViewManager<T>) {
+    this.rvManager = rvManager;
     if (
-      flashListRef.props.onViewableItemsChanged !== null &&
-      flashListRef.props.onViewableItemsChanged !== undefined
+      rvManager.props.onViewableItemsChanged !== null &&
+      rvManager.props.onViewableItemsChanged !== undefined
     ) {
       this.viewabilityHelpers.push(
         this.createViewabilityHelper(
-          flashListRef.props.viewabilityConfig,
+          rvManager.props.viewabilityConfig,
           (info) => {
-            flashListRef.props.onViewableItemsChanged?.(info);
+            rvManager.props.onViewableItemsChanged?.(info);
           }
         )
       );
     }
-    (flashListRef.props.viewabilityConfigCallbackPairs ?? []).forEach(
+    (rvManager.props.viewabilityConfigCallbackPairs ?? []).forEach(
       (pair, index) => {
         this.viewabilityHelpers.push(
           this.createViewabilityHelper(pair.viewabilityConfig, (info) => {
             const callback =
-              flashListRef.props.viewabilityConfigCallbackPairs?.[index]
+              rvManager.props.viewabilityConfigCallbackPairs?.[index]
                 ?.onViewableItemsChanged;
             callback?.(info);
           })
@@ -71,21 +71,19 @@ export default class ViewabilityManager<T> {
   };
 
   public updateViewableItems = (newViewableIndices?: number[]) => {
-    const listSize =
-      this.flashListRef.getWindowSize() ??
-      this.flashListRef.props.estimatedListSize;
+    const listSize = this.rvManager.getWindowSize();
     if (listSize === undefined || !this.shouldListenToVisibleIndices) {
       return;
     }
     const scrollOffset =
-      (this.flashListRef.getAbsoluteLastScrollOffset() ?? 0) -
-      this.flashListRef.firstItemOffset;
+      (this.rvManager.getAbsoluteLastScrollOffset() ?? 0) -
+      this.rvManager.firstItemOffset;
     this.viewabilityHelpers.forEach((viewabilityHelper) => {
       viewabilityHelper.updateViewableItems(
-        this.flashListRef.props.horizontal ?? false,
+        this.rvManager.props.horizontal ?? false,
         scrollOffset,
         listSize,
-        (index: number) => this.flashListRef.getLayout(index),
+        (index: number) => this.rvManager.getLayout(index),
         newViewableIndices
       );
     });
@@ -117,11 +115,11 @@ export default class ViewabilityManager<T> {
       index: number,
       isViewable: boolean
     ) => {
-      const item = this.flashListRef.props.data![index];
+      const item = this.rvManager.props.data![index];
       const key =
-        item === undefined || this.flashListRef.props.keyExtractor === undefined
+        item === undefined || this.rvManager.props.keyExtractor === undefined
           ? index.toString()
-          : this.flashListRef.props.keyExtractor(item, index);
+          : this.rvManager.props.keyExtractor(item, index);
       return {
         index,
         isViewable,

package/RNFlashList.podspec

@@ -1,37 +0,0 @@
-require 'json'
-
-package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
-new_arch_enabled = ENV['RCT_NEW_ARCH_ENABLED']
-
-Pod::Spec.new do |s|
-  s.name             = 'RNFlashList'
-  s.version          = package['version']
-  s.summary          = package['description']
-  s.homepage         = package['homepage']
-  s.license          = package['license']
-  s.author           = package['author']
-  s.platforms        = { :ios => '11.0', :tvos => '12.0' }
-  s.source           = { git: 'https://github.com/shopify/flash-list.git', tag: "v#{s.version}" }
-  s.source_files     = 'ios/Sources/**/*'
-  s.requires_arc     = true
-  s.swift_version    = '5.0'
-
-  if new_arch_enabled
-    s.pod_target_xcconfig = {
-      'OTHER_SWIFT_FLAGS' => '-D RCT_NEW_ARCH_ENABLED',
-    }
-  end
-
-  # install_modules_dependencies is available since RN 0.71
-  if respond_to?(:install_modules_dependencies, true)
-    install_modules_dependencies(s)
-  else
-    s.dependency "React-Core"
-  end
-
-  # Tests spec
-  s.test_spec 'Tests' do |test_spec|
-    test_spec.source_files = 'ios/Tests/**/*'
-    test_spec.framework = 'XCTest'
-  end
-end

package/android/build.gradle

@@ -1,89 +0,0 @@
-def isNewArchitectureEnabled() {
-    return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
-}
-
-apply plugin: 'com.android.library'
-
-apply plugin: 'kotlin-android'
-
-if (isNewArchitectureEnabled()) {
-    apply plugin: 'com.facebook.react'
-}
-
-def _ext = rootProject.ext
-
-def _reactNativeVersion = _ext.has('reactNative') ? _ext.reactNative : '+'
-def _compileSdkVersion = _ext.has('compileSdkVersion') ? _ext.compileSdkVersion : 30
-def _buildToolsVersion = _ext.has('buildToolsVersion') ? _ext.buildToolsVersion : '30.0.2'
-def _minSdkVersion = _ext.has('minSdkVersion') ? _ext.minSdkVersion : 21
-def _targetSdkVersion = _ext.has('targetSdkVersion') ? _ext.targetSdkVersion : 30
-def _junitVersion = _ext.has('junitVersion') ? _ext.junitVersion : '4.13.2'
-def _mockitoVersion = _ext.has('mockitoVersion') ? _ext.mockitoVersion : '3.2.0'
-def _androidTestRunnerVersion = _ext.has('androidTestRunnerVersion') ? _ext.androidTestRunnerVersion : '1.1.0'
-
-buildscript {
-    // buildscript is evaluated before any other task is executed, so this must be defined here
-    ext._kotlinVersion = rootProject.ext.has("kotlinVersion") ?  rootProject.ext.get('kotlinVersion') : '1.8.10'
-
-    repositories {
-        mavenCentral()
-    }
-
-    dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${_kotlinVersion}")
-    }
-}
-
-android {
-    compileSdkVersion _compileSdkVersion
-    buildToolsVersion _buildToolsVersion
-
-    // Conditional for compatibility with AGP <4.2.
-    if (project.android.hasProperty("namespace")) {
-        namespace = "com.shopify.reactnative.flash_list"
-    }
-
-    compileOptions {
-        sourceCompatibility JavaVersion.VERSION_1_8
-        targetCompatibility JavaVersion.VERSION_1_8
-    }
-
-    sourceSets {
-        main.java.srcDirs += 'src/main/kotlin'
-        debug.java.srcDirs += 'src/debug/kotlin'
-        test.java.srcDirs += 'src/test/kotlin'
-        androidTest.java.srcDirs += 'src/androidTest/kotlin'
-
-        if (!isNewArchitectureEnabled()) {
-            main.java.srcDirs += ['src/paper/java']
-        }
-    }
-
-    defaultConfig {
-        minSdkVersion _minSdkVersion
-        targetSdkVersion _targetSdkVersion
-        buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
-        versionCode 1
-        versionName "1.0"
-        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
-    }
-
-    lintOptions {
-        abortOnError false
-    }
-
-    testOptions {
-      unitTests.returnDefaultValues = true
-    }
-}
-
-dependencies {
-    compileOnly "com.facebook.react:react-native:${_reactNativeVersion}"
-    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${_kotlinVersion}"
-    testImplementation "junit:junit:${_junitVersion}"
-    testImplementation "org.mockito.kotlin:mockito-kotlin:${_mockitoVersion}"
-    testImplementation "org.mockito:mockito-inline:${_mockitoVersion}"
-    testImplementation 'com.google.code.gson:gson:2.8.9'
-    androidTestImplementation("androidx.test:runner:${_androidTestRunnerVersion}")
-    androidTestImplementation("androidx.test:rules:${_androidTestRunnerVersion}")
-}

package/android/src/main/AndroidManifest.xml

@@ -1,3 +0,0 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.shopify.reactnative.flash_list">
-</manifest>

package/android/src/main/kotlin/com/shopify/reactnative/flash_list/AutoLayoutShadow.kt

@@ -1,105 +0,0 @@
-package com.shopify.reactnative.flash_list
-
-class AutoLayoutShadow {
-    var horizontal: Boolean = false
-    var scrollOffset: Int = 0
-    var offsetFromStart: Int = 0
-    var windowSize: Int = 0
-    var renderOffset = 0
-
-    var blankOffsetAtStart = 0 // Tracks blank area from the top
-    var blankOffsetAtEnd = 0 // Tracks blank area from the bottom
-
-    var lastMaxBoundOverall = 0 // Tracks where the last pixel is drawn in the overall
-
-    private var lastMaxBound = 0 // Tracks where the last pixel is drawn in the visible window
-    private var lastMinBound = 0 // Tracks where first pixel is drawn in the visible window
-
-    /** Checks for overlaps or gaps between adjacent items and then applies a correction (Only Grid layouts with varying spans)
-     * Performance: RecyclerListView renders very small number of views and this is not going to trigger multiple layouts on Android side. Not expecting any major perf issue. */
-    fun clearGapsAndOverlaps(sortedItems: Array<CellContainer>) {
-        var maxBound = 0
-        var minBound = Int.MAX_VALUE
-        var maxBoundNeighbour = 0
-        lastMaxBoundOverall = 0
-        for (i in 0 until sortedItems.size - 1) {
-            val cell = sortedItems[i]
-            val neighbour = sortedItems[i + 1]
-            // Only apply correction if the next cell is consecutive.
-            val isNeighbourConsecutive = neighbour.index == cell.index + 1
-            if (isWithinBounds(cell) || isWithinBounds(neighbour)) {
-                if (!horizontal) {
-                    maxBound = kotlin.math.max(maxBound, cell.bottom);
-                    minBound = kotlin.math.min(minBound, cell.top);
-                    maxBoundNeighbour = maxBound
-                    if (isNeighbourConsecutive) {
-                        if (cell.left < neighbour.left) {
-                            if (cell.right != neighbour.left) {
-                                neighbour.right = cell.right + neighbour.width
-                                neighbour.left = cell.right
-                            }
-                            if (cell.top != neighbour.top) {
-                                neighbour.bottom = cell.top + neighbour.height
-                                neighbour.top = cell.top
-                            }
-                        } else {
-                            neighbour.bottom = maxBound + neighbour.height
-                            neighbour.top = maxBound
-                        }
-                    }
-                    if (isWithinBounds(neighbour)) {
-                        maxBoundNeighbour = kotlin.math.max(maxBound, neighbour.bottom)
-                    }
-                } else {
-                    maxBound = kotlin.math.max(maxBound, cell.right);
-                    minBound = kotlin.math.min(minBound, cell.left);
-                    maxBoundNeighbour = maxBound
-                    if (isNeighbourConsecutive) {
-                        if (cell.top < neighbour.top) {
-                            if (cell.bottom != neighbour.top) {
-                                neighbour.bottom = cell.bottom + neighbour.height
-                                neighbour.top = cell.bottom
-                            }
-                            if (cell.left != neighbour.left) {
-                                neighbour.right = cell.left + neighbour.width
-                                neighbour.left = cell.left
-                            }
-                        } else {
-                            neighbour.right = maxBound + neighbour.width
-                            neighbour.left = maxBound
-                        }
-                    }
-                    if (isWithinBounds(neighbour)) {
-                        maxBoundNeighbour = kotlin.math.max(maxBound, neighbour.right)
-                    }
-                }
-            }
-            lastMaxBoundOverall = kotlin.math.max(lastMaxBoundOverall, if (horizontal) cell.right else cell.bottom)
-            lastMaxBoundOverall = kotlin.math.max(lastMaxBoundOverall, if (horizontal) neighbour.right else neighbour.bottom)
-        }
-        lastMaxBound = maxBoundNeighbour
-        lastMinBound = minBound
-    }
-
-    /** Offset provided by react can be one frame behind the real one, it's important that this method is called with offset taken directly from
-     * scrollview object */
-    fun computeBlankFromGivenOffset(actualScrollOffset: Int, distanceFromWindowStart: Int, distanceFromWindowEnd: Int): Int {
-        val actualScrollOffset = actualScrollOffset - offsetFromStart;
-        blankOffsetAtStart = lastMinBound - actualScrollOffset - distanceFromWindowStart
-        blankOffsetAtEnd = actualScrollOffset + windowSize - renderOffset - lastMaxBound - distanceFromWindowEnd
-        return kotlin.math.max(blankOffsetAtStart, blankOffsetAtEnd)
-    }
-
-    /** It's important to avoid correcting views outside the render window. An item that isn't being recycled might still remain in the view tree. If views outside get considered then gaps between
-     * unused items will cause algorithm to fail.*/
-    private fun isWithinBounds(cell: CellContainer): Boolean {
-        val scrollOffset = scrollOffset - offsetFromStart;
-        return if (!horizontal) {
-            (cell.top >= (scrollOffset - renderOffset) || cell.bottom >= (scrollOffset - renderOffset)) &&
-                    (cell.top <= scrollOffset + windowSize || cell.bottom <= scrollOffset + windowSize)
-        } else {
-            (cell.left >= (scrollOffset - renderOffset) || cell.right >= (scrollOffset - renderOffset)) &&
-                    (cell.left <= scrollOffset + windowSize || cell.right <= scrollOffset + windowSize)
-        }
-    }
-}

package/android/src/main/kotlin/com/shopify/reactnative/flash_list/AutoLayoutView.kt

@@ -1,158 +0,0 @@
-package com.shopify.reactnative.flash_list
-
-import android.content.Context
-import android.graphics.Canvas
-import android.util.DisplayMetrics
-import android.util.Log
-import android.view.View
-import android.view.ViewGroup
-import android.widget.HorizontalScrollView
-import android.widget.ScrollView
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.ReactContext
-import com.facebook.react.bridge.WritableMap
-import com.facebook.react.uimanager.UIManagerHelper
-import com.facebook.react.uimanager.events.EventDispatcher
-import com.facebook.react.uimanager.events.RCTEventEmitter
-import com.facebook.react.views.view.ReactViewGroup
-
-
-/** Container for all RecyclerListView children. This will automatically remove all gaps and overlaps for GridLayouts with flexible spans.
- * Note: This cannot work for masonry layouts i.e, pinterest like layout */
-class AutoLayoutView(context: Context) : ReactViewGroup(context) {
-    val alShadow = AutoLayoutShadow()
-    var enableInstrumentation = false
-    var disableAutoLayout = false
-
-    var pixelDensity = 1.0;
-
-    /** Overriding draw instead of onLayout. RecyclerListView uses absolute positions for each and every item which means that changes in child layouts may not trigger onLayout on this container. The same layout
-     * can still cause views to overlap. Therefore, it makes sense to override draw to do correction. */
-    override fun dispatchDraw(canvas: Canvas) {
-        fixLayout()
-        fixFooter()
-        super.dispatchDraw(canvas)
-
-        val parentScrollView = getParentScrollView()
-        if (enableInstrumentation && parentScrollView != null) {
-            /** Since we need to call this method with scrollOffset on the UI thread and not with the one react has we're querying parent's parent
-            directly which will be a ScrollView. If it isn't reported values will be incorrect but the component will not break.
-            RecyclerListView is expected not to change the hierarchy of children. */
-
-            val scrollContainerSize = if (alShadow.horizontal) parentScrollView.width else parentScrollView.height
-
-            val scrollOffset = if (alShadow.horizontal) parentScrollView.scrollX else parentScrollView.scrollY
-
-            val startOffset = if (alShadow.horizontal) left else top
-            val endOffset = if (alShadow.horizontal) right else bottom
-
-            val distanceFromWindowStart = kotlin.math.max(startOffset - scrollOffset, 0)
-            val distanceFromWindowEnd = kotlin.math.max(scrollOffset + scrollContainerSize - endOffset, 0)
-
-            alShadow.computeBlankFromGivenOffset(scrollOffset, distanceFromWindowStart, distanceFromWindowEnd)
-            emitBlankAreaEvent()
-        }
-    }
-
-    /** Sorts views by index and then invokes clearGaps which does the correction.
-     * Performance: Sort is needed. Given relatively low number of views in RecyclerListView render tree this should be a non issue.*/
-    private fun fixLayout() {
-        if (childCount > 1 && !disableAutoLayout) {
-            val positionSortedViews: Array<CellContainer> = Array(childCount) {
-                val child = getChildAt(it)
-                if (child is CellContainer) {
-                    child
-                } else {
-                    throw IllegalStateException("CellRendererComponent outer view should always be CellContainer. Learn more here: https://shopify.github.io/flash-list/docs/usage#cellrenderercomponent.")
-                }
-            }
-            positionSortedViews.sortBy { it.index }
-            alShadow.offsetFromStart = if (alShadow.horizontal) left else top
-            alShadow.clearGapsAndOverlaps(positionSortedViews)
-        }
-    }
-
-    /** Fixes footer position along with rest of the items */
-    private fun fixFooter() {
-        val parentScrollView = getParentScrollView()
-        if (disableAutoLayout || parentScrollView == null) {
-            return
-        }
-        val isAutoLayoutEndVisible = if (alShadow.horizontal) right <= parentScrollView.width else bottom <= parentScrollView.height
-        if (!isAutoLayoutEndVisible) {
-            return
-        }
-        val autoLayoutParent = parent as? View
-        val footer = getFooter();
-        val diff = getFooterDiff()
-        if (diff == 0 || footer == null || autoLayoutParent == null) {
-            return
-        }
-
-        if (alShadow.horizontal) {
-            footer.offsetLeftAndRight(diff)
-            right += diff
-            autoLayoutParent.right += diff
-        } else {
-            footer.offsetTopAndBottom(diff)
-            bottom += diff
-            autoLayoutParent.bottom += diff
-        }
-    }
-
-    private fun getFooterDiff(): Int {
-        if (childCount == 0) {
-            alShadow.lastMaxBoundOverall = 0
-        } else if (childCount == 1) {
-            val firstChild = getChildAt(0)
-            alShadow.lastMaxBoundOverall = if (alShadow.horizontal) {
-                firstChild.right
-            } else {
-                firstChild.bottom
-            }
-        }
-        val autoLayoutEnd = if (alShadow.horizontal) right - left else bottom - top
-        return alShadow.lastMaxBoundOverall - autoLayoutEnd
-    }
-
-    private fun getFooter(): View? {
-        return (parent as? ViewGroup)?.let {
-            for (i in 0 until it.childCount) {
-                val view = it.getChildAt(i)
-                if (view is CellContainer && view.index == -1) {
-                    return@let view
-                }
-            }
-            return@let null
-        }
-    }
-
-    private fun getParentScrollView(): View? {
-        var autoLayoutParent = parent;
-        while (autoLayoutParent != null) {
-            if (autoLayoutParent is ScrollView || autoLayoutParent is HorizontalScrollView) {
-                return autoLayoutParent as View
-            }
-            autoLayoutParent = autoLayoutParent.parent;
-        }
-        return null
-    }
-
-
-    private fun emitBlankAreaEvent() {
-        val eventDispatcher: EventDispatcher? =
-            UIManagerHelper.getEventDispatcherForReactTag(context as ReactContext, id)
-
-        if (eventDispatcher != null) {
-            val surfaceId = UIManagerHelper.getSurfaceId(context as ReactContext)
-            eventDispatcher.dispatchEvent(
-                BlankAreaEvent(
-                    surfaceId,
-                    viewTag = id,
-                    offsetStart = alShadow.blankOffsetAtStart / pixelDensity,
-                    offsetEnd = alShadow.blankOffsetAtEnd / pixelDensity
-                )
-            )
-        }
-    }
-}