@legendapp/list 2.0.8 → 2.0.10

package/index.mjs

@@ -1,14 +1,15 @@
-import * as React2 from 'react';
-import React2__default, { useReducer, useEffect, createContext, useRef, useState, useMemo, useLayoutEffect, useCallback, useImperativeHandle, forwardRef, memo, useContext } from 'react';
+import * as React3 from 'react';
+import React3__default, { useReducer, useEffect, createContext, useRef, useState, useMemo, useCallback, useLayoutEffect, useImperativeHandle, forwardRef, memo, useContext } from 'react';
 import { View, Text, Platform, Animated, StyleSheet, Dimensions, RefreshControl, unstable_batchedUpdates } from 'react-native';
 import { useSyncExternalStore } from 'use-sync-external-store/shim';
 
 // src/components/LegendList.tsx
-var ContextState = React2.createContext(null);
+var ContextState = React3.createContext(null);
 function StateProvider({ children }) {
-  const [value] = React2.useState(() => ({
+  const [value] = React3.useState(() => ({
     animatedScrollY: new Animated.Value(0),
     columnWrapperStyle: void 0,
+    internalState: void 0,
     listeners: /* @__PURE__ */ new Map(),
     mapViewabilityAmountCallbacks: /* @__PURE__ */ new Map(),
     mapViewabilityAmountValues: /* @__PURE__ */ new Map(),
@@ -24,10 +25,10 @@ function StateProvider({ children }) {
     ]),
     viewRefs: /* @__PURE__ */ new Map()
   }));
-  return /* @__PURE__ */ React2.createElement(ContextState.Provider, { value }, children);
+  return /* @__PURE__ */ React3.createElement(ContextState.Provider, { value }, children);
 }
 function useStateContext() {
-  return React2.useContext(ContextState);
+  return React3.useContext(ContextState);
 }
 function createSelectorFunctionsArr(ctx, signalNames) {
   let lastValues = [];
@@ -97,23 +98,23 @@ function getContentSize(ctx) {
   return headerSize + footerSize + totalSize + stylePaddingTop;
 }
 function useArr$(signalNames) {
-  const ctx = React2.useContext(ContextState);
-  const { subscribe, get } = React2.useMemo(() => createSelectorFunctionsArr(ctx, signalNames), [ctx, signalNames]);
+  const ctx = React3.useContext(ContextState);
+  const { subscribe, get } = React3.useMemo(() => createSelectorFunctionsArr(ctx, signalNames), [ctx, signalNames]);
   const value = useSyncExternalStore(subscribe, get);
   return value;
 }
 function useSelector$(signalName, selector) {
-  const ctx = React2.useContext(ContextState);
-  const { subscribe, get } = React2.useMemo(() => createSelectorFunctionsArr(ctx, [signalName]), [ctx, signalName]);
+  const ctx = React3.useContext(ContextState);
+  const { subscribe, get } = React3.useMemo(() => createSelectorFunctionsArr(ctx, [signalName]), [ctx, signalName]);
   const value = useSyncExternalStore(subscribe, () => selector(get()[0]));
   return value;
 }
 
 // src/components/DebugView.tsx
 var DebugRow = ({ children }) => {
-  return /* @__PURE__ */ React2.createElement(View, { style: { alignItems: "center", flexDirection: "row", justifyContent: "space-between" } }, children);
+  return /* @__PURE__ */ React3.createElement(View, { style: { alignItems: "center", flexDirection: "row", justifyContent: "space-between" } }, children);
 };
-var DebugView = React2.memo(function DebugView2({ state }) {
+var DebugView = React3.memo(function DebugView2({ state }) {
   const ctx = useStateContext();
   const [totalSize = 0, scrollAdjust = 0, rawScroll = 0, scroll = 0, _numContainers = 0, _numContainersPooled = 0] = useArr$([
     "totalSize",
@@ -128,7 +129,7 @@ var DebugView = React2.memo(function DebugView2({ state }) {
   useInterval(() => {
     forceUpdate();
   }, 100);
-  return /* @__PURE__ */ React2.createElement(
+  return /* @__PURE__ */ React3.createElement(
     View,
     {
       pointerEvents: "none",
@@ -144,14 +145,14 @@ var DebugView = React2.memo(function DebugView2({ state }) {
         top: 0
       }
     },
-    /* @__PURE__ */ React2.createElement(DebugRow, null, /* @__PURE__ */ React2.createElement(Text, null, "TotalSize:"), /* @__PURE__ */ React2.createElement(Text, null, totalSize.toFixed(2))),
-    /* @__PURE__ */ React2.createElement(DebugRow, null, /* @__PURE__ */ React2.createElement(Text, null, "ContentSize:"), /* @__PURE__ */ React2.createElement(Text, null, contentSize.toFixed(2))),
-    /* @__PURE__ */ React2.createElement(DebugRow, null, /* @__PURE__ */ React2.createElement(Text, null, "At end:"), /* @__PURE__ */ React2.createElement(Text, null, String(state.isAtEnd))),
-    /* @__PURE__ */ React2.createElement(Text, null),
-    /* @__PURE__ */ React2.createElement(DebugRow, null, /* @__PURE__ */ React2.createElement(Text, null, "ScrollAdjust:"), /* @__PURE__ */ React2.createElement(Text, null, scrollAdjust.toFixed(2))),
-    /* @__PURE__ */ React2.createElement(Text, null),
-    /* @__PURE__ */ React2.createElement(DebugRow, null, /* @__PURE__ */ React2.createElement(Text, null, "RawScroll: "), /* @__PURE__ */ React2.createElement(Text, null, rawScroll.toFixed(2))),
-    /* @__PURE__ */ React2.createElement(DebugRow, null, /* @__PURE__ */ React2.createElement(Text, null, "ComputedScroll: "), /* @__PURE__ */ React2.createElement(Text, null, scroll.toFixed(2)))
+    /* @__PURE__ */ React3.createElement(DebugRow, null, /* @__PURE__ */ React3.createElement(Text, null, "TotalSize:"), /* @__PURE__ */ React3.createElement(Text, null, totalSize.toFixed(2))),
+    /* @__PURE__ */ React3.createElement(DebugRow, null, /* @__PURE__ */ React3.createElement(Text, null, "ContentSize:"), /* @__PURE__ */ React3.createElement(Text, null, contentSize.toFixed(2))),
+    /* @__PURE__ */ React3.createElement(DebugRow, null, /* @__PURE__ */ React3.createElement(Text, null, "At end:"), /* @__PURE__ */ React3.createElement(Text, null, String(state.isAtEnd))),
+    /* @__PURE__ */ React3.createElement(Text, null),
+    /* @__PURE__ */ React3.createElement(DebugRow, null, /* @__PURE__ */ React3.createElement(Text, null, "ScrollAdjust:"), /* @__PURE__ */ React3.createElement(Text, null, scrollAdjust.toFixed(2))),
+    /* @__PURE__ */ React3.createElement(Text, null),
+    /* @__PURE__ */ React3.createElement(DebugRow, null, /* @__PURE__ */ React3.createElement(Text, null, "RawScroll: "), /* @__PURE__ */ React3.createElement(Text, null, rawScroll.toFixed(2))),
+    /* @__PURE__ */ React3.createElement(DebugRow, null, /* @__PURE__ */ React3.createElement(Text, null, "ComputedScroll: "), /* @__PURE__ */ React3.createElement(Text, null, scroll.toFixed(2)))
   );
 });
 function useInterval(callback, delay) {
@@ -160,11 +161,6 @@ function useInterval(callback, delay) {
     return () => clearInterval(interval);
   }, [delay]);
 }
-var LeanViewComponent = React2.forwardRef((props, ref) => {
-  return React2.createElement("RCTView", { ...props, ref });
-});
-LeanViewComponent.displayName = "RCTView";
-var LeanView = Platform.OS === "android" || Platform.OS === "ios" ? LeanViewComponent : View;
 
 // src/constants.ts
 var POSITION_OUT_OF_VIEW = -1e7;
@@ -198,7 +194,9 @@ function useValue$(key, params) {
         prevValue = newValue;
         if (!didQueueTask) {
           didQueueTask = true;
-          if (delayValue === 0) {
+          if (delayValue === void 0) {
+            fn();
+          } else if (delayValue === 0) {
             queueMicrotask(fn);
           } else {
             setTimeout(fn, delayValue);
@@ -223,8 +221,8 @@ var PositionViewState = typedMemo(function PositionView({
   ...rest
 }) {
   const [position = POSITION_OUT_OF_VIEW] = useArr$([`containerPosition${id}`]);
-  return /* @__PURE__ */ React2.createElement(
-    LeanView,
+  return /* @__PURE__ */ React3.createElement(
+    View,
     {
       ref: refView,
       style: [
@@ -251,7 +249,7 @@ var PositionViewAnimated = typedMemo(function PositionView2({
   } else {
     position = horizontal ? { left: position$ } : { top: position$ };
   }
-  return /* @__PURE__ */ React2.createElement(Animated.View, { ref: refView, style: [style, position], ...rest });
+  return /* @__PURE__ */ React3.createElement(Animated.View, { ref: refView, style: [style, position], ...rest });
 });
 var PositionViewSticky = typedMemo(function PositionViewSticky2({
   id,
@@ -264,8 +262,8 @@ var PositionViewSticky = typedMemo(function PositionViewSticky2({
   ...rest
 }) {
   const [position = POSITION_OUT_OF_VIEW, headerSize] = useArr$([`containerPosition${id}`, "headerSize"]);
-  const transform = React2.useMemo(() => {
-    if (animatedScrollY && stickyOffset) {
+  const transform = React3.useMemo(() => {
+    if (animatedScrollY && stickyOffset !== void 0) {
       const stickyPosition = animatedScrollY.interpolate({
         extrapolate: "clamp",
         inputRange: [position + headerSize, position + 5e3 + headerSize],
@@ -274,8 +272,8 @@ var PositionViewSticky = typedMemo(function PositionViewSticky2({
       return horizontal ? [{ translateX: stickyPosition }] : [{ translateY: stickyPosition }];
     }
   }, [animatedScrollY, headerSize, horizontal, stickyOffset, position]);
-  const viewStyle = React2.useMemo(() => [style, { zIndex: index + 1e3 }, { transform }], [style, transform]);
-  return /* @__PURE__ */ React2.createElement(Animated.View, { ref: refView, style: viewStyle, ...rest });
+  const viewStyle = React3.useMemo(() => [style, { zIndex: index + 1e3 }, { transform }], [style, transform]);
+  return /* @__PURE__ */ React3.createElement(Animated.View, { ref: refView, style: viewStyle, ...rest });
 });
 var PositionView3 = IsNewArchitecture ? PositionViewState : PositionViewAnimated;
 var symbolFirst = Symbol();
@@ -428,7 +426,30 @@ function useSyncLayout() {
 // src/components/Separator.tsx
 function Separator({ ItemSeparatorComponent, leadingItem }) {
   const isLastItem = useIsLastItem();
-  return isLastItem ? null : /* @__PURE__ */ React2.createElement(ItemSeparatorComponent, { leadingItem });
+  return isLastItem ? null : /* @__PURE__ */ React3.createElement(ItemSeparatorComponent, { leadingItem });
+}
+function useOnLayoutSync({
+  ref,
+  onLayoutProp,
+  onLayoutChange
+}, deps = []) {
+  const onLayout = useCallback(
+    (event) => {
+      onLayoutChange(event.nativeEvent.layout, false);
+      onLayoutProp == null ? void 0 : onLayoutProp(event);
+    },
+    [onLayoutChange]
+  );
+  if (IsNewArchitecture) {
+    useLayoutEffect(() => {
+      if (ref.current) {
+        ref.current.measure((x, y, width, height) => {
+          onLayoutChange({ height, width, x, y }, true);
+        });
+      }
+    }, deps);
+  }
+  return { onLayout };
 }
 
 // src/components/Container.tsx
@@ -456,7 +477,7 @@ var Container = typedMemo(function Container2({
   const [layoutRenderCount, forceLayoutRender] = useState(0);
   const otherAxisPos = numColumns > 1 ? `${(column - 1) / numColumns * 100}%` : 0;
   const otherAxisSize = numColumns > 1 ? `${1 / numColumns * 100}%` : void 0;
-  let didLayout = false;
+  const didLayoutRef = useRef(false);
   const style = useMemo(() => {
     let paddingStyles;
     if (columnWrapperStyle) {
@@ -506,15 +527,16 @@ var Container = typedMemo(function Container2({
       value: data
     };
   }, [id, itemKey, index, data]);
-  const onLayout = (event) => {
+  const onLayoutChange = (rectangle) => {
     var _a, _b;
     if (!isNullOrUndefined(itemKey)) {
-      didLayout = true;
-      let layout = event.nativeEvent.layout;
-      const size = layout[horizontal ? "width" : "height"];
+      didLayoutRef.current = true;
+      let layout = rectangle;
+      const size = Math.floor(rectangle[horizontal ? "width" : "height"] * 8) / 8;
       const doUpdate = () => {
         refLastSize.current = { height: layout.height, width: layout.width };
         updateItemSize2(itemKey, layout);
+        didLayoutRef.current = true;
       };
       if (IsNewArchitecture || size > 0) {
         doUpdate();
@@ -526,25 +548,20 @@ var Container = typedMemo(function Container2({
       }
     }
   };
-  if (IsNewArchitecture) {
-    useLayoutEffect(() => {
-      var _a, _b;
-      if (!isNullOrUndefined(itemKey)) {
-        const measured = (_b = (_a = ref.current) == null ? void 0 : _a.unstable_getBoundingClientRect) == null ? void 0 : _b.call(_a);
-        if (measured) {
-          const size = Math.floor(measured[horizontal ? "width" : "height"] * 8) / 8;
-          if (size) {
-            updateItemSize2(itemKey, measured);
-          }
-        }
-      }
-    }, [itemKey, layoutRenderCount]);
-  } else {
+  const { onLayout } = useOnLayoutSync(
+    {
+      onLayoutChange,
+      ref
+    },
+    [itemKey, layoutRenderCount]
+  );
+  if (!IsNewArchitecture) {
     useEffect(() => {
       if (!isNullOrUndefined(itemKey)) {
         const timeout = setTimeout(() => {
-          if (!didLayout && refLastSize.current) {
+          if (!didLayoutRef.current && refLastSize.current) {
             updateItemSize2(itemKey, refLastSize.current);
+            didLayoutRef.current = true;
           }
         }, 16);
         return () => {
@@ -554,7 +571,7 @@ var Container = typedMemo(function Container2({
     }, [itemKey]);
   }
   const PositionComponent = isSticky ? PositionViewSticky : PositionView3;
-  return /* @__PURE__ */ React2.createElement(
+  return /* @__PURE__ */ React3.createElement(
     PositionComponent,
     {
       animatedScrollY: isSticky ? animatedScrollY : void 0,
@@ -567,7 +584,7 @@ var Container = typedMemo(function Container2({
       stickyOffset: isSticky ? stickyOffset : void 0,
       style
     },
-    /* @__PURE__ */ React2.createElement(ContextContainer.Provider, { value: contextValue }, renderedItem, renderedItemInfo && ItemSeparatorComponent && /* @__PURE__ */ React2.createElement(Separator, { ItemSeparatorComponent, leadingItem: renderedItemInfo.item }))
+    /* @__PURE__ */ React3.createElement(ContextContainer.Provider, { value: contextValue }, renderedItem, renderedItemInfo && ItemSeparatorComponent && /* @__PURE__ */ React3.createElement(Separator, { ItemSeparatorComponent, leadingItem: renderedItemInfo.item }))
   );
 });
 
@@ -585,14 +602,18 @@ var Containers = typedMemo(function Containers2({
   const [numContainers, numColumns] = useArr$(["numContainersPooled", "numColumns"]);
   const animSize = useValue$("totalSize", {
     // Use a microtask if increasing the size significantly, otherwise use a timeout
-    delay: (value, prevValue) => !prevValue || value - prevValue > 20 ? 0 : 200
+    // If this is the initial scroll, we don't want to delay because we want to update the size immediately
+    delay: (value, prevValue) => {
+      var _a;
+      return !((_a = ctx.internalState) == null ? void 0 : _a.initialScroll) ? !prevValue || value - prevValue > 20 ? 0 : 200 : void 0;
+    }
   });
   const animOpacity = waitForInitialLayout && !IsNewArchitecture ? useValue$("containersDidLayout", { getValue: (value) => value ? 1 : 0 }) : void 0;
   const otherAxisSize = useValue$("otherAxisSize", { delay: 0 });
   const containers = [];
   for (let i = 0; i < numContainers; i++) {
     containers.push(
-      /* @__PURE__ */ React2.createElement(
+      /* @__PURE__ */ React3.createElement(
         Container,
         {
           getRenderedItem: getRenderedItem2,
@@ -627,13 +648,18 @@ var Containers = typedMemo(function Containers2({
       }
     }
   }
-  return /* @__PURE__ */ React2.createElement(Animated.View, { style }, containers);
+  return /* @__PURE__ */ React3.createElement(Animated.View, { style }, containers);
 });
+var LayoutView = ({ onLayoutChange, refView, ...rest }) => {
+  const ref = refView != null ? refView : useRef();
+  const { onLayout } = useOnLayoutSync({ onLayoutChange, ref });
+  return /* @__PURE__ */ React.createElement(View, { ...rest, onLayout, ref });
+};
 function ScrollAdjust() {
   const bias = 1e7;
   const [scrollAdjust, scrollAdjustUserOffset] = useArr$(["scrollAdjust", "scrollAdjustUserOffset"]);
   const scrollOffset = (scrollAdjust || 0) + (scrollAdjustUserOffset || 0) + bias;
-  return /* @__PURE__ */ React2.createElement(
+  return /* @__PURE__ */ React3.createElement(
     View,
     {
       style: {
@@ -648,88 +674,26 @@ function ScrollAdjust() {
 }
 function SnapWrapper({ ScrollComponent, ...props }) {
   const [snapToOffsets] = useArr$(["snapToOffsets"]);
-  return /* @__PURE__ */ React2__default.createElement(ScrollComponent, { ...props, snapToOffsets });
-}
-function useThrottleDebounce(mode) {
-  const timeoutRef = useRef(null);
-  const lastCallTimeRef = useRef(0);
-  const lastArgsRef = useRef(null);
-  const clearTimeoutRef = () => {
-    if (timeoutRef.current) {
-      clearTimeout(timeoutRef.current);
-      timeoutRef.current = null;
-    }
-  };
-  const execute = useCallback(
-    (callback, delay, ...args) => {
-      {
-        const now = Date.now();
-        lastArgsRef.current = args;
-        if (now - lastCallTimeRef.current >= delay) {
-          lastCallTimeRef.current = now;
-          callback(...args);
-          clearTimeoutRef();
-        } else {
-          clearTimeoutRef();
-          timeoutRef.current = setTimeout(
-            () => {
-              if (lastArgsRef.current) {
-                lastCallTimeRef.current = Date.now();
-                callback(...lastArgsRef.current);
-                timeoutRef.current = null;
-                lastArgsRef.current = null;
-              }
-            },
-            delay - (now - lastCallTimeRef.current)
-          );
-        }
-      }
-    },
-    [mode]
-  );
-  return execute;
-}
-
-// src/hooks/useSyncLayout.tsx
-function useSyncLayout2({
-  onChange
-}) {
-  const ref = useRef(null);
-  const onLayout = useCallback(
-    (event) => {
-      onChange(event.nativeEvent.layout, false);
-    },
-    [onChange]
-  );
-  if (IsNewArchitecture) {
-    useLayoutEffect(() => {
-      if (ref.current) {
-        ref.current.measure((x, y, width, height) => {
-          onChange({ height, width, x, y }, true);
-        });
-      }
-    }, []);
-  }
-  return { onLayout, ref };
+  return /* @__PURE__ */ React3__default.createElement(ScrollComponent, { ...props, snapToOffsets });
 }
 
 // src/components/ListComponent.tsx
 var getComponent = (Component) => {
-  if (React2.isValidElement(Component)) {
+  if (React3.isValidElement(Component)) {
     return Component;
   }
   if (Component) {
-    return /* @__PURE__ */ React2.createElement(Component, null);
+    return /* @__PURE__ */ React3.createElement(Component, null);
   }
   return null;
 };
 var Padding = () => {
   const animPaddingTop = useValue$("alignItemsPaddingTop", { delay: 0 });
-  return /* @__PURE__ */ React2.createElement(Animated.View, { style: { paddingTop: animPaddingTop } });
+  return /* @__PURE__ */ React3.createElement(Animated.View, { style: { paddingTop: animPaddingTop } });
 };
 var PaddingDevMode = () => {
   const animPaddingTop = useValue$("alignItemsPaddingTop", { delay: 0 });
-  return /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement(Animated.View, { style: { paddingTop: animPaddingTop } }), /* @__PURE__ */ React2.createElement(
+  return /* @__PURE__ */ React3.createElement(React3.Fragment, null, /* @__PURE__ */ React3.createElement(Animated.View, { style: { paddingTop: animPaddingTop } }), /* @__PURE__ */ React3.createElement(
     Animated.View,
     {
       style: {
@@ -772,14 +736,11 @@ var ListComponent = typedMemo(function ListComponent2({
   ...rest
 }) {
   const ctx = useStateContext();
-  const { onLayout: onLayoutHeaderSync, ref: refHeader } = useSyncLayout2({
-    onChange: onLayoutHeader
-  });
   const ScrollComponent = renderScrollComponent ? useMemo(
-    () => React2.forwardRef((props, ref) => renderScrollComponent({ ...props, ref })),
+    () => React3.forwardRef((props, ref) => renderScrollComponent({ ...props, ref })),
     [renderScrollComponent]
   ) : Animated.ScrollView;
-  React2.useEffect(() => {
+  React3.useEffect(() => {
     if (canRender) {
       setTimeout(() => {
         scrollAdjustHandler.setMounted();
@@ -787,7 +748,7 @@ var ListComponent = typedMemo(function ListComponent2({
     }
   }, [canRender]);
   const SnapOrScroll = snapToIndices ? SnapWrapper : ScrollComponent;
-  return /* @__PURE__ */ React2.createElement(
+  return /* @__PURE__ */ React3.createElement(
     SnapOrScroll,
     {
       ...rest,
@@ -806,11 +767,11 @@ var ListComponent = typedMemo(function ListComponent2({
       ScrollComponent: snapToIndices ? ScrollComponent : void 0,
       style
     },
-    maintainVisibleContentPosition && /* @__PURE__ */ React2.createElement(ScrollAdjust, null),
-    ENABLE_DEVMODE ? /* @__PURE__ */ React2.createElement(PaddingDevMode, null) : /* @__PURE__ */ React2.createElement(Padding, null),
-    ListHeaderComponent && /* @__PURE__ */ React2.createElement(View, { onLayout: onLayoutHeaderSync, ref: refHeader, style: ListHeaderComponentStyle }, getComponent(ListHeaderComponent)),
+    maintainVisibleContentPosition && /* @__PURE__ */ React3.createElement(ScrollAdjust, null),
+    ENABLE_DEVMODE ? /* @__PURE__ */ React3.createElement(PaddingDevMode, null) : /* @__PURE__ */ React3.createElement(Padding, null),
+    ListHeaderComponent && /* @__PURE__ */ React3.createElement(LayoutView, { onLayoutChange: onLayoutHeader, style: ListHeaderComponentStyle }, getComponent(ListHeaderComponent)),
     ListEmptyComponent && getComponent(ListEmptyComponent),
-    canRender && !ListEmptyComponent && /* @__PURE__ */ React2.createElement(
+    canRender && !ListEmptyComponent && /* @__PURE__ */ React3.createElement(
       Containers,
       {
         getRenderedItem: getRenderedItem2,
@@ -821,22 +782,22 @@ var ListComponent = typedMemo(function ListComponent2({
         waitForInitialLayout
       }
     ),
-    ListFooterComponent && /* @__PURE__ */ React2.createElement(
-      View,
+    ListFooterComponent && /* @__PURE__ */ React3.createElement(
+      LayoutView,
       {
-        onLayout: (event) => {
-          const size = event.nativeEvent.layout[horizontal ? "width" : "height"];
+        onLayoutChange: (layout) => {
+          const size = layout[horizontal ? "width" : "height"];
           set$(ctx, "footerSize", size);
         },
         style: ListFooterComponentStyle
       },
       getComponent(ListFooterComponent)
     ),
-    __DEV__ && ENABLE_DEVMODE && /* @__PURE__ */ React2.createElement(DevNumbers, null)
+    __DEV__ && ENABLE_DEVMODE && /* @__PURE__ */ React3.createElement(DevNumbers, null)
   );
 });
-var DevNumbers = __DEV__ && React2.memo(function DevNumbers2() {
-  return Array.from({ length: 100 }).map((_, index) => /* @__PURE__ */ React2.createElement(
+var DevNumbers = __DEV__ && React3.memo(function DevNumbers2() {
+  return Array.from({ length: 100 }).map((_, index) => /* @__PURE__ */ React3.createElement(
     View,
     {
       key: index,
@@ -848,7 +809,7 @@ var DevNumbers = __DEV__ && React2.memo(function DevNumbers2() {
         width: "100%"
       }
     },
-    /* @__PURE__ */ React2.createElement(Text, { style: { color: "red" } }, index * 100)
+    /* @__PURE__ */ React3.createElement(Text, { style: { color: "red" } }, index * 100)
   ));
 });
 
@@ -860,7 +821,7 @@ function getId(state, index) {
   }
   const ret = index < data.length ? keyExtractor ? keyExtractor(data[index], index) : index : null;
   const id = ret;
-  state.idCache.set(index, id);
+  state.idCache[index] = id;
   return id;
 }
 
@@ -946,7 +907,7 @@ var finishScrollTo = (state) => {
 // src/core/scrollTo.ts
 function scrollTo(state, params = {}) {
   var _a;
-  const { animated, noScrollingTo } = params;
+  const { animated, noScrollingTo, isInitialScroll } = params;
   const {
     refScroller,
     props: { horizontal }
@@ -957,14 +918,21 @@ function scrollTo(state, params = {}) {
     state.scrollingTo = params;
   }
   state.scrollPending = offset;
-  (_a = refScroller.current) == null ? void 0 : _a.scrollTo({
-    animated: !!animated,
-    x: horizontal ? offset : 0,
-    y: horizontal ? 0 : offset
-  });
+  if (!params.isInitialScroll || Platform.OS === "android") {
+    (_a = refScroller.current) == null ? void 0 : _a.scrollTo({
+      animated: !!animated,
+      x: horizontal ? offset : 0,
+      y: horizontal ? 0 : offset
+    });
+  }
   if (!animated) {
     state.scroll = offset;
     setTimeout(() => finishScrollTo(state), 100);
+    if (isInitialScroll) {
+      setTimeout(() => {
+        state.initialScroll = void 0;
+      }, 500);
+    }
   }
 }
 
@@ -1059,7 +1027,16 @@ function prepareMVCP(ctx, state, dataChanged) {
     if (targetId !== void 0 && prevPosition !== void 0) {
       const newPosition = positions.get(targetId);
       if (newPosition !== void 0) {
-        positionDiff = newPosition - prevPosition;
+        const totalSize = peek$(ctx, "totalSize");
+        let diff = newPosition - prevPosition;
+        if (state.scroll + state.scrollLength > totalSize) {
+          if (diff > 0) {
+            diff = Math.max(0, totalSize - state.scroll - state.scrollLength);
+          } else {
+            diff = 0;
+          }
+        }
+        positionDiff = diff;
       }
     }
     if (positionDiff !== void 0 && Math.abs(positionDiff) > 0.1) {
@@ -1068,6 +1045,68 @@ function prepareMVCP(ctx, state, dataChanged) {
   };
 }
 
+// src/core/prepareColumnStartState.ts
+function prepareColumnStartState(ctx, state, startIndex, useAverageSize) {
+  var _a;
+  const numColumns = peek$(ctx, "numColumns");
+  let rowStartIndex = startIndex;
+  const columnAtStart = state.columns.get(state.idCache[startIndex]);
+  if (columnAtStart !== 1) {
+    rowStartIndex = findRowStartIndex(state, numColumns, startIndex);
+  }
+  let currentRowTop = 0;
+  const curId = state.idCache[rowStartIndex];
+  const column = state.columns.get(curId);
+  if (rowStartIndex > 0) {
+    const prevIndex = rowStartIndex - 1;
+    const prevId = state.idCache[prevIndex];
+    const prevPosition = (_a = state.positions.get(prevId)) != null ? _a : 0;
+    const prevRowStart = findRowStartIndex(state, numColumns, prevIndex);
+    const prevRowHeight = calculateRowMaxSize(state, prevRowStart, prevIndex, useAverageSize);
+    currentRowTop = prevPosition + prevRowHeight;
+  }
+  return {
+    column,
+    currentRowTop,
+    startIndex: rowStartIndex
+  };
+}
+function findRowStartIndex(state, numColumns, index) {
+  if (numColumns <= 1) {
+    return Math.max(0, index);
+  }
+  let rowStart = Math.max(0, index);
+  while (rowStart > 0) {
+    const columnForIndex = state.columns.get(state.idCache[rowStart]);
+    if (columnForIndex === 1) {
+      break;
+    }
+    rowStart--;
+  }
+  return rowStart;
+}
+function calculateRowMaxSize(state, startIndex, endIndex, useAverageSize) {
+  if (endIndex < startIndex) {
+    return 0;
+  }
+  const { data } = state.props;
+  if (!data) {
+    return 0;
+  }
+  let maxSize = 0;
+  for (let i = startIndex; i <= endIndex; i++) {
+    if (i < 0 || i >= data.length) {
+      continue;
+    }
+    const id = state.idCache[i];
+    const size = getItemSize(state, id, i, data[i], useAverageSize);
+    if (size > maxSize) {
+      maxSize = size;
+    }
+  }
+  return maxSize;
+}
+
 // src/utils/setPaddingTop.ts
 function setPaddingTop(ctx, state, { stylePaddingTop, alignItemsPaddingTop }) {
   if (stylePaddingTop !== void 0) {
@@ -1127,6 +1166,7 @@ function updateTotalSize(ctx, state) {
 }
 function addTotalSize(ctx, state, key, add) {
   const { alignItemsAtEnd } = state.props;
+  const prevTotalSize = state.totalSize;
   if (key === null) {
     state.totalSize = add;
     if (state.timeoutSetPaddingTop) {
@@ -1136,9 +1176,11 @@ function addTotalSize(ctx, state, key, add) {
   } else {
     state.totalSize += add;
   }
-  set$(ctx, "totalSize", state.totalSize);
-  if (alignItemsAtEnd) {
-    updateAlignItemsPaddingTop(ctx, state);
+  if (prevTotalSize !== state.totalSize) {
+    set$(ctx, "totalSize", state.totalSize);
+    if (alignItemsAtEnd) {
+      updateAlignItemsPaddingTop(ctx, state);
+    }
   }
 }
 
@@ -1159,7 +1201,7 @@ function updateSnapToOffsets(ctx, state) {
 
 // src/core/updateItemPositions.ts
 function updateItemPositions(ctx, state, dataChanged, { startIndex, scrollBottomBuffered } = { scrollBottomBuffered: -1, startIndex: 0 }) {
-  var _a, _b, _c, _d, _e, _f;
+  var _a, _b, _c, _d;
   const {
     columns,
     indexByKey,
@@ -1169,41 +1211,47 @@ function updateItemPositions(ctx, state, dataChanged, { startIndex, scrollBottom
     props: { getEstimatedItemSize, snapToIndices, enableAverages }
   } = state;
   const data = state.props.data;
+  const dataLength = data.length;
   const numColumns = peek$(ctx, "numColumns");
+  const hasColumns = numColumns > 1;
   const indexByKeyForChecking = __DEV__ ? /* @__PURE__ */ new Map() : void 0;
   const maxVisibleArea = scrollBottomBuffered + 1e3;
   const useAverageSize = enableAverages && !getEstimatedItemSize;
   let currentRowTop = 0;
   let column = 1;
   let maxSizeInRow = 0;
-  const hasColumns = numColumns > 1;
   if (startIndex > 0) {
-    const prevIndex = startIndex - 1;
-    const prevId = (_a = idCache.get(prevIndex)) != null ? _a : getId(state, prevIndex);
-    const prevPosition = (_b = positions.get(prevId)) != null ? _b : 0;
     if (hasColumns) {
-      const prevColumn = (_c = columns.get(prevId)) != null ? _c : 1;
-      currentRowTop = prevPosition;
-      column = prevColumn % numColumns + 1;
-    } else {
-      const prevSize = (_d = sizesKnown.get(prevId)) != null ? _d : getItemSize(state, prevId, prevIndex, data[prevIndex], useAverageSize);
+      const { startIndex: processedStartIndex, currentRowTop: initialRowTop } = prepareColumnStartState(
+        ctx,
+        state,
+        startIndex,
+        useAverageSize
+      );
+      startIndex = processedStartIndex;
+      currentRowTop = initialRowTop;
+    } else if (startIndex < dataLength) {
+      const prevIndex = startIndex - 1;
+      const prevId = getId(state, prevIndex);
+      const prevPosition = (_a = positions.get(prevId)) != null ? _a : 0;
+      const prevSize = (_b = sizesKnown.get(prevId)) != null ? _b : getItemSize(state, prevId, prevIndex, data[prevIndex], useAverageSize);
       currentRowTop = prevPosition + prevSize;
     }
   }
   const needsIndexByKey = dataChanged || indexByKey.size === 0;
   let didBreakEarly = false;
   let breakAt;
-  const dataLength = data.length;
   for (let i = startIndex; i < dataLength; i++) {
     if (breakAt && i > breakAt) {
       didBreakEarly = true;
       break;
     }
-    if (!dataChanged && currentRowTop > maxVisibleArea) {
-      breakAt = i + 10;
+    if (breakAt === void 0 && !dataChanged && currentRowTop > maxVisibleArea) {
+      const itemsPerRow = hasColumns ? numColumns : 1;
+      breakAt = i + itemsPerRow + 10;
     }
-    const id = (_e = idCache.get(i)) != null ? _e : getId(state, i);
-    const size = (_f = sizesKnown.get(id)) != null ? _f : getItemSize(state, id, i, data[i], useAverageSize);
+    const id = (_c = idCache[i]) != null ? _c : getId(state, i);
+    const size = (_d = sizesKnown.get(id)) != null ? _d : getItemSize(state, id, i, data[i], useAverageSize);
     if (__DEV__ && needsIndexByKey) {
       if (indexByKeyForChecking.has(id)) {
         console.error(
@@ -1440,9 +1488,12 @@ function maybeUpdateViewabilityCallback(ctx, configId, containerId, viewToken) {
 var batchedUpdates = unstable_batchedUpdates || ((callback) => callback());
 
 // src/utils/checkAllSizesKnown.ts
+function isNullOrUndefined2(value) {
+  return value === null || value === void 0;
+}
 function checkAllSizesKnown(state) {
   const { startBuffered, endBuffered, sizesKnown } = state;
-  if (endBuffered !== null) {
+  if (!isNullOrUndefined2(endBuffered) && !isNullOrUndefined2(startBuffered) && startBuffered >= 0 && endBuffered >= 0) {
     let areAllKnown = true;
     for (let i = startBuffered; areAllKnown && i <= endBuffered; i++) {
       const key = getId(state, i);
@@ -1459,6 +1510,8 @@ function findAvailableContainers(ctx, state, numNeeded, startBuffered, endBuffer
   const { stickyContainerPool, containerItemTypes } = state;
   const result = [];
   const availableContainers = [];
+  const pendingRemovalSet = new Set(pendingRemoval);
+  let pendingRemovalChanged = false;
   const stickyIndicesSet = state.props.stickyIndicesSet;
   const stickyItemIndices = (needNewContainers == null ? void 0 : needNewContainers.filter((index) => stickyIndicesSet.has(index))) || [];
   const canReuseContainer = (containerIndex, requiredType) => {
@@ -1474,12 +1527,11 @@ function findAvailableContainers(ctx, state, numNeeded, startBuffered, endBuffer
     let foundContainer = false;
     for (const containerIndex of stickyContainerPool) {
       const key = peek$(ctx, `containerItemKey${containerIndex}`);
-      const isPendingRemoval = pendingRemoval.includes(containerIndex);
+      const isPendingRemoval = pendingRemovalSet.has(containerIndex);
       if ((key === void 0 || isPendingRemoval) && canReuseContainer(containerIndex, requiredType)) {
         result.push(containerIndex);
-        if (isPendingRemoval) {
-          const index = pendingRemoval.indexOf(containerIndex);
-          pendingRemoval.splice(index, 1);
+        if (isPendingRemoval && pendingRemovalSet.delete(containerIndex)) {
+          pendingRemovalChanged = true;
         }
         foundContainer = true;
         if (requiredItemTypes) typeIndex++;
@@ -1499,13 +1551,11 @@ function findAvailableContainers(ctx, state, numNeeded, startBuffered, endBuffer
     }
     const key = peek$(ctx, `containerItemKey${u}`);
     let isOk = key === void 0;
-    if (!isOk) {
-      const index = pendingRemoval.indexOf(u);
-      if (index !== -1) {
-        pendingRemoval.splice(index, 1);
-        const requiredType = neededTypes[typeIndex];
-        isOk = canReuseContainer(u, requiredType);
-      }
+    if (!isOk && pendingRemovalSet.has(u)) {
+      pendingRemovalSet.delete(u);
+      pendingRemovalChanged = true;
+      const requiredType = neededTypes[typeIndex];
+      isOk = canReuseContainer(u, requiredType);
     }
     if (isOk) {
       result.push(u);
@@ -1563,6 +1613,12 @@ function findAvailableContainers(ctx, state, numNeeded, startBuffered, endBuffer
       }
     }
   }
+  if (pendingRemovalChanged) {
+    pendingRemoval.length = 0;
+    for (const value of pendingRemovalSet) {
+      pendingRemoval.push(value);
+    }
+  }
   return result.sort(comparatorDefault);
 }
 function comparatorByDistance(a, b) {
@@ -1700,17 +1756,16 @@ function setDidLayout(ctx, state) {
       onLoad({ elapsedTimeInMs: Date.now() - loadStartTime });
     }
   };
-  if (Platform.OS === "android" || !IsNewArchitecture) {
-    if (initialScroll) {
-      queueMicrotask(() => {
+  if (Platform.OS === "android" && initialScroll) {
+    if (IsNewArchitecture) {
+      scrollToIndex(ctx, state, { ...initialScroll, animated: false });
+      requestAnimationFrame(() => {
         scrollToIndex(ctx, state, { ...initialScroll, animated: false });
-        requestAnimationFrame(() => {
-          scrollToIndex(ctx, state, { ...initialScroll, animated: false });
-          setIt();
-        });
+        setIt();
       });
     } else {
-      queueMicrotask(setIt);
+      scrollToIndex(ctx, state, { ...initialScroll, animated: false });
+      setIt();
     }
   } else {
     setIt();
@@ -1723,7 +1778,8 @@ function findCurrentStickyIndex(stickyArray, scroll, state) {
   const idCache = state.idCache;
   const positions = state.positions;
   for (let i = stickyArray.length - 1; i >= 0; i--) {
-    const stickyId = (_a = idCache.get(stickyArray[i])) != null ? _a : getId(state, stickyArray[i]);
+    const stickyIndex = stickyArray[i];
+    const stickyId = (_a = idCache[stickyIndex]) != null ? _a : getId(state, stickyIndex);
     const stickyPos = stickyId ? positions.get(stickyId) : void 0;
     if (stickyPos !== void 0 && scroll >= stickyPos) {
       return i;
@@ -1736,40 +1792,43 @@ function getActiveStickyIndices(ctx, state, stickyIndices) {
     Array.from(state.stickyContainerPool).map((i) => peek$(ctx, `containerItemKey${i}`)).map((key) => key ? state.indexByKey.get(key) : void 0).filter((idx) => idx !== void 0 && stickyIndices.has(idx))
   );
 }
-function handleStickyActivation(ctx, state, stickyIndices, stickyArray, scroll, needNewContainers, startBuffered, endBuffered) {
+function handleStickyActivation(ctx, state, stickyIndices, stickyArray, currentStickyIdx, needNewContainers, startBuffered, endBuffered) {
   var _a;
   const activeIndices = getActiveStickyIndices(ctx, state, stickyIndices);
-  const currentStickyIdx = findCurrentStickyIndex(stickyArray, scroll, state);
   state.activeStickyIndex = currentStickyIdx >= 0 ? stickyArray[currentStickyIdx] : void 0;
   for (let offset = 0; offset <= 1; offset++) {
     const idx = currentStickyIdx - offset;
     if (idx < 0 || activeIndices.has(stickyArray[idx])) continue;
     const stickyIndex = stickyArray[idx];
-    const stickyId = (_a = state.idCache.get(stickyIndex)) != null ? _a : getId(state, stickyIndex);
+    const stickyId = (_a = state.idCache[stickyIndex]) != null ? _a : getId(state, stickyIndex);
     if (stickyId && !state.containerItemKeys.has(stickyId) && (stickyIndex < startBuffered || stickyIndex > endBuffered)) {
       needNewContainers.push(stickyIndex);
     }
   }
 }
-function handleStickyRecycling(ctx, state, stickyArray, scroll, scrollBuffer, pendingRemoval) {
+function handleStickyRecycling(ctx, state, stickyArray, scroll, scrollBuffer, currentStickyIdx, pendingRemoval) {
   var _a, _b, _c;
-  const currentStickyIdx = findCurrentStickyIndex(stickyArray, scroll, state);
   for (const containerIndex of state.stickyContainerPool) {
     const itemKey = peek$(ctx, `containerItemKey${containerIndex}`);
     const itemIndex = itemKey ? state.indexByKey.get(itemKey) : void 0;
     if (itemIndex === void 0) continue;
     const arrayIdx = stickyArray.indexOf(itemIndex);
-    if (arrayIdx === -1) continue;
+    if (arrayIdx === -1) {
+      state.stickyContainerPool.delete(containerIndex);
+      set$(ctx, `containerSticky${containerIndex}`, false);
+      set$(ctx, `containerStickyOffset${containerIndex}`, void 0);
+      continue;
+    }
     const isRecentSticky = arrayIdx >= currentStickyIdx - 1 && arrayIdx <= currentStickyIdx + 1;
     if (isRecentSticky) continue;
     const nextIndex = stickyArray[arrayIdx + 1];
     let shouldRecycle = false;
     if (nextIndex) {
-      const nextId = (_a = state.idCache.get(nextIndex)) != null ? _a : getId(state, nextIndex);
+      const nextId = (_a = state.idCache[nextIndex]) != null ? _a : getId(state, nextIndex);
       const nextPos = nextId ? state.positions.get(nextId) : void 0;
       shouldRecycle = nextPos !== void 0 && scroll > nextPos + scrollBuffer * 2;
     } else {
-      const currentId = (_b = state.idCache.get(itemIndex)) != null ? _b : getId(state, itemIndex);
+      const currentId = (_b = state.idCache[itemIndex]) != null ? _b : getId(state, itemIndex);
       if (currentId) {
         const currentPos = state.positions.get(currentId);
         const currentSize = (_c = state.sizes.get(currentId)) != null ? _c : getItemSize(state, currentId, itemIndex, state.props.data[itemIndex]);
@@ -1797,7 +1856,7 @@ function calculateItemsInView(ctx, state, params = {}) {
       sizes,
       startBufferedId: startBufferedIdOrig,
       viewabilityConfigCallbackPairs,
-      props: { getItemType, initialScroll, itemsAreEqual, keyExtractor, scrollBuffer }
+      props: { getItemType, initialScroll, itemsAreEqual, keyExtractor, onStickyHeaderChange, scrollBuffer }
     } = state;
     const { data } = state.props;
     const stickyIndicesArr = state.props.stickyIndicesArr || [];
@@ -1832,6 +1891,10 @@ function calculateItemsInView(ctx, state, params = {}) {
       set$(ctx, "debugRawScroll", scrollState);
       set$(ctx, "debugComputedScroll", scroll);
     }
+    const previousStickyIndex = state.activeStickyIndex;
+    const currentStickyIdx = stickyIndicesArr.length > 0 ? findCurrentStickyIndex(stickyIndicesArr, scroll, state) : -1;
+    const nextActiveStickyIndex = currentStickyIdx >= 0 ? stickyIndicesArr[currentStickyIdx] : void 0;
+    state.activeStickyIndex = nextActiveStickyIndex;
     let scrollBufferTop = scrollBuffer;
     let scrollBufferBottom = scrollBuffer;
     if (speed > 0 || speed === 0 && scroll < Math.max(50, scrollBuffer)) {
@@ -1853,7 +1916,7 @@ function calculateItemsInView(ctx, state, params = {}) {
     const checkMVCP = doMVCP ? prepareMVCP(ctx, state, dataChanged) : void 0;
     if (dataChanged) {
       indexByKey.clear();
-      idCache.clear();
+      idCache.length = 0;
       positions.clear();
     }
     const startIndex = dataChanged ? 0 : (_a = minIndexSizeChanged != null ? minIndexSizeChanged : state.startBuffered) != null ? _a : 0;
@@ -1869,7 +1932,7 @@ function calculateItemsInView(ctx, state, params = {}) {
     let endBuffered = null;
     let loopStart = !dataChanged && startBufferedIdOrig ? indexByKey.get(startBufferedIdOrig) || 0 : 0;
     for (let i = loopStart; i >= 0; i--) {
-      const id = (_b = idCache.get(i)) != null ? _b : getId(state, i);
+      const id = (_b = idCache[i]) != null ? _b : getId(state, i);
       const top = positions.get(id);
       const size = (_c = sizes.get(id)) != null ? _c : getItemSize(state, id, i, data[i]);
       const bottom = top + size;
@@ -1897,7 +1960,7 @@ function calculateItemsInView(ctx, state, params = {}) {
     let firstFullyOnScreenIndex;
     const dataLength = data.length;
     for (let i = Math.max(0, loopStart); i < dataLength && (!foundEnd || i <= maxIndexRendered); i++) {
-      const id = (_d = idCache.get(i)) != null ? _d : getId(state, i);
+      const id = (_d = idCache[i]) != null ? _d : getId(state, i);
       const size = (_e = sizes.get(id)) != null ? _e : getItemSize(state, id, i, data[i]);
       const top = positions.get(id);
       if (!foundEnd) {
@@ -1927,7 +1990,7 @@ function calculateItemsInView(ctx, state, params = {}) {
     }
     const idsInView = [];
     for (let i = firstFullyOnScreenIndex; i <= endNoBuffer; i++) {
-      const id = (_f = idCache.get(i)) != null ? _f : getId(state, i);
+      const id = (_f = idCache[i]) != null ? _f : getId(state, i);
       idsInView.push(id);
     }
     Object.assign(state, {
@@ -1959,7 +2022,7 @@ function calculateItemsInView(ctx, state, params = {}) {
       let numContainers2 = prevNumContainers;
       const needNewContainers = [];
       for (let i = startBuffered; i <= endBuffered; i++) {
-        const id = (_g = idCache.get(i)) != null ? _g : getId(state, i);
+        const id = (_g = idCache[i]) != null ? _g : getId(state, i);
         if (!containerItemKeys.has(id)) {
           needNewContainers.push(i);
         }
@@ -1970,7 +2033,7 @@ function calculateItemsInView(ctx, state, params = {}) {
           state,
           stickyIndicesSet,
           stickyIndicesArr,
-          scroll,
+          currentStickyIdx,
           needNewContainers,
           startBuffered,
           endBuffered
@@ -1996,7 +2059,7 @@ function calculateItemsInView(ctx, state, params = {}) {
         for (let idx = 0; idx < needNewContainers.length; idx++) {
           const i = needNewContainers[idx];
           const containerIndex = availableContainers[idx];
-          const id = (_h = idCache.get(i)) != null ? _h : getId(state, i);
+          const id = (_h = idCache[i]) != null ? _h : getId(state, i);
           const oldKey = peek$(ctx, `containerItemKey${containerIndex}`);
           if (oldKey && oldKey !== id) {
             containerItemKeys.delete(oldKey);
@@ -2010,7 +2073,7 @@ function calculateItemsInView(ctx, state, params = {}) {
           if (stickyIndicesSet.has(i)) {
             set$(ctx, `containerSticky${containerIndex}`, true);
             const topPadding = (peek$(ctx, "stylePaddingTop") || 0) + (peek$(ctx, "headerSize") || 0);
-            set$(ctx, `containerStickyOffset${containerIndex}`, new Animated.Value(topPadding));
+            set$(ctx, `containerStickyOffset${containerIndex}`, topPadding);
             state.stickyContainerPool.add(containerIndex);
           } else {
             set$(ctx, `containerSticky${containerIndex}`, false);
@@ -2029,7 +2092,7 @@ function calculateItemsInView(ctx, state, params = {}) {
       }
     }
     if (stickyIndicesArr.length > 0) {
-      handleStickyRecycling(ctx, state, stickyIndicesArr, scroll, scrollBuffer, pendingRemoval);
+      handleStickyRecycling(ctx, state, stickyIndicesArr, scroll, scrollBuffer, currentStickyIdx, pendingRemoval);
     }
     for (let i = 0; i < numContainers; i++) {
       const itemKey = peek$(ctx, `containerItemKey${i}`);
@@ -2051,7 +2114,7 @@ function calculateItemsInView(ctx, state, params = {}) {
         const itemIndex = indexByKey.get(itemKey);
         const item = data[itemIndex];
         if (item !== void 0) {
-          const id = (_i = idCache.get(itemIndex)) != null ? _i : getId(state, itemIndex);
+          const id = (_i = idCache[itemIndex]) != null ? _i : getId(state, itemIndex);
           const position = positions.get(id);
           if (position === void 0) {
             set$(ctx, `containerPosition${i}`, POSITION_OUT_OF_VIEW);
@@ -2081,6 +2144,12 @@ function calculateItemsInView(ctx, state, params = {}) {
     if (viewabilityConfigCallbackPairs) {
       updateViewableItems(state, ctx, viewabilityConfigCallbackPairs, scrollLength, startNoBuffer, endNoBuffer);
     }
+    if (onStickyHeaderChange && stickyIndicesArr.length > 0 && nextActiveStickyIndex !== void 0 && nextActiveStickyIndex !== previousStickyIndex) {
+      const item = data[nextActiveStickyIndex];
+      if (item !== void 0) {
+        onStickyHeaderChange({ index: nextActiveStickyIndex, item });
+      }
+    }
   });
 }
 
@@ -2239,7 +2308,9 @@ function doInitialAllocateContainers(ctx, state) {
       let totalSize = 0;
       const num = Math.min(20, data.length);
       for (let i = 0; i < num; i++) {
-        totalSize += fn(0, data[0], getItemType ? (_a = getItemType(data[0], 0)) != null ? _a : "" : "");
+        const item = data[i];
+        const itemType = getItemType ? (_a = getItemType(item, i)) != null ? _a : "" : "";
+        totalSize += fn(i, item, itemType);
       }
       averageItemSize = totalSize / num;
     } else {
@@ -2268,7 +2339,9 @@ function doInitialAllocateContainers(ctx, state) {
 // src/core/handleLayout.ts
 function handleLayout(ctx, state, layout, setCanRender) {
   const { maintainScrollAtEnd } = state.props;
-  const scrollLength = layout[state.props.horizontal ? "width" : "height"];
+  const measuredLength = layout[state.props.horizontal ? "width" : "height"];
+  const previousLength = state.scrollLength;
+  const scrollLength = measuredLength > 0 ? measuredLength : previousLength;
   const otherAxisSize = layout[state.props.horizontal ? "height" : "width"];
   const needsCalculate = !state.lastLayout || scrollLength > state.scrollLength || state.lastLayout.x !== layout.x || state.lastLayout.y !== layout.y;
   state.lastLayout = layout;
@@ -2279,7 +2352,9 @@ function handleLayout(ctx, state, layout, setCanRender) {
     state.otherAxisSize = otherAxisSize;
     state.lastBatchingAction = Date.now();
     state.scrollForNextCalculateItemsInView = void 0;
-    doInitialAllocateContainers(ctx, state);
+    if (scrollLength > 0) {
+      doInitialAllocateContainers(ctx, state);
+    }
     if (needsCalculate) {
       calculateItemsInView(ctx, state, { doMVCP: true });
     }
@@ -2295,14 +2370,14 @@ function handleLayout(ctx, state, layout, setCanRender) {
     if (state) {
       state.needsOtherAxisSize = otherAxisSize - (state.props.stylePaddingTop || 0) < 10;
     }
-    if (__DEV__ && scrollLength === 0) {
+    if (__DEV__ && measuredLength === 0) {
       warnDevOnce(
         "height0",
         `List ${state.props.horizontal ? "width" : "height"} is 0. You may need to set a style or \`flex: \` for the list, because children are absolutely positioned.`
       );
     }
-    setCanRender(true);
   }
+  setCanRender(true);
 }
 
 // src/core/onScroll.ts
@@ -2362,7 +2437,7 @@ var ScrollAdjustHandler = class {
     this.context = ctx;
   }
   requestAdjust(add) {
-    const oldAdjustTop = peek$(this.context, "scrollAdjust") || 0;
+    const oldAdjustTop = this.appliedAdjust;
     this.appliedAdjust = add + oldAdjustTop;
     const set = () => set$(this.context, "scrollAdjust", this.appliedAdjust);
     if (this.mounted) {
@@ -2381,7 +2456,7 @@ var ScrollAdjustHandler = class {
 
 // src/core/updateItemSize.ts
 function updateItemSize(ctx, state, itemKey, sizeObj) {
-  var _a, _b;
+  var _a;
   const {
     sizesKnown,
     props: {
@@ -2396,17 +2471,17 @@ function updateItemSize(ctx, state, itemKey, sizeObj) {
     }
   } = state;
   if (!data) return;
+  const index = state.indexByKey.get(itemKey);
   if (getFixedItemSize) {
-    const index2 = state.indexByKey.get(itemKey);
-    if (index2 === void 0) {
+    if (index === void 0) {
       return;
     }
-    const itemData = state.props.data[index2];
+    const itemData = state.props.data[index];
     if (itemData === void 0) {
       return;
     }
-    const type = getItemType ? (_a = getItemType(itemData, index2)) != null ? _a : "" : "";
-    const size2 = getFixedItemSize(index2, itemData, type);
+    const type = getItemType ? (_a = getItemType(itemData, index)) != null ? _a : "" : "";
+    const size2 = getFixedItemSize(index, itemData, type);
     if (size2 !== void 0 && size2 === sizesKnown.get(itemKey)) {
       return;
     }
@@ -2416,15 +2491,11 @@ function updateItemSize(ctx, state, itemKey, sizeObj) {
   let shouldMaintainScrollAtEnd = false;
   let minIndexSizeChanged;
   let maxOtherAxisSize = peek$(ctx, "otherAxisSize") || 0;
-  const index = state.indexByKey.get(itemKey);
   const prevSizeKnown = state.sizesKnown.get(itemKey);
   const diff = updateOneItemSize(state, itemKey, sizeObj);
   const size = Math.floor((horizontal ? sizeObj.width : sizeObj.height) * 8) / 8;
   if (diff !== 0) {
     minIndexSizeChanged = minIndexSizeChanged !== void 0 ? Math.min(minIndexSizeChanged, index) : index;
-    if (((_b = state.scrollingTo) == null ? void 0 : _b.viewPosition) && maintainVisibleContentPosition && index === state.scrollingTo.index && diff > 0) {
-      requestAdjust(ctx, state, diff * state.scrollingTo.viewPosition);
-    }
     const { startBuffered, endBuffered } = state;
     needsRecalculate || (needsRecalculate = index >= startBuffered && index <= endBuffered);
     if (!needsRecalculate) {
@@ -2556,18 +2627,59 @@ function getRenderedItem(ctx, state, key) {
     return null;
   }
   let renderedItem = null;
-  if (renderItem && data[index]) {
+  const extraData = peek$(ctx, "extraData");
+  const item = data[index];
+  if (renderItem && !isNullOrUndefined(item)) {
     const itemProps = {
       data,
-      extraData: peek$(ctx, "extraData"),
+      extraData,
       index,
-      item: data[index],
-      type: getItemType ? (_a = getItemType(data[index], index)) != null ? _a : "" : ""
+      item,
+      type: getItemType ? (_a = getItemType(item, index)) != null ? _a : "" : ""
     };
-    renderedItem = isFunction(renderItem) ? renderItem(itemProps) : React2__default.createElement(renderItem, itemProps);
+    renderedItem = isFunction(renderItem) ? renderItem(itemProps) : React3__default.createElement(renderItem, itemProps);
   }
   return { index, item: data[index], renderedItem };
 }
+function useThrottleDebounce(mode) {
+  const timeoutRef = useRef(null);
+  const lastCallTimeRef = useRef(0);
+  const lastArgsRef = useRef(null);
+  const clearTimeoutRef = () => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+  };
+  const execute = useCallback(
+    (callback, delay, ...args) => {
+      {
+        const now = Date.now();
+        lastArgsRef.current = args;
+        if (now - lastCallTimeRef.current >= delay) {
+          lastCallTimeRef.current = now;
+          callback(...args);
+          clearTimeoutRef();
+        } else {
+          clearTimeoutRef();
+          timeoutRef.current = setTimeout(
+            () => {
+              if (lastArgsRef.current) {
+                lastCallTimeRef.current = Date.now();
+                callback(...lastArgsRef.current);
+                timeoutRef.current = null;
+                lastArgsRef.current = null;
+              }
+            },
+            delay - (now - lastCallTimeRef.current)
+          );
+        }
+      }
+    },
+    [mode]
+  );
+  return execute;
+}
 
 // src/utils/throttledOnScroll.ts
 function useThrottledOnScroll(originalHandler, scrollEventThrottle) {
@@ -2584,14 +2696,14 @@ var LegendList = typedMemo(
     const isChildrenMode = children !== void 0 && dataProp === void 0;
     const processedProps = isChildrenMode ? {
       ...restProps,
-      data: (isArray(children) ? children : React2.Children.toArray(children)).flat(1),
+      data: (isArray(children) ? children : React3.Children.toArray(children)).flat(1),
       renderItem: ({ item }) => item
     } : {
       ...restProps,
       data: dataProp || [],
       renderItem: renderItemProp
     };
-    return /* @__PURE__ */ React2.createElement(StateProvider, null, /* @__PURE__ */ React2.createElement(LegendListInner, { ...processedProps, ref: forwardedRef }));
+    return /* @__PURE__ */ React3.createElement(StateProvider, null, /* @__PURE__ */ React3.createElement(LegendListInner, { ...processedProps, ref: forwardedRef }));
   })
 );
 var LegendListInner = typedForwardRef(function LegendListInner2(props, forwardedRef) {
@@ -2631,6 +2743,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     onScroll: onScrollProp,
     onStartReached,
     onStartReachedThreshold = 0.5,
+    onStickyHeaderChange,
     onViewableItemsChanged,
     progressViewOffset,
     recycleItems = false,
@@ -2650,7 +2763,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   } = props;
   const [renderNum, setRenderNum] = useState(0);
   const initialScroll = initialScrollIndexProp || initialScrollOffsetProp ? typeof initialScrollIndexProp === "object" ? { index: initialScrollIndexProp.index || 0, viewOffset: initialScrollIndexProp.viewOffset || 0 } : { index: initialScrollIndexProp || 0, viewOffset: initialScrollOffsetProp || 0 } : void 0;
-  const [canRender, setCanRender] = React2.useState(!IsNewArchitecture);
+  const [canRender, setCanRender] = React3.useState(!IsNewArchitecture);
   const contentContainerStyle = { ...StyleSheet.flatten(contentContainerStyleProp) };
   const style = { ...StyleSheet.flatten(styleProp) };
   const stylePaddingTopState = extractPadding(style, contentContainerStyle, "Top");
@@ -2664,60 +2777,63 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const keyExtractor = keyExtractorProp != null ? keyExtractorProp : (_item, index) => index.toString();
   const refState = useRef();
   if (!refState.current) {
-    const initialScrollLength = (estimatedListSize != null ? estimatedListSize : IsNewArchitecture ? { height: 0, width: 0 } : Dimensions.get("window"))[horizontal ? "width" : "height"];
-    refState.current = {
-      activeStickyIndex: void 0,
-      averageSizes: {},
-      columns: /* @__PURE__ */ new Map(),
-      containerItemKeys: /* @__PURE__ */ new Set(),
-      containerItemTypes: /* @__PURE__ */ new Map(),
-      dataChangeNeedsScrollUpdate: false,
-      enableScrollForNextCalculateItemsInView: true,
-      endBuffered: -1,
-      endNoBuffer: -1,
-      endReachedBlockedByTimer: false,
-      firstFullyOnScreenIndex: -1,
-      idCache: /* @__PURE__ */ new Map(),
-      idsInView: [],
-      indexByKey: /* @__PURE__ */ new Map(),
-      initialScroll,
-      isAtEnd: false,
-      isAtStart: false,
-      isEndReached: false,
-      isStartReached: false,
-      lastBatchingAction: Date.now(),
-      lastLayout: void 0,
-      loadStartTime: Date.now(),
-      minIndexSizeChanged: 0,
-      nativeMarginTop: 0,
-      positions: /* @__PURE__ */ new Map(),
-      props: {},
-      queuedCalculateItemsInView: 0,
-      refScroller: void 0,
-      scroll: 0,
-      scrollAdjustHandler: new ScrollAdjustHandler(ctx),
-      scrollForNextCalculateItemsInView: void 0,
-      scrollHistory: [],
-      scrollLength: initialScrollLength,
-      scrollPending: 0,
-      scrollPrev: 0,
-      scrollPrevTime: 0,
-      scrollProcessingEnabled: true,
-      scrollTime: 0,
-      sizes: /* @__PURE__ */ new Map(),
-      sizesKnown: /* @__PURE__ */ new Map(),
-      startBuffered: -1,
-      startNoBuffer: -1,
-      startReachedBlockedByTimer: false,
-      stickyContainerPool: /* @__PURE__ */ new Set(),
-      stickyContainers: /* @__PURE__ */ new Map(),
-      timeoutSizeMessage: 0,
-      timeouts: /* @__PURE__ */ new Set(),
-      totalSize: 0,
-      viewabilityConfigCallbackPairs: void 0
-    };
-    set$(ctx, "maintainVisibleContentPosition", maintainVisibleContentPosition);
-    set$(ctx, "extraData", extraData);
+    if (!ctx.internalState) {
+      const initialScrollLength = (estimatedListSize != null ? estimatedListSize : IsNewArchitecture ? { height: 0, width: 0 } : Dimensions.get("window"))[horizontal ? "width" : "height"];
+      ctx.internalState = {
+        activeStickyIndex: void 0,
+        averageSizes: {},
+        columns: /* @__PURE__ */ new Map(),
+        containerItemKeys: /* @__PURE__ */ new Set(),
+        containerItemTypes: /* @__PURE__ */ new Map(),
+        dataChangeNeedsScrollUpdate: false,
+        enableScrollForNextCalculateItemsInView: true,
+        endBuffered: -1,
+        endNoBuffer: -1,
+        endReachedBlockedByTimer: false,
+        firstFullyOnScreenIndex: -1,
+        idCache: [],
+        idsInView: [],
+        indexByKey: /* @__PURE__ */ new Map(),
+        initialScroll,
+        isAtEnd: false,
+        isAtStart: false,
+        isEndReached: false,
+        isStartReached: false,
+        lastBatchingAction: Date.now(),
+        lastLayout: void 0,
+        loadStartTime: Date.now(),
+        minIndexSizeChanged: 0,
+        nativeMarginTop: 0,
+        positions: /* @__PURE__ */ new Map(),
+        props: {},
+        queuedCalculateItemsInView: 0,
+        refScroller: void 0,
+        scroll: 0,
+        scrollAdjustHandler: new ScrollAdjustHandler(ctx),
+        scrollForNextCalculateItemsInView: void 0,
+        scrollHistory: [],
+        scrollLength: initialScrollLength,
+        scrollPending: 0,
+        scrollPrev: 0,
+        scrollPrevTime: 0,
+        scrollProcessingEnabled: true,
+        scrollTime: 0,
+        sizes: /* @__PURE__ */ new Map(),
+        sizesKnown: /* @__PURE__ */ new Map(),
+        startBuffered: -1,
+        startNoBuffer: -1,
+        startReachedBlockedByTimer: false,
+        stickyContainerPool: /* @__PURE__ */ new Set(),
+        stickyContainers: /* @__PURE__ */ new Map(),
+        timeoutSizeMessage: 0,
+        timeouts: /* @__PURE__ */ new Set(),
+        totalSize: 0,
+        viewabilityConfigCallbackPairs: void 0
+      };
+      set$(ctx, "maintainVisibleContentPosition", maintainVisibleContentPosition);
+      set$(ctx, "extraData", extraData);
+    }
+    refState.current = ctx.internalState;
   }
   const state = refState.current;
   const isFirst = !state.props.renderItem;
@@ -2750,6 +2866,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     onScroll: throttleScrollFn,
     onStartReached,
     onStartReachedThreshold,
+    onStickyHeaderChange,
     recycleItems: !!recycleItems,
     renderItem,
     scrollBuffer,
@@ -2800,7 +2917,13 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       }
       refState.current.isStartReached = initialContentOffset2 < refState.current.scrollLength * onStartReachedThreshold;
       if (initialContentOffset2 > 0) {
-        scrollTo(state, { animated: false, index, offset: initialContentOffset2 });
+        scrollTo(state, {
+          animated: false,
+          index,
+          isInitialScroll: true,
+          offset: initialContentOffset2,
+          viewPosition: index === dataProp.length - 1 ? 1 : 0
+        });
       }
       return initialContentOffset2;
     }
@@ -2838,7 +2961,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     }
   }, [snapToIndices]);
   useLayoutEffect(() => {
-    const didAllocateContainers = dataProp.length > 0 && doInitialAllocateContainersCallback();
+    const didAllocateContainers = dataProp.length > 0 && doInitialAllocateContainers(ctx, state);
     if (!didAllocateContainers) {
       checkResetContainers(
         ctx,
@@ -2852,30 +2975,12 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   useLayoutEffect(() => {
     set$(ctx, "extraData", extraData);
   }, [extraData]);
-  useLayoutEffect(() => {
-    var _a2;
-    if (IsNewArchitecture) {
-      let measured;
-      (_a2 = refScroller.current) == null ? void 0 : _a2.measure((x, y, width, height) => {
-        measured = { height, width, x, y };
-      });
-      if (measured) {
-        const size = Math.floor(measured[horizontal ? "width" : "height"] * 8) / 8;
-        if (size) {
-          handleLayout(ctx, state, measured, setCanRender);
-        }
-      }
-    }
-  }, []);
   useLayoutEffect(initializeStateVars, [
     memoizedLastItemKeys.join(","),
     numColumnsProp,
     stylePaddingTopState,
     stylePaddingBottomState
   ]);
-  const doInitialAllocateContainersCallback = () => {
-    return doInitialAllocateContainers(ctx, state);
-  };
   useEffect(() => {
     const viewability = setupViewability({
       onViewableItemsChanged,
@@ -2887,16 +2992,18 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   }, [viewabilityConfig, viewabilityConfigCallbackPairs, onViewableItemsChanged]);
   if (!IsNewArchitecture) {
     useInit(() => {
-      doInitialAllocateContainersCallback();
+      doInitialAllocateContainers(ctx, state);
     });
   }
-  const onLayout = useCallback((event) => {
-    const layout = event.nativeEvent.layout;
+  const onLayoutChange = useCallback((layout) => {
     handleLayout(ctx, state, layout, setCanRender);
-    if (onLayoutProp) {
-      onLayoutProp(event);
-    }
   }, []);
+  const { onLayout } = useOnLayoutSync({
+    onLayoutChange,
+    onLayoutProp,
+    ref: refScroller
+    // the type of ScrollView doesn't include measure?
+  });
   useImperativeHandle(forwardedRef, () => {
     const scrollIndexIntoView = (options) => {
       const state2 = refState.current;
@@ -3005,7 +3112,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     }
     return onScrollFn;
   }, [stickyIndices == null ? void 0 : stickyIndices.length, horizontal, scrollEventThrottle]);
-  return /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement(
+  return /* @__PURE__ */ React3.createElement(React3.Fragment, null, /* @__PURE__ */ React3.createElement(
     ListComponent,
     {
       ...rest,
@@ -3036,9 +3143,9 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       },
       onScroll: onScrollHandler,
       recycleItems,
-      refreshControl: refreshControl ? stylePaddingTopState > 0 ? React2.cloneElement(refreshControl, {
+      refreshControl: refreshControl ? stylePaddingTopState > 0 ? React3.cloneElement(refreshControl, {
         progressViewOffset: (refreshControl.props.progressViewOffset || 0) + stylePaddingTopState
-      }) : refreshControl : onRefresh && /* @__PURE__ */ React2.createElement(
+      }) : refreshControl : onRefresh && /* @__PURE__ */ React3.createElement(
         RefreshControl,
         {
           onRefresh,
@@ -3055,7 +3162,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       updateItemSize: fns.updateItemSize,
       waitForInitialLayout
     }
-  ), __DEV__ && ENABLE_DEBUG_VIEW && /* @__PURE__ */ React2.createElement(DebugView, { state: refState.current }));
+  ), __DEV__ && ENABLE_DEBUG_VIEW && /* @__PURE__ */ React3.createElement(DebugView, { state: refState.current }));
 });
 
 export { LegendList, useIsLastItem, useListScrollSize, useRecyclingEffect, useRecyclingState, useSyncLayout, useViewability, useViewabilityAmount };