@legendapp/list 3.3.1 → 3.3.3

package/react-native.mjs

@@ -1,5 +1,5 @@
 import * as React2 from 'react';
-import { useReducer, useEffect, createContext, useRef, useState, useMemo, useCallback, useLayoutEffect, useImperativeHandle, useContext } from 'react';
+import { useReducer, useEffect, createContext, useRef, useMemo, useCallback, useLayoutEffect, useImperativeHandle, useState, useContext } from 'react';
 import * as ReactNative from 'react-native';
 import { Animated, Platform as Platform$1, View as View$1, Text as Text$1, PixelRatio as PixelRatio$1, StyleSheet as StyleSheet$1, RefreshControl, Dimensions, I18nManager } from 'react-native';
 import { useSyncExternalStore } from 'use-sync-external-store/shim';
@@ -117,6 +117,7 @@ var createAnimatedValue = (value) => new Animated.Value(value);
 
 // src/state/state.tsx
 var ContextState = React2.createContext(null);
+var SIGNAL_NAMES_SEPARATOR = "\0";
 var contextNum = 0;
 function StateProvider({ children }) {
   const [value] = React2.useState(() => ({
@@ -130,11 +131,13 @@ function StateProvider({ children }) {
     mapViewabilityCallbacks: /* @__PURE__ */ new Map(),
     mapViewabilityConfigStates: /* @__PURE__ */ new Map(),
     mapViewabilityValues: /* @__PURE__ */ new Map(),
+    pendingContainerIds: void 0,
     positionListeners: /* @__PURE__ */ new Map(),
     scrollAxisGap: 0,
     state: void 0,
     values: /* @__PURE__ */ new Map([
       ["alignItemsAtEndPadding", 0],
+      ["containerLayoutEpoch", 0],
       ["stylePaddingTop", 0],
       ["headerSize", 0],
       ["numContainers", 0],
@@ -188,6 +191,12 @@ function createSelectorFunctionsArr(ctx, signalNames) {
     }
   };
 }
+function getSignalNamesKey(signalNames) {
+  return signalNames.length === 1 ? signalNames[0] : signalNames.join(SIGNAL_NAMES_SEPARATOR);
+}
+function getSignalNamesFromKey(signalNamesKey) {
+  return signalNamesKey.split(SIGNAL_NAMES_SEPARATOR);
+}
 function listen$(ctx, signalName, cb) {
   const { listeners } = ctx;
   let setListeners = listeners.get(signalName);
@@ -235,7 +244,11 @@ function notifyPosition$(ctx, key, value) {
 }
 function useArr$(signalNames) {
   const ctx = React2.useContext(ContextState);
-  const { subscribe, get } = React2.useMemo(() => createSelectorFunctionsArr(ctx, signalNames), [ctx, signalNames]);
+  const signalNamesKey = getSignalNamesKey(signalNames);
+  const { subscribe, get } = React2.useMemo(
+    () => createSelectorFunctionsArr(ctx, getSignalNamesFromKey(signalNamesKey)),
+    [ctx, signalNamesKey]
+  );
   const value = useSyncExternalStore(subscribe, get, get);
   return value;
 }
@@ -349,28 +362,49 @@ function useInterval(callback, delay) {
   }, [delay]);
 }
 
-// src/components/stickyPositionUtils.ts
-function getStickyPushLimit(state, index, itemKey) {
-  if (!itemKey) {
-    return void 0;
-  }
-  const currentSize = state.sizes.get(itemKey);
-  if (!(currentSize && currentSize > 0)) {
-    return void 0;
+// src/constants-platform.native.ts
+var f = global.nativeFabricUIManager;
+var IsNewArchitecture = f !== void 0 && f != null;
+
+// src/core/containerItemMetadata.ts
+function createContainerItemMetadata(state, itemIndex, itemData, itemType) {
+  return {
+    dataChangeEpoch: state.dataChangeEpoch,
+    getFixedItemSize: state.props.getFixedItemSize,
+    getItemType: state.props.getItemType,
+    itemData,
+    itemIndex,
+    itemType
+  };
+}
+function resolveContainerItemMetadata(state, containerId, itemIndex, itemData) {
+  var _a3, _b;
+  const { getFixedItemSize, getItemType } = state.props;
+  const previousMetadata = state.containerItemMetadata.get(containerId);
+  let metadata;
+  if ((previousMetadata == null ? void 0 : previousMetadata.dataChangeEpoch) === state.dataChangeEpoch && previousMetadata.getItemType === getItemType && previousMetadata.itemData === itemData && previousMetadata.itemIndex === itemIndex) {
+    metadata = previousMetadata;
+  } else {
+    const itemType = getItemType ? (_a3 = getItemType(itemData, itemIndex)) != null ? _a3 : "" : void 0;
+    metadata = createContainerItemMetadata(state, itemIndex, itemData, itemType);
+    state.containerItemMetadata.set(containerId, metadata);
   }
-  const stickyIndexInArray = state.props.stickyHeaderIndicesArr.indexOf(index);
-  if (stickyIndexInArray === -1) {
-    return void 0;
+  if (metadata.getFixedItemSize !== getFixedItemSize) {
+    metadata.didResolveFixedItemSize = false;
+    metadata.fixedItemSize = void 0;
+    metadata.getFixedItemSize = getFixedItemSize;
   }
-  const nextStickyIndex = state.props.stickyHeaderIndicesArr[stickyIndexInArray + 1];
-  if (nextStickyIndex === void 0) {
-    return void 0;
+  if (getFixedItemSize && !metadata.didResolveFixedItemSize) {
+    metadata.fixedItemSize = getFixedItemSize(itemData, itemIndex, (_b = metadata.itemType) != null ? _b : "");
+    metadata.didResolveFixedItemSize = true;
   }
-  const nextStickyPosition = state.positions[nextStickyIndex];
-  if (nextStickyPosition === void 0) {
-    return void 0;
+  return metadata;
+}
+function invalidateContainerFixedItemSizes(state) {
+  for (const metadata of state.containerItemMetadata.values()) {
+    metadata.didResolveFixedItemSize = false;
+    metadata.fixedItemSize = void 0;
   }
-  return nextStickyPosition - currentSize;
 }
 
 // src/utils/devEnvironment.ts
@@ -387,445 +421,73 @@ var EDGE_POSITION_EPSILON = 1;
 var ENABLE_DEVMODE = IS_DEV && false;
 var ENABLE_DEBUG_VIEW = IS_DEV && false;
 
-// src/constants-platform.native.ts
-var f = global.nativeFabricUIManager;
-var IsNewArchitecture = f !== void 0 && f != null;
-var useAnimatedValue = (initialValue) => {
-  const [animAnimatedValue] = useState(() => new Animated.Value(initialValue));
-  return animAnimatedValue;
-};
-
-// src/hooks/useValue$.ts
-function useValue$(key, params) {
-  const { getValue } = params || {};
-  const ctx = useStateContext();
-  const getNewValue = () => {
-    var _a3;
-    return (_a3 = getValue ? getValue(peek$(ctx, key)) : peek$(ctx, key)) != null ? _a3 : 0;
+// src/core/deferredPublicOnScroll.ts
+function withResolvedContentOffset(state, event, resolvedOffset) {
+  return {
+    ...event,
+    nativeEvent: {
+      ...event.nativeEvent,
+      contentOffset: state.props.horizontal ? { x: resolvedOffset, y: 0 } : { x: 0, y: resolvedOffset }
+    }
   };
-  const animValue = useAnimatedValue(getNewValue());
-  useLayoutEffect(() => {
-    const syncCurrentValue = () => {
-      animValue.setValue(getNewValue());
-    };
-    const unsubscribe = listen$(ctx, key, syncCurrentValue);
-    syncCurrentValue();
-    return unsubscribe;
-  }, [animValue, ctx, key]);
-  return animValue;
 }
-var typedForwardRef = React2.forwardRef;
-var typedMemo = React2.memo;
-var getComponent = (Component) => {
-  if (React2.isValidElement(Component)) {
-    return Component;
-  }
-  if (Component) {
-    return /* @__PURE__ */ React2.createElement(Component, null);
-  }
-  return null;
-};
-
-// src/components/PositionView.native.tsx
-var PositionViewState = typedMemo(function PositionViewState2({
-  id,
-  horizontal,
-  style,
-  refView,
-  ...rest
-}) {
-  const [position = POSITION_OUT_OF_VIEW, _itemKey] = useArr$([`containerPosition${id}`, `containerItemKey${id}`]);
-  return /* @__PURE__ */ React2.createElement(View$1, { ref: refView, style: [style, horizontal ? { left: position } : { top: position }], ...rest });
-});
-var PositionViewAnimated = typedMemo(function PositionViewAnimated2({
-  id,
-  horizontal,
-  style,
-  refView,
-  ...rest
-}) {
-  const position$ = useValue$(`containerPosition${id}`, {
-    getValue: (v) => v != null ? v : POSITION_OUT_OF_VIEW
-  });
-  const position = horizontal ? { left: position$ } : { top: position$ };
-  return /* @__PURE__ */ React2.createElement(Animated.View, { ref: refView, style: [style, position], ...rest });
-});
-var PositionViewSticky = typedMemo(function PositionViewSticky2({
-  id,
-  horizontal,
-  style,
-  refView,
-  animatedScrollY,
-  index,
-  stickyHeaderConfig,
-  children,
-  ...rest
-}) {
-  const ctx = useStateContext();
-  const [
-    position = POSITION_OUT_OF_VIEW,
-    alignItemsAtEndPadding = 0,
-    headerSize = 0,
-    stylePaddingTop = 0,
-    itemKey,
-    _totalSize = 0
-  ] = useArr$([
-    `containerPosition${id}`,
-    "alignItemsAtEndPadding",
-    "headerSize",
-    "stylePaddingTop",
-    `containerItemKey${id}`,
-    "totalSize"
-  ]);
-  const pushLimit = React2.useMemo(
-    () => getStickyPushLimit(ctx.state, index, itemKey),
-    [ctx.state, index, itemKey, _totalSize]
-  );
-  const transform = React2.useMemo(() => {
-    var _a3;
-    if (animatedScrollY) {
-      const stickyConfigOffset = (_a3 = stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.offset) != null ? _a3 : 0;
-      const stickyStart = position + headerSize + stylePaddingTop + alignItemsAtEndPadding - stickyConfigOffset;
-      let nextStickyPosition;
-      if (pushLimit !== void 0) {
-        if (pushLimit <= position) {
-          nextStickyPosition = pushLimit;
-        } else {
-          nextStickyPosition = animatedScrollY.interpolate({
-            extrapolateLeft: "clamp",
-            extrapolateRight: "clamp",
-            inputRange: [stickyStart, stickyStart + (pushLimit - position)],
-            outputRange: [position, pushLimit]
-          });
-        }
-      } else {
-        nextStickyPosition = animatedScrollY.interpolate({
-          extrapolateLeft: "clamp",
-          extrapolateRight: "extend",
-          inputRange: [stickyStart, stickyStart + 5e3],
-          outputRange: [position, position + 5e3]
-        });
-      }
-      return horizontal ? [{ translateX: nextStickyPosition }] : [{ translateY: nextStickyPosition }];
-    }
-  }, [
-    alignItemsAtEndPadding,
-    animatedScrollY,
-    headerSize,
-    position,
-    pushLimit,
-    stylePaddingTop,
-    stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.offset
-  ]);
-  const viewStyle = React2.useMemo(() => [style, { zIndex: index + 1e3 }, { transform }], [style, transform]);
-  const renderStickyHeaderBackdrop = React2.useMemo(() => {
-    if (!(stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.backdropComponent)) {
-      return null;
-    }
-    return /* @__PURE__ */ React2.createElement(
-      View$1,
-      {
-        style: {
-          inset: 0,
-          pointerEvents: "none",
-          position: "absolute"
-        }
-      },
-      getComponent(stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.backdropComponent)
+function releaseDeferredPublicOnScroll(ctx, resolvedOffset) {
+  var _a3, _b, _c, _d;
+  const state = ctx.state;
+  const deferredEvent = state.deferredPublicOnScrollEvent;
+  state.deferredPublicOnScrollEvent = void 0;
+  if (deferredEvent) {
+    (_d = (_c = state.props).onScroll) == null ? void 0 : _d.call(
+      _c,
+      withResolvedContentOffset(
+        state,
+        deferredEvent,
+        (_b = (_a3 = resolvedOffset != null ? resolvedOffset : state.scrollPending) != null ? _a3 : state.scroll) != null ? _b : 0
+      )
     );
-  }, [stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.backdropComponent]);
-  return /* @__PURE__ */ React2.createElement(Animated.View, { ref: refView, style: viewStyle, ...rest }, renderStickyHeaderBackdrop, children);
-});
-var PositionView = IsNewArchitecture ? PositionViewState : PositionViewAnimated;
-function useInit(cb) {
-  useState(() => cb());
+  }
 }
 
-// src/utils/helpers.ts
-function isFunction(obj) {
-  return typeof obj === "function";
-}
-function isArray(obj) {
-  return Array.isArray(obj);
+// src/core/initialScrollSession.ts
+var INITIAL_SCROLL_MIN_TARGET_OFFSET = 1;
+function hasInitialScrollSessionCompletion(completion) {
+  return !!((completion == null ? void 0 : completion.didDispatchNativeScroll) || (completion == null ? void 0 : completion.didRetrySilentInitialScroll) || (completion == null ? void 0 : completion.watchdog));
 }
-var warned = /* @__PURE__ */ new Set();
-function warnDevOnce(id, text) {
-  if (IS_DEV && !warned.has(id)) {
-    warned.add(id);
-    console.warn(`[legend-list] ${text}`);
-  }
+function clearInitialScrollSession(state) {
+  state.initialScrollSession = void 0;
+  return void 0;
 }
-function roundSize(size) {
-  return Math.floor(size * 8) / 8;
+function createInitialScrollSession(options) {
+  const { bootstrap, completion, kind, previousDataLength } = options;
+  return kind === "offset" ? {
+    completion,
+    kind,
+    previousDataLength
+  } : {
+    bootstrap,
+    completion,
+    kind,
+    previousDataLength
+  };
 }
-function isNullOrUndefined(value) {
-  return value === null || value === void 0;
-}
-function getPadding(s, type) {
-  var _a3, _b, _c;
-  const axisPadding = type === "Left" || type === "Right" ? s.paddingHorizontal : s.paddingVertical;
-  return (_c = (_b = (_a3 = s[`padding${type}`]) != null ? _a3 : axisPadding) != null ? _b : s.padding) != null ? _c : 0;
-}
-function extractPadding(style, contentContainerStyle, type) {
-  return getPadding(style, type) + getPadding(contentContainerStyle, type);
-}
-function findContainerId(ctx, key) {
-  var _a3, _b;
-  const directMatch = (_b = (_a3 = ctx.state) == null ? void 0 : _a3.containerItemKeys) == null ? void 0 : _b.get(key);
-  if (directMatch !== void 0) {
-    return directMatch;
-  }
-  const numContainers = peek$(ctx, "numContainers");
-  for (let i = 0; i < numContainers; i++) {
-    const itemKey = peek$(ctx, `containerItemKey${i}`);
-    if (itemKey === key) {
-      return i;
-    }
-  }
-  return -1;
-}
-
-// src/state/ContextContainer.ts
-var ContextContainer = createContext(null);
-function useContextContainer() {
-  return useContext(ContextContainer);
-}
-function useAdaptiveRender() {
-  const [mode] = useArr$(["adaptiveRender"]);
-  return mode;
-}
-function useAdaptiveRenderChange(callback) {
-  const ctx = useStateContext();
-  const callbackRef = useRef(callback);
-  callbackRef.current = callback;
-  useLayoutEffect(() => {
-    let mode = peek$(ctx, "adaptiveRender");
-    return listen$(ctx, "adaptiveRender", (nextMode) => {
-      if (mode !== nextMode) {
-        mode = nextMode;
-        callbackRef.current(nextMode);
-      }
-    });
-  }, [ctx]);
-}
-function useViewability(callback, configId) {
-  const ctx = useStateContext();
-  const containerContext = useContextContainer();
-  useInit(() => {
-    if (!containerContext) {
-      return;
-    }
-    const { containerId } = containerContext;
-    const key = containerId + (configId != null ? configId : "");
-    const value = ctx.mapViewabilityValues.get(key);
-    if (value) {
-      callback(value);
-    }
-  });
-  useEffect(() => {
-    if (!containerContext) {
-      return;
-    }
-    const { containerId } = containerContext;
-    const key = containerId + (configId != null ? configId : "");
-    ctx.mapViewabilityCallbacks.set(key, callback);
-    return () => {
-      ctx.mapViewabilityCallbacks.delete(key);
-    };
-  }, [ctx, callback, configId, containerContext]);
-}
-function useViewabilityAmount(callback) {
-  const ctx = useStateContext();
-  const containerContext = useContextContainer();
-  useInit(() => {
-    if (!containerContext) {
-      return;
-    }
-    const { containerId } = containerContext;
-    const value = ctx.mapViewabilityAmountValues.get(containerId);
-    if (value) {
-      callback(value);
-    }
-  });
-  useEffect(() => {
-    if (!containerContext) {
-      return;
-    }
-    const { containerId } = containerContext;
-    ctx.mapViewabilityAmountCallbacks.set(containerId, callback);
-    return () => {
-      ctx.mapViewabilityAmountCallbacks.delete(containerId);
-    };
-  }, [ctx, callback, containerContext]);
-}
-function useRecyclingEffect(effect) {
-  const containerContext = useContextContainer();
-  const prevValues = useRef({
-    prevIndex: void 0,
-    prevItem: void 0
-  });
-  useEffect(() => {
-    if (!containerContext) {
-      return;
-    }
-    const { index, value } = containerContext;
-    let ret;
-    if (prevValues.current.prevIndex !== void 0 && prevValues.current.prevItem !== void 0) {
-      ret = effect({
-        index,
-        item: value,
-        prevIndex: prevValues.current.prevIndex,
-        prevItem: prevValues.current.prevItem
-      });
-    }
-    prevValues.current = {
-      prevIndex: index,
-      prevItem: value
-    };
-    return ret;
-  }, [effect, containerContext]);
-}
-function useRecyclingState(valueOrFun) {
-  var _a3, _b;
-  const containerContext = useContextContainer();
-  const computeValue = (ctx) => {
-    if (isFunction(valueOrFun)) {
-      const initializer = valueOrFun;
-      return ctx ? initializer({
-        index: ctx.index,
-        item: ctx.value,
-        prevIndex: void 0,
-        prevItem: void 0
-      }) : initializer();
-    }
-    return valueOrFun;
-  };
-  const [stateValue, setStateValue] = useState(() => {
-    return computeValue(containerContext);
-  });
-  const prevItemKeyRef = useRef((_a3 = containerContext == null ? void 0 : containerContext.itemKey) != null ? _a3 : null);
-  const currentItemKey = (_b = containerContext == null ? void 0 : containerContext.itemKey) != null ? _b : null;
-  if (currentItemKey !== null && prevItemKeyRef.current !== currentItemKey) {
-    prevItemKeyRef.current = currentItemKey;
-    setStateValue(computeValue(containerContext));
-  }
-  const triggerLayout = containerContext == null ? void 0 : containerContext.triggerLayout;
-  const setState = useCallback(
-    (newState) => {
-      if (!triggerLayout) {
-        return;
-      }
-      setStateValue((prevValue) => {
-        return isFunction(newState) ? newState(prevValue) : newState;
-      });
-      triggerLayout();
-    },
-    [triggerLayout]
-  );
-  return [stateValue, setState];
-}
-function useIsLastItem() {
-  const containerContext = useContextContainer();
-  const isLast = useSelector$("lastItemKeys", (lastItemKeys) => {
-    if (containerContext) {
-      const { itemKey } = containerContext;
-      if (!isNullOrUndefined(itemKey)) {
-        return (lastItemKeys == null ? void 0 : lastItemKeys.includes(itemKey)) || false;
-      }
-    }
-    return false;
-  });
-  return isLast;
-}
-function useListScrollSize() {
-  const [scrollSize] = useArr$(["scrollSize"]);
-  return scrollSize;
-}
-var noop = () => {
-};
-function useSyncLayout() {
-  const containerContext = useContextContainer();
-  if (IsNewArchitecture && containerContext) {
-    const { triggerLayout: syncLayout } = containerContext;
-    return syncLayout;
-  } else {
-    return noop;
-  }
-}
-
-// src/components/Separator.tsx
-function Separator({ ItemSeparatorComponent, leadingItem }) {
-  const isLastItem = useIsLastItem();
-  return isLastItem ? null : /* @__PURE__ */ React2.createElement(ItemSeparatorComponent, { leadingItem });
-}
-
-// src/core/deferredPublicOnScroll.ts
-function withResolvedContentOffset(state, event, resolvedOffset) {
-  return {
-    ...event,
-    nativeEvent: {
-      ...event.nativeEvent,
-      contentOffset: state.props.horizontal ? { x: resolvedOffset, y: 0 } : { x: 0, y: resolvedOffset }
-    }
-  };
-}
-function releaseDeferredPublicOnScroll(ctx, resolvedOffset) {
-  var _a3, _b, _c, _d;
-  const state = ctx.state;
-  const deferredEvent = state.deferredPublicOnScrollEvent;
-  state.deferredPublicOnScrollEvent = void 0;
-  if (deferredEvent) {
-    (_d = (_c = state.props).onScroll) == null ? void 0 : _d.call(
-      _c,
-      withResolvedContentOffset(
-        state,
-        deferredEvent,
-        (_b = (_a3 = resolvedOffset != null ? resolvedOffset : state.scrollPending) != null ? _a3 : state.scroll) != null ? _b : 0
-      )
-    );
-  }
-}
-
-// src/core/initialScrollSession.ts
-var INITIAL_SCROLL_MIN_TARGET_OFFSET = 1;
-function hasInitialScrollSessionCompletion(completion) {
-  return !!((completion == null ? void 0 : completion.didDispatchNativeScroll) || (completion == null ? void 0 : completion.didRetrySilentInitialScroll) || (completion == null ? void 0 : completion.watchdog));
-}
-function clearInitialScrollSession(state) {
-  state.initialScrollSession = void 0;
-  return void 0;
-}
-function createInitialScrollSession(options) {
-  const { bootstrap, completion, kind, previousDataLength } = options;
-  return kind === "offset" ? {
-    completion,
-    kind,
-    previousDataLength
-  } : {
-    bootstrap,
-    completion,
-    kind,
-    previousDataLength
-  };
-}
-function ensureInitialScrollSessionCompletion(state, kind = ((_b) => (_b = ((_a3) => (_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind)()) != null ? _b : "bootstrap")()) {
-  var _a4, _b2;
-  if (!state.initialScrollSession) {
-    state.initialScrollSession = createInitialScrollSession({
-      completion: {},
-      kind,
-      previousDataLength: 0
-    });
-  } else if (state.initialScrollSession.kind !== kind) {
-    state.initialScrollSession = createInitialScrollSession({
-      bootstrap: state.initialScrollSession.kind === "bootstrap" ? state.initialScrollSession.bootstrap : void 0,
-      completion: state.initialScrollSession.completion,
-      kind,
-      previousDataLength: state.initialScrollSession.previousDataLength
-    });
-  }
-  (_b2 = (_a4 = state.initialScrollSession).completion) != null ? _b2 : _a4.completion = {};
-  return state.initialScrollSession.completion;
+function ensureInitialScrollSessionCompletion(state, kind = ((_b) => (_b = ((_a3) => (_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind)()) != null ? _b : "bootstrap")()) {
+  var _a4, _b2;
+  if (!state.initialScrollSession) {
+    state.initialScrollSession = createInitialScrollSession({
+      completion: {},
+      kind,
+      previousDataLength: 0
+    });
+  } else if (state.initialScrollSession.kind !== kind) {
+    state.initialScrollSession = createInitialScrollSession({
+      bootstrap: state.initialScrollSession.kind === "bootstrap" ? state.initialScrollSession.bootstrap : void 0,
+      completion: state.initialScrollSession.completion,
+      kind,
+      previousDataLength: state.initialScrollSession.previousDataLength
+    });
+  }
+  (_b2 = (_a4 = state.initialScrollSession).completion) != null ? _b2 : _a4.completion = {};
+  return state.initialScrollSession.completion;
 }
 var initialScrollCompletion = {
   didDispatchNativeScroll(state) {
@@ -906,7 +568,11 @@ function setInitialScrollSession(state, options = {}) {
 
 // src/utils/checkThreshold.ts
 var HYSTERESIS_MULTIPLIER = 1.3;
-var checkThreshold = (distance, atThreshold, threshold, wasReached, snapshot, context, onReached, setSnapshot, allowReentryOnChange) => {
+function isOutsideThresholdHysteresis(distance, atThreshold, threshold) {
+  const absDistance = Math.abs(distance);
+  return !atThreshold && threshold > 0 && absDistance >= threshold * HYSTERESIS_MULTIPLIER || !atThreshold && threshold <= 0 && absDistance > 0;
+}
+var checkThreshold = (distance, atThreshold, threshold, wasReached, snapshot, context, onReached, setSnapshot) => {
   const absDistance = Math.abs(distance);
   const within = atThreshold || threshold > 0 && absDistance <= threshold;
   const updateSnapshot = () => {
@@ -925,7 +591,7 @@ var checkThreshold = (distance, atThreshold, threshold, wasReached, snapshot, co
     updateSnapshot();
     return true;
   }
-  const reset = !atThreshold && threshold > 0 && absDistance >= threshold * HYSTERESIS_MULTIPLIER || !atThreshold && threshold <= 0 && absDistance > 0;
+  const reset = isOutsideThresholdHysteresis(distance, atThreshold, threshold);
   if (reset) {
     setSnapshot(void 0);
     return false;
@@ -933,35 +599,82 @@ var checkThreshold = (distance, atThreshold, threshold, wasReached, snapshot, co
   if (within) {
     const changed = !snapshot || snapshot.atThreshold !== atThreshold || snapshot.contentSize !== context.contentSize || snapshot.dataLength !== context.dataLength;
     if (changed) {
-      if (allowReentryOnChange) {
-        onReached(distance);
-      }
       updateSnapshot();
     }
   }
   return true;
 };
 
-// src/utils/hasActiveInitialScroll.ts
-function hasActiveInitialScroll(state) {
-  return !!(state == null ? void 0 : state.initialScroll) && !state.didFinishInitialScroll;
+// src/utils/edgeReachedGate.ts
+function resetEdgeLatch(ctx, edge) {
+  const state = ctx.state;
+  if (edge === "start") {
+    state.isStartReached = false;
+    state.startReachedSnapshot = void 0;
+  } else {
+    state.isEndReached = false;
+    state.endReachedSnapshot = void 0;
+  }
 }
-
-// src/utils/checkAtBottom.ts
-function checkAtBottom(ctx) {
-  var _a3;
+function resetSharedEdgeGateIfOutsideHysteresis(ctx) {
   const state = ctx.state;
-  if (!state) {
+  if (!state.edgeReachedGate) {
     return;
   }
-  const {
-    queuedInitialLayout,
-    scrollLength,
-    scroll,
-    maintainingScrollAtEnd,
-    props: { maintainScrollAtEndThreshold, onEndReachedThreshold }
-  } = state;
   const contentSize = getContentSize(ctx);
+  const endDistance = contentSize - state.scroll - state.scrollLength - getContentInsetEnd(ctx);
+  const isContentLess = contentSize < state.scrollLength;
+  const startThreshold = state.props.onStartReachedThreshold * state.scrollLength;
+  const endThreshold = state.props.onEndReachedThreshold * state.scrollLength;
+  const isOutsideStart = isOutsideThresholdHysteresis(state.scroll, false, startThreshold);
+  const isOutsideEnd = isOutsideThresholdHysteresis(endDistance, isContentLess, endThreshold);
+  if (isOutsideStart && isOutsideEnd) {
+    state.edgeReachedGate = void 0;
+  }
+}
+function canDispatchReachedEdge(ctx, edge, allowedEdge, allowGateCreatedInCurrentCheck) {
+  return !ctx.state.edgeReachedGate || allowedEdge === edge || !!allowGateCreatedInCurrentCheck;
+}
+function markReachedEdge(ctx) {
+  ctx.state.edgeReachedGate = "closed";
+}
+function prepareReachedEdgeForNextUserScroll(ctx) {
+  if (ctx.state.edgeReachedGate) {
+    ctx.state.edgeReachedGate = "prepared";
+  }
+}
+function beginReachedEdgeUserScroll(ctx, scrollDelta) {
+  const state = ctx.state;
+  if (state.edgeReachedGate !== "prepared") {
+    return void 0;
+  }
+  const allowedEdge = scrollDelta < 0 ? "start" : "end";
+  state.edgeReachedGate = "closed";
+  resetEdgeLatch(ctx, allowedEdge);
+  return allowedEdge;
+}
+
+// src/utils/hasActiveInitialScroll.ts
+function hasActiveInitialScroll(state) {
+  return !!(state == null ? void 0 : state.initialScroll) && !state.didFinishInitialScroll;
+}
+
+// src/utils/checkAtBottom.ts
+function checkAtBottom(ctx, allowedEdge, allowGateCreatedInCurrentCheck) {
+  var _a3;
+  const state = ctx.state;
+  if (!state) {
+    return;
+  }
+  const {
+    queuedInitialLayout,
+    scrollLength,
+    scroll,
+    maintainingScrollAtEnd,
+    props: { maintainScrollAtEndThreshold, onEndReachedThreshold }
+  } = state;
+  const contentSize = getContentSize(ctx);
+  resetSharedEdgeGateIfOutsideHysteresis(ctx);
   if (contentSize > 0 && queuedInitialLayout) {
     const insetEnd = getContentInsetEnd(ctx);
     const distanceFromEnd = contentSize - scroll - scrollLength - insetEnd;
@@ -988,59 +701,50 @@ function checkAtBottom(ctx) {
         },
         (distance) => {
           var _a4, _b;
-          return (_b = (_a4 = state.props).onEndReached) == null ? void 0 : _b.call(_a4, { distanceFromEnd: distance });
+          if (canDispatchReachedEdge(ctx, "end", allowedEdge, allowGateCreatedInCurrentCheck)) {
+            markReachedEdge(ctx);
+            (_b = (_a4 = state.props).onEndReached) == null ? void 0 : _b.call(_a4, { distanceFromEnd: distance });
+          }
         },
         (snapshot) => {
           state.endReachedSnapshot = snapshot;
-        },
-        true
+        }
       );
     }
   }
 }
 
-// src/utils/isInMVCPActiveMode.native.ts
-function isInMVCPActiveMode(state) {
-  return state.dataChangeNeedsScrollUpdate;
-}
-
 // src/utils/checkAtTop.ts
-function checkAtTop(ctx) {
+function checkAtTop(ctx, allowedEdge, allowGateCreatedInCurrentCheck) {
   const state = ctx == null ? void 0 : ctx.state;
   if (!state) {
     return;
   }
   const {
-    dataChangeEpoch,
     isStartReached,
     props: { data, onStartReachedThreshold },
     scroll,
     scrollLength,
     startReachedSnapshot,
-    startReachedSnapshotDataChangeEpoch,
     totalSize
   } = state;
   const dataLength = data.length;
   const threshold = onStartReachedThreshold * scrollLength;
-  const dataChanged = startReachedSnapshotDataChangeEpoch !== dataChangeEpoch;
-  const withinThreshold = threshold > 0 && Math.abs(scroll) <= threshold;
-  const allowReentryOnDataChange = !!isStartReached && withinThreshold && !!dataChanged && !isInMVCPActiveMode(state);
-  if (isStartReached && threshold > 0 && scroll > threshold && startReachedSnapshot && (dataChanged || startReachedSnapshot.contentSize !== totalSize || startReachedSnapshot.dataLength !== dataLength)) {
+  resetSharedEdgeGateIfOutsideHysteresis(ctx);
+  if (isStartReached && threshold > 0 && scroll > threshold && startReachedSnapshot && (startReachedSnapshot.contentSize !== totalSize || startReachedSnapshot.dataLength !== dataLength)) {
     state.isStartReached = false;
     state.startReachedSnapshot = void 0;
-    state.startReachedSnapshotDataChangeEpoch = void 0;
   }
   set$(ctx, "isAtStart", scroll <= EDGE_POSITION_EPSILON);
   set$(ctx, "isNearStart", scroll <= threshold);
   const shouldSkipThresholdChecks = hasActiveInitialScroll(state) || !!state.scrollingTo;
-  const shouldDeferDataChangeRefire = isStartReached && withinThreshold && dataChanged && !allowReentryOnDataChange;
-  if (!shouldSkipThresholdChecks && !shouldDeferDataChangeRefire) {
+  if (!shouldSkipThresholdChecks) {
     state.isStartReached = checkThreshold(
       scroll,
       false,
       threshold,
       state.isStartReached,
-      allowReentryOnDataChange ? void 0 : startReachedSnapshot,
+      startReachedSnapshot,
       {
         contentSize: totalSize,
         dataLength,
@@ -1048,21 +752,23 @@ function checkAtTop(ctx) {
       },
       (distance) => {
         var _a3, _b;
-        return (_b = (_a3 = state.props).onStartReached) == null ? void 0 : _b.call(_a3, { distanceFromStart: distance });
+        if (canDispatchReachedEdge(ctx, "start", allowedEdge, allowGateCreatedInCurrentCheck)) {
+          markReachedEdge(ctx);
+          (_b = (_a3 = state.props).onStartReached) == null ? void 0 : _b.call(_a3, { distanceFromStart: distance });
+        }
       },
       (snapshot) => {
         state.startReachedSnapshot = snapshot;
-        state.startReachedSnapshotDataChangeEpoch = snapshot ? dataChangeEpoch : void 0;
-      },
-      allowReentryOnDataChange
+      }
     );
   }
 }
 
 // src/utils/checkThresholds.ts
-function checkThresholds(ctx) {
-  checkAtBottom(ctx);
-  checkAtTop(ctx);
+function checkThresholds(ctx, allowedEdge) {
+  const allowGateCreatedInCurrentCheck = !ctx.state.edgeReachedGate;
+  checkAtBottom(ctx, allowedEdge, allowGateCreatedInCurrentCheck);
+  checkAtTop(ctx, allowedEdge, allowGateCreatedInCurrentCheck);
 }
 
 // src/core/recalculateSettledScroll.ts
@@ -1371,6 +1077,50 @@ function setSize(ctx, itemKey, size, notifyTotalSize = true) {
   sizes.set(itemKey, size);
 }
 
+// src/utils/helpers.ts
+function isFunction(obj) {
+  return typeof obj === "function";
+}
+function isArray(obj) {
+  return Array.isArray(obj);
+}
+var warned = /* @__PURE__ */ new Set();
+function warnDevOnce(id, text) {
+  if (IS_DEV && !warned.has(id)) {
+    warned.add(id);
+    console.warn(`[legend-list] ${text}`);
+  }
+}
+function roundSize(size) {
+  return Math.floor(size * 8) / 8;
+}
+function isNullOrUndefined(value) {
+  return value === null || value === void 0;
+}
+function getPadding(s, type) {
+  var _a3, _b, _c;
+  const axisPadding = type === "Left" || type === "Right" ? s.paddingHorizontal : s.paddingVertical;
+  return (_c = (_b = (_a3 = s[`padding${type}`]) != null ? _a3 : axisPadding) != null ? _b : s.padding) != null ? _c : 0;
+}
+function extractPadding(style, contentContainerStyle, type) {
+  return getPadding(style, type) + getPadding(contentContainerStyle, type);
+}
+function findContainerId(ctx, key) {
+  var _a3, _b;
+  const directMatch = (_b = (_a3 = ctx.state) == null ? void 0 : _a3.containerItemKeys) == null ? void 0 : _b.get(key);
+  if (directMatch !== void 0) {
+    return directMatch;
+  }
+  const numContainers = peek$(ctx, "numContainers");
+  for (let i = 0; i < numContainers; i++) {
+    const itemKey = peek$(ctx, `containerItemKey${i}`);
+    if (itemKey === key) {
+      return i;
+    }
+  }
+  return -1;
+}
+
 // src/utils/getItemSize.ts
 function getKnownOrFixedSize(ctx, key, index, data, resolved) {
   var _a3, _b;
@@ -2195,6 +1945,11 @@ var getScrollVelocity = (state) => {
   return totalWeight > 0 ? weightedVelocity / totalWeight : 0;
 };
 
+// src/utils/isInMVCPActiveMode.native.ts
+function isInMVCPActiveMode(state) {
+  return state.dataChangeNeedsScrollUpdate;
+}
+
 // src/core/updateScroll.ts
 function updateScroll(ctx, newScroll, forceUpdate, options) {
   var _a3;
@@ -2232,6 +1987,8 @@ function updateScroll(ctx, newScroll, forceUpdate, options) {
   state.scroll = newScroll;
   state.scrollTime = currentTime;
   const scrollDelta = Math.abs(newScroll - prevScroll);
+  const isUserScrollEvent = !!(options == null ? void 0 : options.fromNativeScrollEvent) && scrollDelta > 0.1 && !adjustChanged && scrollingTo === void 0 && !state.pendingNativeMVCPAdjust;
+  const allowedEdge = isUserScrollEvent ? beginReachedEdgeUserScroll(ctx, newScroll - prevScroll) : void 0;
   const didResolvePendingNativeMVCPAdjust = resolvePendingNativeMVCPAdjust(ctx, newScroll);
   const scrollLength = state.scrollLength;
   const isLargeUserScrollJump = scrollLength > 0 && scrollingTo === void 0 && scrollDelta > scrollLength && !state.pendingNativeMVCPAdjust;
@@ -2239,7 +1996,7 @@ function updateScroll(ctx, newScroll, forceUpdate, options) {
   updateAdaptiveRender(ctx, scrollVelocity, { forceLight: isLargeUserScrollJump });
   const lastCalculated = state.scrollLastCalculate;
   const useAggressiveItemRecalculation = isInMVCPActiveMode(state);
-  const shouldUpdate = useAggressiveItemRecalculation || didResolvePendingNativeMVCPAdjust || forceUpdate || lastCalculated === void 0 || Math.abs(state.scroll - lastCalculated) > 2;
+  const shouldUpdate = useAggressiveItemRecalculation || didResolvePendingNativeMVCPAdjust || allowedEdge !== void 0 || forceUpdate || lastCalculated === void 0 || Math.abs(state.scroll - lastCalculated) > 2;
   if (shouldUpdate) {
     state.scrollLastCalculate = state.scroll;
     state.ignoreScrollFromMVCPIgnored = false;
@@ -2254,7 +2011,7 @@ function updateScroll(ctx, newScroll, forceUpdate, options) {
         calculateItemsParams.drawDistanceMode = "visible-first";
       }
       (_a4 = state.triggerCalculateItemsInView) == null ? void 0 : _a4.call(state, calculateItemsParams);
-      checkThresholds(ctx);
+      checkThresholds(ctx, allowedEdge);
     };
     if (isLargeUserScrollJump) {
       state.mvcpAnchorLock = void 0;
@@ -3343,6 +3100,52 @@ function resetLayoutCachesForDataChange(state) {
   state.columnSpans.length = 0;
 }
 
+// src/core/scheduleContainerLayout.ts
+function getContainerLayoutEffectScope(ctx) {
+  var _a3;
+  const scheduledIds = ctx.pendingContainerIds;
+  ctx.pendingContainerIds = void 0;
+  if (scheduledIds === void 0) {
+    return void 0;
+  }
+  const state = ctx.state;
+  let targetContainerIds = scheduledIds;
+  if (targetContainerIds && ((_a3 = state.userScrollAnchorReset) == null ? void 0 : _a3.keys.size)) {
+    targetContainerIds = new Set(targetContainerIds);
+    for (const itemKey of state.userScrollAnchorReset.keys) {
+      const containerId = state.containerItemKeys.get(itemKey);
+      if (containerId !== void 0) {
+        targetContainerIds.add(containerId);
+      }
+    }
+  }
+  return targetContainerIds;
+}
+function scheduleContainerLayout(ctx, target) {
+  var _a3;
+  const isAlreadyScheduled = ctx.pendingContainerIds !== void 0;
+  const previousIds = ctx.pendingContainerIds;
+  if (target === void 0) {
+    ctx.pendingContainerIds = null;
+  } else if (previousIds !== null) {
+    let nextIds = previousIds;
+    if (!nextIds) {
+      nextIds = typeof target === "number" ? /* @__PURE__ */ new Set([target]) : new Set(target);
+    } else if (typeof target === "number") {
+      nextIds.add(target);
+    } else {
+      for (const containerId of target) {
+        nextIds.add(containerId);
+      }
+    }
+    ctx.pendingContainerIds = nextIds;
+  }
+  if (!isAlreadyScheduled) {
+    const nextEpoch = ((_a3 = peek$(ctx, "containerLayoutEpoch")) != null ? _a3 : 0) + 1;
+    set$(ctx, "containerLayoutEpoch", nextEpoch);
+  }
+}
+
 // src/core/syncMountedContainer.ts
 function syncMountedContainer(ctx, containerIndex, itemIndex, options) {
   var _a3, _b, _c, _d, _e, _f, _g, _h, _i;
@@ -3386,22 +3189,27 @@ function syncMountedContainer(ctx, containerIndex, itemIndex, options) {
       set$(ctx, `containerSpan${containerIndex}`, span);
     }
   }
+  const prevIndex = peek$(ctx, `containerItemIndex${containerIndex}`);
+  if (prevIndex !== itemIndex) {
+    set$(ctx, `containerItemIndex${containerIndex}`, itemIndex);
+  }
   const prevData = peek$(ctx, `containerItemData${containerIndex}`);
+  const updateData = () => {
+    set$(ctx, `containerItemData${containerIndex}`, item);
+    didRefreshData = true;
+  };
   if (prevData !== item) {
     const pendingDataComparison = ((_e = state.pendingDataComparison) == null ? void 0 : _e.previousData) === state.previousData && ((_f = state.pendingDataComparison) == null ? void 0 : _f.nextData) === data ? state.pendingDataComparison : void 0;
     const cachedComparison = (_g = pendingDataComparison == null ? void 0 : pendingDataComparison.byIndex[itemIndex]) != null ? _g : 0;
     if (cachedComparison === 2) {
-      set$(ctx, `containerItemData${containerIndex}`, item);
-      didRefreshData = true;
+      updateData();
     } else if (cachedComparison !== 1) {
       const nextItemKey = (_h = peek$(ctx, `containerItemKey${containerIndex}`)) != null ? _h : itemKey;
       const prevKey = keyExtractor == null ? void 0 : keyExtractor(prevData, itemIndex);
       if (prevData === void 0 || !keyExtractor || prevKey !== nextItemKey) {
-        set$(ctx, `containerItemData${containerIndex}`, item);
-        didRefreshData = true;
+        updateData();
       } else if (!itemsAreEqual) {
-        set$(ctx, `containerItemData${containerIndex}`, item);
-        didRefreshData = true;
+        updateData();
       } else {
         const isEqual = itemsAreEqual(prevData, item, itemIndex, data);
         if (!state.pendingDataComparison || state.pendingDataComparison.previousData !== state.previousData || state.pendingDataComparison.nextData !== data) {
@@ -3417,8 +3225,7 @@ function syncMountedContainer(ctx, containerIndex, itemIndex, options) {
           state.pendingDataComparison.byIndex[itemIndex] = isEqual ? 1 : 2;
         }
         if (!isEqual) {
-          set$(ctx, `containerItemData${containerIndex}`, item);
-          didRefreshData = true;
+          updateData();
         }
       }
     }
@@ -3787,19 +3594,29 @@ function updateViewableItemsWithConfig(data, viewabilityConfigCallbackPair, stat
   if (previousViewableItems) {
     for (const viewToken of previousViewableItems) {
       previousViewableKeys.add(viewToken.key);
+      const currentIndex = state.indexByKey.get(viewToken.key);
+      const currentItem = currentIndex !== void 0 ? data[currentIndex] : void 0;
       const containerId = findContainerId(ctx, viewToken.key);
-      if (!checkIsViewable(
-        state,
-        ctx,
-        viewabilityConfig,
-        containerId,
-        viewToken.key,
-        scrollSize,
-        viewToken.item,
-        viewToken.index
-      )) {
-        viewToken.isViewable = false;
-        changed.push(viewToken);
+      let isStillViewable = false;
+      if (currentIndex !== void 0 && currentItem !== void 0) {
+        isStillViewable = checkIsViewable(
+          state,
+          ctx,
+          viewabilityConfig,
+          containerId,
+          viewToken.key,
+          scrollSize,
+          currentItem,
+          currentIndex
+        );
+      }
+      if (!isStillViewable) {
+        changed.push({
+          ...viewToken,
+          index: currentIndex != null ? currentIndex : viewToken.index,
+          isViewable: false,
+          item: currentItem != null ? currentItem : viewToken.item
+        });
       }
     }
   }
@@ -3956,128 +3773,102 @@ function getExpandedContainerPoolSize(dataLength, numContainers) {
 
 // src/utils/findAvailableContainers.ts
 function findAvailableContainers(ctx, needNewContainers, startBuffered, endBuffered, pendingRemoval, getRequiredItemType, protectedKeys) {
+  var _a3;
   const numNeeded = needNewContainers.length;
   if (numNeeded === 0) {
     return [];
   }
   const numContainers = peek$(ctx, "numContainers");
   const state = ctx.state;
-  const { stickyContainerPool, containerItemTypes } = state;
+  const { containerItemMetadata, stickyContainerPool } = state;
   const shouldAvoidAssignedContainerReuse = state.props.recycleItems && !!state.props.positionComponentInternal;
-  const allocations = [];
   const pendingRemovalSet = pendingRemoval.length > 0 ? new Set(pendingRemoval) : void 0;
-  let pendingRemovalChanged = false;
+  const requests = needNewContainers.map((itemIndex, order) => ({
+    isSticky: state.props.stickyHeaderIndicesSet.has(itemIndex),
+    itemIndex,
+    itemType: getRequiredItemType == null ? void 0 : getRequiredItemType(itemIndex),
+    order
+  }));
+  const normalRequests = requests.filter((request) => !request.isSticky);
+  const stickyRequests = requests.filter((request) => request.isSticky);
+  const normalCandidates = [];
+  const stickyCandidates = [];
+  for (let containerIndex = 0; containerIndex < numContainers; containerIndex++) {
+    const key = peek$(ctx, `containerItemKey${containerIndex}`);
+    const isPendingRemoval = !!(pendingRemovalSet == null ? void 0 : pendingRemovalSet.has(containerIndex));
+    const isProtected = !!key && !!(protectedKeys == null ? void 0 : protectedKeys.has(key)) && state.indexByKey.has(key);
+    if (isProtected) {
+      continue;
+    }
+    if (stickyContainerPool.has(containerIndex)) {
+      if (key === void 0 || isPendingRemoval) {
+        stickyCandidates.push({ containerIndex, distance: Number.POSITIVE_INFINITY });
+      }
+    } else if (key === void 0 || isPendingRemoval) {
+      normalCandidates.push({ containerIndex, distance: Number.POSITIVE_INFINITY });
+    } else if (!shouldAvoidAssignedContainerReuse) {
+      const index = state.indexByKey.get(key);
+      if (index !== void 0 && (index < startBuffered || index > endBuffered)) {
+        const distance = index < startBuffered ? startBuffered - index : index - endBuffered;
+        normalCandidates.push({ containerIndex, distance });
+      }
+    }
+  }
+  normalCandidates.sort(comparatorByDistance);
+  const allocations = new Array(numNeeded);
   let nextNewContainerIndex = numContainers;
-  const usedContainers = /* @__PURE__ */ new Set();
-  let availableContainers;
-  const stickyHeaderIndicesSet = state.props.stickyHeaderIndicesSet;
-  const canReuseContainer = (containerIndex, requiredType) => {
-    if (!requiredType) return true;
-    const existingType = containerItemTypes.get(containerIndex);
-    if (!existingType) return true;
-    return existingType === requiredType;
-  };
-  const pushAllocation = (itemIndex, itemType, containerIndex) => {
-    allocations.push({
+  let pendingRemovalChanged = false;
+  const assign = (request, containerIndex) => {
+    allocations[request.order] = {
       containerIndex,
-      itemIndex,
-      itemType
-    });
-    usedContainers.add(containerIndex);
+      itemIndex: request.itemIndex,
+      itemType: request.itemType
+    };
     if (pendingRemovalSet == null ? void 0 : pendingRemovalSet.delete(containerIndex)) {
       pendingRemovalChanged = true;
     }
   };
-  const pushNewContainer = (itemIndex, itemType, isSticky) => {
-    const newContainerIndex = nextNewContainerIndex++;
-    pushAllocation(itemIndex, itemType, newContainerIndex);
-    if (isSticky) {
-      stickyContainerPool.add(newContainerIndex);
-    }
-    return newContainerIndex;
-  };
-  const canUseContainer = (containerIndex, itemType) => {
-    if (usedContainers.has(containerIndex) || stickyContainerPool.has(containerIndex)) {
-      return false;
-    }
-    const key = peek$(ctx, `containerItemKey${containerIndex}`);
-    const isPending = !!(pendingRemovalSet == null ? void 0 : pendingRemovalSet.has(containerIndex));
-    return (key === void 0 || isPending) && canReuseContainer(containerIndex, itemType);
-  };
-  const findStickyContainer = (itemType) => {
-    let foundContainer;
-    for (const containerIndex of stickyContainerPool) {
-      if (!usedContainers.has(containerIndex)) {
-        const key = peek$(ctx, `containerItemKey${containerIndex}`);
-        const isPendingRemoval = !!(pendingRemovalSet == null ? void 0 : pendingRemovalSet.has(containerIndex));
-        if ((key === void 0 || isPendingRemoval) && canReuseContainer(containerIndex, itemType)) {
-          foundContainer = containerIndex;
-          break;
-        }
-      }
-    }
-    return foundContainer;
-  };
-  const findUnassignedOrPendingContainer = (itemType) => {
-    let foundContainer;
-    for (let containerIndex = 0; containerIndex < numContainers && foundContainer === void 0; containerIndex++) {
-      if (canUseContainer(containerIndex, itemType)) {
-        foundContainer = containerIndex;
+  const assignMatching = (pendingRequests, candidates, matches) => {
+    for (const request of pendingRequests) {
+      if (allocations[request.order]) {
+        continue;
       }
-    }
-    return foundContainer;
-  };
-  const getAvailableContainers = () => {
-    if (!availableContainers) {
-      availableContainers = [];
-      if (!shouldAvoidAssignedContainerReuse) {
-        for (let containerIndex = 0; containerIndex < numContainers; containerIndex++) {
-          if (usedContainers.has(containerIndex) || stickyContainerPool.has(containerIndex)) {
-            continue;
-          }
-          const key = peek$(ctx, `containerItemKey${containerIndex}`);
-          if (key === void 0) continue;
-          if ((protectedKeys == null ? void 0 : protectedKeys.has(key)) && state.indexByKey.has(key)) continue;
-          const index = state.indexByKey.get(key);
-          const isOutOfView = index < startBuffered || index > endBuffered;
-          if (isOutOfView) {
-            const distance = index < startBuffered ? startBuffered - index : index - endBuffered;
-            availableContainers.push({ distance, index: containerIndex });
-          }
+      const candidateIndex = candidates.findIndex(
+        (candidate) => {
+          var _a4;
+          return matches((_a4 = containerItemMetadata.get(candidate.containerIndex)) == null ? void 0 : _a4.itemType, request.itemType);
         }
-        availableContainers.sort(comparatorByDistance);
+      );
+      if (candidateIndex !== -1) {
+        const [candidate] = candidates.splice(candidateIndex, 1);
+        assign(request, candidate.containerIndex);
       }
     }
-    return availableContainers;
   };
-  const findAvailableContainer = (itemType) => {
-    const containers = getAvailableContainers();
-    let matchIndex = -1;
-    for (let i = 0; i < containers.length && matchIndex === -1; i++) {
-      const containerIndex = containers[i].index;
-      if (!usedContainers.has(containerIndex) && canReuseContainer(containerIndex, itemType)) {
-        matchIndex = i;
-      }
+  const assignFromPool = (pendingRequests, candidates, allowCrossType) => {
+    if (getRequiredItemType) {
+      assignMatching(
+        pendingRequests,
+        candidates,
+        (containerType, requestType) => requestType !== void 0 && containerType === requestType
+      );
+    }
+    assignMatching(pendingRequests, candidates, (containerType) => containerType === void 0);
+    if (allowCrossType) {
+      assignMatching(pendingRequests, candidates, () => true);
     }
-    return matchIndex === -1 ? void 0 : containers.splice(matchIndex, 1)[0].index;
   };
-  for (const itemIndex of needNewContainers) {
-    const itemType = getRequiredItemType == null ? void 0 : getRequiredItemType(itemIndex);
-    const isSticky = stickyHeaderIndicesSet.has(itemIndex);
-    let containerIndex;
-    if (isSticky) {
-      containerIndex = findStickyContainer(itemType);
-    } else {
-      containerIndex = findUnassignedOrPendingContainer(itemType);
-      if (containerIndex === void 0) {
-        containerIndex = findAvailableContainer(itemType);
-      }
+  assignFromPool(normalRequests, normalCandidates, true);
+  assignFromPool(stickyRequests, stickyCandidates, false);
+  for (const request of requests) {
+    if (allocations[request.order]) {
+      continue;
     }
-    if (containerIndex !== void 0) {
-      pushAllocation(itemIndex, itemType, containerIndex);
-    } else {
-      pushNewContainer(itemIndex, itemType, isSticky);
+    const containerIndex = nextNewContainerIndex++;
+    if (request.isSticky) {
+      stickyContainerPool.add(containerIndex);
     }
+    assign(request, containerIndex);
   }
   if (pendingRemovalChanged) {
     pendingRemoval.length = 0;
@@ -4087,18 +3878,21 @@ function findAvailableContainers(ctx, needNewContainers, startBuffered, endBuffe
       }
     }
   }
-  if (IS_DEV && nextNewContainerIndex > peek$(ctx, "numContainersPooled")) {
-    console.warn(
-      "[legend-list] No unused container available, so creating one on demand. This can be a minor performance issue and is likely caused by the estimatedItemSize being too large. Consider decreasing estimatedItemSize.",
-      {
-        debugInfo: {
-          numContainers,
-          numContainersPooled: peek$(ctx, "numContainersPooled"),
-          numNeeded,
-          stillNeeded: nextNewContainerIndex - numContainers
+  if (IS_DEV) {
+    const numContainersPooled = (_a3 = peek$(ctx, "numContainersPooled")) != null ? _a3 : Number.POSITIVE_INFINITY;
+    if (nextNewContainerIndex > numContainersPooled) {
+      console.warn(
+        "[legend-list] No unused container available, so creating one on demand. This can be a minor performance issue and is likely caused by the estimatedItemSize being too large. Consider decreasing estimatedItemSize.",
+        {
+          debugInfo: {
+            numContainers,
+            numContainersPooled,
+            numNeeded,
+            stillNeeded: nextNewContainerIndex - numContainers
+          }
         }
-      }
-    );
+      );
+    }
   }
   return allocations;
 }
@@ -4333,7 +4127,7 @@ function updateViewabilityForCachedRange(ctx, viewabilityConfigCallbackPairs, sc
 function calculateItemsInView(ctx, params = {}) {
   const state = ctx.state;
   batchedUpdates(() => {
-    var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t;
+    var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u;
     const {
       columns,
       containerItemKeys,
@@ -4361,6 +4155,7 @@ function calculateItemsInView(ctx, params = {}) {
       return;
     }
     let totalSize = getContentSize(ctx);
+    let changedContainerIds;
     const topPad = peek$(ctx, "stylePaddingTop") + peek$(ctx, "alignItemsAtEndPadding") + peek$(ctx, "headerSize");
     const numColumns = peek$(ctx, "numColumns");
     const speed = (_b = params.scrollVelocity) != null ? _b : getScrollVelocity(state);
@@ -4486,7 +4281,7 @@ function calculateItemsInView(ctx, params = {}) {
     const scrollAdjustPendingBeforeMVCP = (_f = peek$(ctx, "scrollAdjustPending")) != null ? _f : 0;
     checkMVCP == null ? void 0 : checkMVCP();
     const didMVCPAdjustScroll = !!checkMVCP && (state.scroll !== scrollBeforeMVCP || ((_g = peek$(ctx, "scrollAdjustPending")) != null ? _g : 0) !== scrollAdjustPendingBeforeMVCP);
-    if (didMVCPAdjustScroll && (initialScroll || state.scrollingTo)) {
+    if (didMVCPAdjustScroll) {
       updateScroll2(state.scroll);
       updateScrollRange();
     }
@@ -4666,17 +4461,20 @@ function calculateItemsInView(ctx, params = {}) {
           if (oldKey && oldKey !== id) {
             containerItemKeys.delete(oldKey);
           }
+          if (oldKey !== id) {
+            changedContainerIds != null ? changedContainerIds : changedContainerIds = /* @__PURE__ */ new Set();
+            changedContainerIds.add(containerIndex);
+            state.containerItemGenerations[containerIndex] = ((_p = state.containerItemGenerations[containerIndex]) != null ? _p : 0) + 1;
+          }
           set$(ctx, `containerItemKey${containerIndex}`, id);
+          set$(ctx, `containerItemIndex${containerIndex}`, i);
           set$(ctx, `containerItemData${containerIndex}`, data[i]);
-          if (allocation.itemType !== void 0) {
-            state.containerItemTypes.set(containerIndex, allocation.itemType);
-          }
+          state.containerItemMetadata.set(
+            containerIndex,
+            createContainerItemMetadata(state, i, data[i], allocation.itemType)
+          );
           containerItemKeys.set(id, containerIndex);
-          (_p = state.userScrollAnchorReset) == null ? void 0 : _p.keys.add(id);
-          if (IsNewArchitecture) {
-            (_q = state.pendingLayoutEffectMeasurements) != null ? _q : state.pendingLayoutEffectMeasurements = /* @__PURE__ */ new Set();
-            state.pendingLayoutEffectMeasurements.add(id);
-          }
+          (_q = state.userScrollAnchorReset) == null ? void 0 : _q.keys.add(id);
           const containerSticky = `containerSticky${containerIndex}`;
           const isSticky = stickyHeaderIndicesSet.has(i);
           const isPinnedRender = isPinnedRenderIndex(i);
@@ -4726,13 +4524,17 @@ function calculateItemsInView(ctx, params = {}) {
       if (pendingRemovalSet == null ? void 0 : pendingRemovalSet.has(i)) {
         if (itemKey !== void 0) {
           containerItemKeys.delete(itemKey);
+          changedContainerIds != null ? changedContainerIds : changedContainerIds = /* @__PURE__ */ new Set();
+          changedContainerIds.add(i);
+          state.containerItemGenerations[i] = ((_t = state.containerItemGenerations[i]) != null ? _t : 0) + 1;
         }
-        state.containerItemTypes.delete(i);
+        state.containerItemMetadata.delete(i);
         if (state.stickyContainerPool.has(i)) {
           set$(ctx, `containerSticky${i}`, false);
           state.stickyContainerPool.delete(i);
         }
         set$(ctx, `containerItemKey${i}`, void 0);
+        set$(ctx, `containerItemIndex${i}`, void 0);
         set$(ctx, `containerItemData${i}`, void 0);
         set$(ctx, `containerPosition${i}`, POSITION_OUT_OF_VIEW);
         set$(ctx, `containerColumn${i}`, -1);
@@ -4747,6 +4549,9 @@ function calculateItemsInView(ctx, params = {}) {
         }
       }
     }
+    if (changedContainerIds && (IsNewArchitecture || Platform.OS === "web")) {
+      scheduleContainerLayout(ctx, changedContainerIds);
+    }
     if (Platform.OS === "web" && didChangePositions) {
       set$(ctx, "lastPositionUpdate", Date.now());
     }
@@ -4763,20 +4568,18 @@ function calculateItemsInView(ctx, params = {}) {
       }
     }
     if (viewabilityConfigCallbackPairs && visibleRange.startNoBuffer !== null && visibleRange.endNoBuffer !== null) {
-      if (!didMVCPAdjustScroll) {
-        updateViewableItems(
-          ctx.state,
-          ctx,
-          viewabilityConfigCallbackPairs,
-          scrollLength,
-          visibleRange.startNoBuffer,
-          visibleRange.endNoBuffer,
-          startBuffered != null ? startBuffered : visibleRange.startNoBuffer,
-          endBuffered != null ? endBuffered : visibleRange.endNoBuffer
-        );
-      }
+      updateViewableItems(
+        ctx.state,
+        ctx,
+        viewabilityConfigCallbackPairs,
+        scrollLength,
+        visibleRange.startNoBuffer,
+        visibleRange.endNoBuffer,
+        startBuffered != null ? startBuffered : visibleRange.startNoBuffer,
+        endBuffered != null ? endBuffered : visibleRange.endNoBuffer
+      );
     }
-    (_t = stickyState == null ? void 0 : stickyState.finishCalculateItemsInView) == null ? void 0 : _t.call(stickyState);
+    (_u = stickyState == null ? void 0 : stickyState.finishCalculateItemsInView) == null ? void 0 : _u.call(stickyState);
   });
 }
 
@@ -4882,42 +4685,28 @@ function updateOtherAxisSizeIfNeeded(ctx, sizeObj, horizontal) {
     }
   }
 }
+var activeItemSizeBatches;
+function batchItemSizeUpdates(runUpdates) {
+  const isOuterBatch = activeItemSizeBatches === void 0;
+  activeItemSizeBatches != null ? activeItemSizeBatches : activeItemSizeBatches = /* @__PURE__ */ new Map();
+  try {
+    runUpdates();
+  } finally {
+    if (isOuterBatch) {
+      const batches = activeItemSizeBatches;
+      activeItemSizeBatches = void 0;
+      for (const [ctx, measurements] of batches) {
+        updateItemSizesBatch(ctx, measurements);
+      }
+    }
+  }
+}
 function mergeItemSizeUpdateResult(result, next) {
   result.didChange || (result.didChange = next.didChange);
   result.didMeasureUserScrollAnchorResetItem || (result.didMeasureUserScrollAnchorResetItem = next.didMeasureUserScrollAnchorResetItem);
   result.needsRecalculate || (result.needsRecalculate = next.needsRecalculate);
   result.shouldMaintainScrollAtEnd || (result.shouldMaintainScrollAtEnd = next.shouldMaintainScrollAtEnd);
 }
-var batchedItemSizeRecalculates = /* @__PURE__ */ new WeakMap();
-function flushBatchedItemSizeRecalculate(ctx, didFallback = false, expectedResult) {
-  const result = batchedItemSizeRecalculates.get(ctx);
-  if (!result || expectedResult && result !== expectedResult) {
-    return;
-  }
-  batchedItemSizeRecalculates.delete(ctx);
-  if (didFallback) {
-    ctx.state.pendingLayoutEffectMeasurements = void 0;
-  }
-  flushItemSizeUpdates(ctx, result);
-}
-function queueItemSizeRecalculate(ctx, result) {
-  var _a3, _b;
-  const batch = batchedItemSizeRecalculates.get(ctx);
-  if (batch) {
-    mergeItemSizeUpdateResult(batch, result);
-  } else {
-    const nextBatch = { ...result };
-    batchedItemSizeRecalculates.set(ctx, nextBatch);
-    if ((_a3 = ctx.state.pendingLayoutEffectMeasurements) == null ? void 0 : _a3.size) {
-      requestAnimationFrame(() => {
-        flushBatchedItemSizeRecalculate(ctx, true, nextBatch);
-      });
-    }
-  }
-  if (!((_b = ctx.state.pendingLayoutEffectMeasurements) == null ? void 0 : _b.size)) {
-    flushBatchedItemSizeRecalculate(ctx);
-  }
-}
 function flushItemSizeUpdates(ctx, result) {
   var _a3;
   const state = ctx.state;
@@ -4932,54 +4721,36 @@ function flushItemSizeUpdates(ctx, result) {
   }
 }
 function updateItemSizes(ctx, measurement) {
-  var _a3, _b, _c, _d;
-  const state = ctx.state;
-  let didDrainLayoutEffectMeasurements = false;
-  if (IsNewArchitecture && measurement.fromLayoutEffect) {
-    const pendingLayoutEffectMeasurements = state.pendingLayoutEffectMeasurements;
-    if ((pendingLayoutEffectMeasurements == null ? void 0 : pendingLayoutEffectMeasurements.delete(measurement.itemKey)) && pendingLayoutEffectMeasurements.size === 0) {
-      state.pendingLayoutEffectMeasurements = void 0;
-      didDrainLayoutEffectMeasurements = true;
-    }
-  }
-  const pendingKeys = (_a3 = state.userScrollAnchorReset) == null ? void 0 : _a3.keys;
-  const shouldBatchPendingMeasurements = IsNewArchitecture && measurement.fromLayoutEffect && !!(pendingKeys == null ? void 0 : pendingKeys.size);
-  const shouldQueueRecalculate = IsNewArchitecture && !!measurement.fromLayoutEffect;
-  let result;
-  if (!shouldBatchPendingMeasurements) {
-    result = applyItemSize(ctx, measurement.itemKey, measurement.size);
-  } else {
-    result = {};
-    const updateContainerItemSize = (itemKey, containerId, size) => {
-      if (containerId !== void 0 && peek$(ctx, `containerItemKey${containerId}`) === itemKey) {
-        mergeItemSizeUpdateResult(result, applyItemSize(ctx, itemKey, size));
-      }
-    };
-    updateContainerItemSize(measurement.itemKey, measurement.containerId, measurement.size);
-    const keys = Array.from(pendingKeys);
-    for (const itemKey of keys) {
-      const containerId = state.containerItemKeys.get(itemKey);
-      if (containerId !== void 0) {
-        (_d = (_c = (_b = ctx.viewRefs.get(containerId)) == null ? void 0 : _b.current) == null ? void 0 : _c.measure) == null ? void 0 : _d.call(_c, (_x, _y, width, height) => {
-          if (pendingKeys.has(itemKey)) {
-            updateContainerItemSize(itemKey, containerId, { height, width });
-          }
-        });
-      }
+  if (activeItemSizeBatches) {
+    const measurements = activeItemSizeBatches.get(ctx);
+    if (measurements) {
+      measurements.push(measurement);
+    } else {
+      activeItemSizeBatches.set(ctx, [measurement]);
     }
-  }
-  if (shouldQueueRecalculate && result.needsRecalculate) {
-    queueItemSizeRecalculate(ctx, result);
   } else {
-    flushItemSizeUpdates(ctx, result);
-  }
-  if (didDrainLayoutEffectMeasurements) {
-    flushBatchedItemSizeRecalculate(ctx);
+    updateItemSizesBatch(ctx, [measurement]);
   }
 }
-function applyItemSize(ctx, itemKey, sizeObj) {
+function updateItemSizesBatch(ctx, measurements) {
   var _a3;
   const state = ctx.state;
+  const result = {};
+  for (const measurement of measurements) {
+    const ownsMeasuredItem = measurement.containerId === void 0 || peek$(ctx, `containerItemKey${measurement.containerId}`) === measurement.itemKey;
+    if (ownsMeasuredItem) {
+      const index = state.indexByKey.get(measurement.itemKey);
+      const itemData = index === void 0 ? void 0 : (_a3 = state.props.data) == null ? void 0 : _a3[index];
+      const metadata = measurement.containerId !== void 0 && index !== void 0 && itemData !== void 0 ? resolveContainerItemMetadata(state, measurement.containerId, index, itemData) : void 0;
+      const nextResult = applyItemSize(ctx, measurement.itemKey, measurement.size, metadata);
+      mergeItemSizeUpdateResult(result, nextResult);
+    }
+  }
+  flushItemSizeUpdates(ctx, result);
+}
+function applyItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
+  var _a3, _b;
+  const state = ctx.state;
   const userScrollAnchorReset = state.userScrollAnchorReset;
   const didMeasureUserScrollAnchorResetItem = !!(userScrollAnchorReset == null ? void 0 : userScrollAnchorReset.keys.delete(itemKey));
   const {
@@ -4989,7 +4760,6 @@ function applyItemSize(ctx, itemKey, sizeObj) {
   } = state;
   if (!data) return { didMeasureUserScrollAnchorResetItem };
   const index = state.indexByKey.get(itemKey);
-  let resolvedMeasurementItem;
   if (getFixedItemSize) {
     if (index === void 0) {
       return { didMeasureUserScrollAnchorResetItem };
@@ -4998,14 +4768,15 @@ function applyItemSize(ctx, itemKey, sizeObj) {
     if (itemData === void 0) {
       return { didMeasureUserScrollAnchorResetItem };
     }
-    const type = getItemType ? (_a3 = getItemType(itemData, index)) != null ? _a3 : "" : "";
-    const size2 = getFixedItemSize(itemData, index, type);
-    resolvedMeasurementItem = {
-      didResolveFixedItemSize: true,
-      fixedItemSize: size2,
-      itemData,
-      itemType: type
-    };
+    if (!(resolvedMeasurementItem == null ? void 0 : resolvedMeasurementItem.didResolveFixedItemSize)) {
+      const type = (_b = resolvedMeasurementItem == null ? void 0 : resolvedMeasurementItem.itemType) != null ? _b : getItemType ? (_a3 = getItemType(itemData, index)) != null ? _a3 : "" : "";
+      resolvedMeasurementItem = {
+        didResolveFixedItemSize: true,
+        fixedItemSize: getFixedItemSize(itemData, index, type),
+        itemType: type
+      };
+    }
+    const size2 = resolvedMeasurementItem.fixedItemSize;
     if (size2 !== void 0 && size2 === sizesKnown.get(itemKey)) {
       updateOtherAxisSizeIfNeeded(ctx, sizeObj, horizontal);
       return { didMeasureUserScrollAnchorResetItem };
@@ -5024,91 +4795,532 @@ function applyItemSize(ctx, itemKey, sizeObj) {
     if (!needsRecalculate && state.containerItemKeys.has(itemKey)) {
       needsRecalculate = true;
     }
-    if (prevSizeKnown !== void 0 && Math.abs(prevSizeKnown - size) > 5) {
-      shouldMaintainScrollAtEnd = true;
+    if (prevSizeKnown !== void 0 && Math.abs(prevSizeKnown - size) > 5) {
+      shouldMaintainScrollAtEnd = true;
+    }
+    onItemSizeChanged == null ? void 0 : onItemSizeChanged({
+      index,
+      itemData: state.props.data[index],
+      itemKey,
+      previous: size - diff,
+      size
+    });
+    maybeUpdateAnchoredEndSpace(ctx);
+  }
+  if (minIndexSizeChanged !== void 0) {
+    state.minIndexSizeChanged = state.minIndexSizeChanged !== void 0 ? Math.min(state.minIndexSizeChanged, minIndexSizeChanged) : minIndexSizeChanged;
+  }
+  updateOtherAxisSizeIfNeeded(ctx, sizeObj, horizontal);
+  if (didContainersLayout || checkAllSizesKnown(state, state.startBuffered, state.endBuffered)) {
+    const canMaintainScrollAtEnd = shouldMaintainScrollAtEnd && !!(maintainScrollAtEnd == null ? void 0 : maintainScrollAtEnd.onItemLayout);
+    return {
+      didChange: diff !== 0,
+      didMeasureUserScrollAnchorResetItem,
+      needsRecalculate,
+      shouldMaintainScrollAtEnd: canMaintainScrollAtEnd
+    };
+  }
+  return {
+    didChange: diff !== 0,
+    didMeasureUserScrollAnchorResetItem
+  };
+}
+function updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
+  var _a3, _b;
+  const state = ctx.state;
+  const {
+    indexByKey,
+    sizesKnown,
+    averageSizes,
+    props: { data, horizontal, getItemType, getFixedItemSize }
+  } = state;
+  if (!data) return 0;
+  const index = indexByKey.get(itemKey);
+  const itemData = data[index];
+  let itemType = resolvedMeasurementItem == null ? void 0 : resolvedMeasurementItem.itemType;
+  let fixedItemSize = resolvedMeasurementItem == null ? void 0 : resolvedMeasurementItem.fixedItemSize;
+  if (getFixedItemSize && !(resolvedMeasurementItem == null ? void 0 : resolvedMeasurementItem.didResolveFixedItemSize)) {
+    itemType = getItemType ? (_a3 = getItemType(itemData, index)) != null ? _a3 : "" : "";
+    fixedItemSize = getFixedItemSize(itemData, index, itemType);
+  }
+  const resolvedItemSize = (resolvedMeasurementItem == null ? void 0 : resolvedMeasurementItem.didResolveFixedItemSize) || itemType !== void 0 || fixedItemSize !== void 0 ? {
+    didResolveFixedItemSize: resolvedMeasurementItem == null ? void 0 : resolvedMeasurementItem.didResolveFixedItemSize,
+    fixedItemSize,
+    itemType
+  } : void 0;
+  const prevSize = getItemSize(ctx, itemKey, index, itemData, void 0, void 0, void 0, resolvedItemSize);
+  const rawSize = horizontal ? sizeObj.width : sizeObj.height;
+  const prevSizeKnown = sizesKnown.get(itemKey);
+  if (Platform.OS !== "web" && prevSizeKnown !== void 0 && isNativeLayoutNoise(rawSize - prevSizeKnown)) {
+    return 0;
+  }
+  const size = Platform.OS === "web" ? Math.round(rawSize) : roundSize(rawSize);
+  sizesKnown.set(itemKey, size);
+  if (fixedItemSize === void 0 && size > 0) {
+    itemType != null ? itemType : itemType = getItemType ? (_b = getItemType(itemData, index)) != null ? _b : "" : "";
+    let averages = averageSizes[itemType];
+    if (!averages) {
+      averages = averageSizes[itemType] = { avg: 0, num: 0 };
+    }
+    if (averages.num === 0) {
+      averages.avg = size;
+      averages.num++;
+    } else if (prevSizeKnown !== void 0 && prevSizeKnown > 0) {
+      averages.avg += (size - prevSizeKnown) / averages.num;
+    } else {
+      averages.avg = (averages.avg * averages.num + size) / (averages.num + 1);
+      averages.num++;
+    }
+  }
+  if (!prevSize || Math.abs(prevSize - size) > 0.1) {
+    setSize(ctx, itemKey, size);
+    return size - prevSize;
+  }
+  return 0;
+}
+
+// src/core/measureContainersInLayoutEffect.native.ts
+function resolveFixedItemSize(ctx, containerId, itemKey) {
+  var _a3;
+  const state = ctx.state;
+  const { data, getFixedItemSize } = state.props;
+  const index = state.indexByKey.get(itemKey);
+  let fixedItemSize;
+  if (data && getFixedItemSize && index !== void 0) {
+    const itemData = data[index];
+    if (itemData !== void 0) {
+      fixedItemSize = (_a3 = resolveContainerItemMetadata(state, containerId, index, itemData)) == null ? void 0 : _a3.fixedItemSize;
+    }
+  }
+  return fixedItemSize;
+}
+function resolveSkippedAnchorReset(ctx, itemKey) {
+  const state = ctx.state;
+  const anchorReset = state.userScrollAnchorReset;
+  if ((anchorReset == null ? void 0 : anchorReset.keys.delete(itemKey)) && anchorReset.keys.size === 0) {
+    state.userScrollAnchorReset = void 0;
+  }
+}
+function measureContainersInLayoutEffect(ctx, targetContainerIds = null) {
+  var _a3, _b, _c;
+  const state = ctx.state;
+  const measurements = [];
+  let isCollectingSynchronousMeasurements = true;
+  const containerIds = targetContainerIds != null ? targetContainerIds : ctx.viewRefs.keys();
+  for (const containerId of containerIds) {
+    const viewRef = ctx.viewRefs.get(containerId);
+    const itemKey = peek$(ctx, `containerItemKey${containerId}`);
+    if (itemKey !== void 0) {
+      const generation = ((_a3 = state.containerItemGenerations[containerId]) != null ? _a3 : 0) + 1;
+      state.containerItemGenerations[containerId] = generation;
+      const fixedItemSize = resolveFixedItemSize(ctx, containerId, itemKey);
+      const canSkipMeasurement = !state.needsOtherAxisSize && fixedItemSize !== void 0 && state.sizesKnown.get(itemKey) === fixedItemSize + ctx.scrollAxisGap;
+      if (canSkipMeasurement) {
+        resolveSkippedAnchorReset(ctx, itemKey);
+      } else if (viewRef) {
+        (_c = (_b = viewRef.current) == null ? void 0 : _b.measure) == null ? void 0 : _c.call(_b, (_x, _y, width, height) => {
+          var _a4;
+          const isCurrentGeneration = ((_a4 = ctx.state.containerItemGenerations[containerId]) != null ? _a4 : 0) === generation;
+          if (isCurrentGeneration) {
+            const measurement = {
+              containerId,
+              itemKey,
+              size: { height, width }
+            };
+            if (isCollectingSynchronousMeasurements) {
+              measurements.push(measurement);
+            } else {
+              updateItemSizes(ctx, measurement);
+            }
+          }
+        });
+      }
+    }
+  }
+  isCollectingSynchronousMeasurements = false;
+  if (measurements.length > 0) {
+    updateItemSizesBatch(ctx, measurements);
+  }
+}
+var typedForwardRef = React2.forwardRef;
+var typedMemo = React2.memo;
+
+// src/components/ContainerLayoutCoordinator.tsx
+var ContainerLayoutCoordinator = typedMemo(function ContainerLayoutCoordinatorComponent({
+  children
+}) {
+  const ctx = useStateContext();
+  const [containerLayoutEpoch] = useArr$(["containerLayoutEpoch"]);
+  React2.useLayoutEffect(() => {
+    if (IsNewArchitecture) {
+      const targetContainerIds = getContainerLayoutEffectScope(ctx);
+      if (targetContainerIds !== void 0) {
+        measureContainersInLayoutEffect(ctx, targetContainerIds);
+      }
+    }
+  }, [ctx, containerLayoutEpoch]);
+  return children;
+});
+
+// src/components/stickyPositionUtils.ts
+function getStickyPushLimit(state, index, itemKey) {
+  if (!itemKey) {
+    return void 0;
+  }
+  const currentSize = state.sizes.get(itemKey);
+  if (!(currentSize && currentSize > 0)) {
+    return void 0;
+  }
+  const stickyIndexInArray = state.props.stickyHeaderIndicesArr.indexOf(index);
+  if (stickyIndexInArray === -1) {
+    return void 0;
+  }
+  const nextStickyIndex = state.props.stickyHeaderIndicesArr[stickyIndexInArray + 1];
+  if (nextStickyIndex === void 0) {
+    return void 0;
+  }
+  const nextStickyPosition = state.positions[nextStickyIndex];
+  if (nextStickyPosition === void 0) {
+    return void 0;
+  }
+  return nextStickyPosition - currentSize;
+}
+var useAnimatedValue = (initialValue) => {
+  const [animAnimatedValue] = useState(() => new Animated.Value(initialValue));
+  return animAnimatedValue;
+};
+
+// src/hooks/useValue$.ts
+function useValue$(key, params) {
+  const { getValue } = params || {};
+  const ctx = useStateContext();
+  const getNewValue = () => {
+    var _a3;
+    return (_a3 = getValue ? getValue(peek$(ctx, key)) : peek$(ctx, key)) != null ? _a3 : 0;
+  };
+  const animValue = useAnimatedValue(getNewValue());
+  useLayoutEffect(() => {
+    const syncCurrentValue = () => {
+      animValue.setValue(getNewValue());
+    };
+    const unsubscribe = listen$(ctx, key, syncCurrentValue);
+    syncCurrentValue();
+    return unsubscribe;
+  }, [animValue, ctx, key]);
+  return animValue;
+}
+var getComponent = (Component) => {
+  if (React2.isValidElement(Component)) {
+    return Component;
+  }
+  if (Component) {
+    return /* @__PURE__ */ React2.createElement(Component, null);
+  }
+  return null;
+};
+
+// src/components/PositionView.native.tsx
+var PositionViewState = typedMemo(function PositionViewState2({
+  id,
+  horizontal,
+  style,
+  refView,
+  ...rest
+}) {
+  const [position = POSITION_OUT_OF_VIEW, _itemKey] = useArr$([`containerPosition${id}`, `containerItemKey${id}`]);
+  return /* @__PURE__ */ React2.createElement(View$1, { ref: refView, style: [style, horizontal ? { left: position } : { top: position }], ...rest });
+});
+var PositionViewAnimated = typedMemo(function PositionViewAnimated2({
+  id,
+  horizontal,
+  style,
+  refView,
+  ...rest
+}) {
+  const position$ = useValue$(`containerPosition${id}`, {
+    getValue: (v) => v != null ? v : POSITION_OUT_OF_VIEW
+  });
+  const position = horizontal ? { left: position$ } : { top: position$ };
+  return /* @__PURE__ */ React2.createElement(Animated.View, { ref: refView, style: [style, position], ...rest });
+});
+var PositionViewSticky = typedMemo(function PositionViewSticky2({
+  id,
+  horizontal,
+  style,
+  refView,
+  animatedScrollY,
+  stickyHeaderConfig,
+  children,
+  ...rest
+}) {
+  const ctx = useStateContext();
+  const [
+    position = POSITION_OUT_OF_VIEW,
+    alignItemsAtEndPadding = 0,
+    headerSize = 0,
+    stylePaddingTop = 0,
+    itemKey,
+    itemIndex,
+    _totalSize = 0
+  ] = useArr$([
+    `containerPosition${id}`,
+    "alignItemsAtEndPadding",
+    "headerSize",
+    "stylePaddingTop",
+    `containerItemKey${id}`,
+    `containerItemIndex${id}`,
+    "totalSize"
+  ]);
+  const pushLimit = React2.useMemo(
+    () => getStickyPushLimit(ctx.state, itemIndex, itemKey),
+    [ctx.state, itemIndex, itemKey, _totalSize]
+  );
+  const transform = React2.useMemo(() => {
+    var _a3;
+    if (animatedScrollY) {
+      const stickyConfigOffset = (_a3 = stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.offset) != null ? _a3 : 0;
+      const stickyStart = position + headerSize + stylePaddingTop + alignItemsAtEndPadding - stickyConfigOffset;
+      let nextStickyPosition;
+      if (pushLimit !== void 0) {
+        if (pushLimit <= position) {
+          nextStickyPosition = pushLimit;
+        } else {
+          nextStickyPosition = animatedScrollY.interpolate({
+            extrapolateLeft: "clamp",
+            extrapolateRight: "clamp",
+            inputRange: [stickyStart, stickyStart + (pushLimit - position)],
+            outputRange: [position, pushLimit]
+          });
+        }
+      } else {
+        nextStickyPosition = animatedScrollY.interpolate({
+          extrapolateLeft: "clamp",
+          extrapolateRight: "extend",
+          inputRange: [stickyStart, stickyStart + 5e3],
+          outputRange: [position, position + 5e3]
+        });
+      }
+      return horizontal ? [{ translateX: nextStickyPosition }] : [{ translateY: nextStickyPosition }];
+    }
+  }, [
+    alignItemsAtEndPadding,
+    animatedScrollY,
+    headerSize,
+    position,
+    pushLimit,
+    stylePaddingTop,
+    stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.offset
+  ]);
+  const viewStyle = React2.useMemo(
+    () => [style, { zIndex: itemIndex + 1e3 }, { transform }],
+    [style, itemIndex, transform]
+  );
+  const renderStickyHeaderBackdrop = React2.useMemo(() => {
+    if (!(stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.backdropComponent)) {
+      return null;
+    }
+    return /* @__PURE__ */ React2.createElement(
+      View$1,
+      {
+        style: {
+          inset: 0,
+          pointerEvents: "none",
+          position: "absolute"
+        }
+      },
+      getComponent(stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.backdropComponent)
+    );
+  }, [stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.backdropComponent]);
+  return /* @__PURE__ */ React2.createElement(Animated.View, { ref: refView, style: viewStyle, ...rest }, renderStickyHeaderBackdrop, children);
+});
+var PositionView = IsNewArchitecture ? PositionViewState : PositionViewAnimated;
+function useInit(cb) {
+  useState(() => cb());
+}
+
+// src/state/ContextContainer.ts
+var ContextContainer = createContext(null);
+var NO_CONTAINER_ID = -1;
+function useContextContainer() {
+  return useContext(ContextContainer);
+}
+function useContainerItemSignals(containerContext) {
+  var _a3;
+  const containerId = (_a3 = containerContext == null ? void 0 : containerContext.containerId) != null ? _a3 : NO_CONTAINER_ID;
+  const [itemKey, itemIndex, item] = useArr$([
+    `containerItemKey${containerId}`,
+    `containerItemIndex${containerId}`,
+    `containerItemData${containerId}`
+  ]);
+  return {
+    hasItemInfo: !!containerContext && itemKey !== void 0 && itemIndex !== void 0,
+    item,
+    itemIndex,
+    itemKey
+  };
+}
+function useAdaptiveRender() {
+  const [mode] = useArr$(["adaptiveRender"]);
+  return mode;
+}
+function useAdaptiveRenderChange(callback) {
+  const ctx = useStateContext();
+  const callbackRef = useRef(callback);
+  callbackRef.current = callback;
+  useLayoutEffect(() => {
+    let mode = peek$(ctx, "adaptiveRender");
+    return listen$(ctx, "adaptiveRender", (nextMode) => {
+      if (mode !== nextMode) {
+        mode = nextMode;
+        callbackRef.current(nextMode);
+      }
+    });
+  }, [ctx]);
+}
+function useViewability(callback, configId) {
+  const ctx = useStateContext();
+  const containerContext = useContextContainer();
+  useInit(() => {
+    if (!containerContext) {
+      return;
+    }
+    const { containerId } = containerContext;
+    const key = containerId + (configId != null ? configId : "");
+    const value = ctx.mapViewabilityValues.get(key);
+    if (value) {
+      callback(value);
+    }
+  });
+  useEffect(() => {
+    if (!containerContext) {
+      return;
+    }
+    const { containerId } = containerContext;
+    const key = containerId + (configId != null ? configId : "");
+    ctx.mapViewabilityCallbacks.set(key, callback);
+    return () => {
+      ctx.mapViewabilityCallbacks.delete(key);
+    };
+  }, [ctx, callback, configId, containerContext]);
+}
+function useViewabilityAmount(callback) {
+  const ctx = useStateContext();
+  const containerContext = useContextContainer();
+  useInit(() => {
+    if (!containerContext) {
+      return;
+    }
+    const { containerId } = containerContext;
+    const value = ctx.mapViewabilityAmountValues.get(containerId);
+    if (value) {
+      callback(value);
+    }
+  });
+  useEffect(() => {
+    if (!containerContext) {
+      return;
+    }
+    const { containerId } = containerContext;
+    ctx.mapViewabilityAmountCallbacks.set(containerId, callback);
+    return () => {
+      ctx.mapViewabilityAmountCallbacks.delete(containerId);
+    };
+  }, [ctx, callback, containerContext]);
+}
+function useRecyclingEffect(effect) {
+  const containerContext = useContextContainer();
+  const { hasItemInfo, item, itemIndex, itemKey } = useContainerItemSignals(containerContext);
+  const prevInfo = useRef(void 0);
+  useEffect(() => {
+    if (!hasItemInfo) {
+      return;
+    }
+    let ret;
+    if (prevInfo.current) {
+      ret = effect({
+        index: itemIndex,
+        item,
+        prevIndex: prevInfo.current.index,
+        prevItem: prevInfo.current.item
+      });
     }
-    onItemSizeChanged == null ? void 0 : onItemSizeChanged({
-      index,
-      itemData: state.props.data[index],
-      itemKey,
-      previous: size - diff,
-      size
-    });
-    maybeUpdateAnchoredEndSpace(ctx);
-  }
-  if (minIndexSizeChanged !== void 0) {
-    state.minIndexSizeChanged = state.minIndexSizeChanged !== void 0 ? Math.min(state.minIndexSizeChanged, minIndexSizeChanged) : minIndexSizeChanged;
-  }
-  updateOtherAxisSizeIfNeeded(ctx, sizeObj, horizontal);
-  if (didContainersLayout || checkAllSizesKnown(state, state.startBuffered, state.endBuffered)) {
-    const canMaintainScrollAtEnd = shouldMaintainScrollAtEnd && !!(maintainScrollAtEnd == null ? void 0 : maintainScrollAtEnd.onItemLayout);
-    return {
-      didChange: diff !== 0,
-      didMeasureUserScrollAnchorResetItem,
-      needsRecalculate,
-      shouldMaintainScrollAtEnd: canMaintainScrollAtEnd
+    prevInfo.current = {
+      index: itemIndex,
+      item
     };
-  }
-  return {
-    didChange: diff !== 0,
-    didMeasureUserScrollAnchorResetItem
-  };
+    return ret;
+  }, [effect, hasItemInfo, itemIndex, item, itemKey]);
 }
-function updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
-  var _a3, _b, _c;
-  const state = ctx.state;
-  const {
-    indexByKey,
-    sizesKnown,
-    averageSizes,
-    props: { data, horizontal, getItemType, getFixedItemSize }
-  } = state;
-  if (!data) return 0;
-  const index = indexByKey.get(itemKey);
-  const itemData = (_a3 = resolvedMeasurementItem == null ? void 0 : resolvedMeasurementItem.itemData) != null ? _a3 : data[index];
-  let itemType = resolvedMeasurementItem == null ? void 0 : resolvedMeasurementItem.itemType;
-  let fixedItemSize = resolvedMeasurementItem == null ? void 0 : resolvedMeasurementItem.fixedItemSize;
-  if (getFixedItemSize && !(resolvedMeasurementItem == null ? void 0 : resolvedMeasurementItem.didResolveFixedItemSize)) {
-    itemType = getItemType ? (_b = getItemType(itemData, index)) != null ? _b : "" : "";
-    fixedItemSize = getFixedItemSize(itemData, index, itemType);
-  }
-  const resolvedItemSize = (resolvedMeasurementItem == null ? void 0 : resolvedMeasurementItem.didResolveFixedItemSize) || itemType !== void 0 || fixedItemSize !== void 0 ? {
-    didResolveFixedItemSize: resolvedMeasurementItem == null ? void 0 : resolvedMeasurementItem.didResolveFixedItemSize,
-    fixedItemSize,
-    itemType
-  } : void 0;
-  const prevSize = getItemSize(ctx, itemKey, index, itemData, void 0, void 0, void 0, resolvedItemSize);
-  const rawSize = horizontal ? sizeObj.width : sizeObj.height;
-  const prevSizeKnown = sizesKnown.get(itemKey);
-  if (Platform.OS !== "web" && prevSizeKnown !== void 0 && isNativeLayoutNoise(rawSize - prevSizeKnown)) {
-    return 0;
-  }
-  const size = Platform.OS === "web" ? Math.round(rawSize) : roundSize(rawSize);
-  sizesKnown.set(itemKey, size);
-  if (fixedItemSize === void 0 && size > 0) {
-    itemType != null ? itemType : itemType = getItemType ? (_c = getItemType(itemData, index)) != null ? _c : "" : "";
-    let averages = averageSizes[itemType];
-    if (!averages) {
-      averages = averageSizes[itemType] = { avg: 0, num: 0 };
-    }
-    if (averages.num === 0) {
-      averages.avg = size;
-      averages.num++;
-    } else if (prevSizeKnown !== void 0 && prevSizeKnown > 0) {
-      averages.avg += (size - prevSizeKnown) / averages.num;
-    } else {
-      averages.avg = (averages.avg * averages.num + size) / (averages.num + 1);
-      averages.num++;
+function useRecyclingState(valueOrFun) {
+  const containerContext = useContextContainer();
+  const { hasItemInfo, item, itemIndex, itemKey } = useContainerItemSignals(containerContext);
+  const computeValue = () => {
+    if (isFunction(valueOrFun)) {
+      const initializer = valueOrFun;
+      return hasItemInfo ? initializer({
+        index: itemIndex,
+        item,
+        prevIndex: void 0,
+        prevItem: void 0
+      }) : initializer();
     }
+    return valueOrFun;
+  };
+  const [stateValue, setStateValue] = useState(() => {
+    return computeValue();
+  });
+  const prevItemKeyRef = useRef(hasItemInfo ? itemKey : null);
+  if (hasItemInfo && prevItemKeyRef.current !== itemKey) {
+    prevItemKeyRef.current = itemKey;
+    setStateValue(computeValue());
   }
-  if (!prevSize || Math.abs(prevSize - size) > 0.1) {
-    setSize(ctx, itemKey, size);
-    return size - prevSize;
-  }
-  return 0;
+  const triggerLayout = containerContext == null ? void 0 : containerContext.triggerLayout;
+  const setState = useCallback(
+    (newState) => {
+      if (!triggerLayout) {
+        return;
+      }
+      setStateValue((prevValue) => {
+        return isFunction(newState) ? newState(prevValue) : newState;
+      });
+      triggerLayout();
+    },
+    [triggerLayout]
+  );
+  return [stateValue, setState];
+}
+function useIsLastItem() {
+  var _a3;
+  const containerContext = useContextContainer();
+  const containerId = (_a3 = containerContext == null ? void 0 : containerContext.containerId) != null ? _a3 : NO_CONTAINER_ID;
+  const [itemKey] = useArr$([`containerItemKey${containerId}`]);
+  const isLast = useSelector$("lastItemKeys", (lastItemKeys) => {
+    if (containerContext && !isNullOrUndefined(itemKey)) {
+      return (lastItemKeys == null ? void 0 : lastItemKeys.includes(itemKey)) || false;
+    }
+    return false;
+  });
+  return isLast;
+}
+function useListScrollSize() {
+  const [scrollSize] = useArr$(["scrollSize"]);
+  return scrollSize;
+}
+var noop = () => {
+};
+function useSyncLayout() {
+  const containerContext = useContextContainer();
+  return IsNewArchitecture && containerContext ? containerContext.triggerLayout : noop;
+}
+
+// src/components/Separator.tsx
+function Separator({ ItemSeparatorComponent, leadingItem }) {
+  const isLastItem = useIsLastItem();
+  return isLastItem ? null : /* @__PURE__ */ React2.createElement(ItemSeparatorComponent, { leadingItem });
 }
 function useOnLayoutSync({
   ref,
+  measureInLayoutEffect = true,
   onLayoutProp,
   onLayoutChange
 }, deps = []) {
@@ -5122,16 +5334,154 @@ function useOnLayoutSync({
   );
   if (IsNewArchitecture) {
     useLayoutEffect(() => {
-      if (ref.current) {
+      if (measureInLayoutEffect && ref.current) {
         ref.current.measure((x, y, width, height) => {
           onLayoutChange({ height, width, x, y }, true);
         });
       }
-    }, deps);
+    }, [measureInLayoutEffect, ...deps]);
   }
   return { onLayout };
 }
 
+// src/hooks/useContainerMeasurement.tsx
+var pendingWebShrinkMeasurements = /* @__PURE__ */ new Map();
+var pendingWebShrinkFrame;
+function cancelWebShrinkMeasurement(state) {
+  pendingWebShrinkMeasurements.delete(state);
+}
+function scheduleWebShrinkMeasurement(state, confirmMeasurement) {
+  pendingWebShrinkMeasurements.set(state, confirmMeasurement);
+  if (pendingWebShrinkFrame === void 0) {
+    pendingWebShrinkFrame = requestAnimationFrame(() => {
+      const callbacks = Array.from(pendingWebShrinkMeasurements.values());
+      pendingWebShrinkMeasurements.clear();
+      pendingWebShrinkFrame = void 0;
+      batchItemSizeUpdates(() => {
+        for (const callback of callbacks) {
+          callback();
+        }
+      });
+    });
+  }
+}
+function processContainerLayout({ containerId, ctx, rectangle, ref, state }) {
+  var _a3, _b;
+  const listState = ctx.state;
+  const currentItemKey = state.itemKey;
+  state.didLayout = true;
+  let layout = rectangle;
+  const axis = state.horizontal ? "width" : "height";
+  const size = roundSize(rectangle[axis]);
+  const localPreviousSize = state.lastSize ? roundSize(state.lastSize[axis]) : void 0;
+  const coreKnownSize = listState.sizesKnown.get(currentItemKey);
+  const previousSize = Platform.OS === "web" ? coreKnownSize : localPreviousSize;
+  const applyLayout = () => {
+    state.lastSize = layout;
+    updateItemSizes(ctx, {
+      containerId,
+      itemKey: currentItemKey,
+      size: layout
+    });
+  };
+  const shouldDeferWebShrinkLayoutUpdate = Platform.OS === "web" && !isInMVCPActiveMode(listState) && previousSize !== void 0 && size + 1 < previousSize;
+  if (shouldDeferWebShrinkLayoutUpdate) {
+    scheduleWebShrinkMeasurement(state, () => {
+      var _a4;
+      if (state.itemKey === currentItemKey) {
+        const element = ref.current;
+        const rect = (_a4 = element == null ? void 0 : element.getBoundingClientRect) == null ? void 0 : _a4.call(element);
+        if (rect) {
+          layout = { height: rect.height, width: rect.width };
+        }
+        applyLayout();
+      }
+    });
+  } else {
+    if (Platform.OS === "web") {
+      cancelWebShrinkMeasurement(state);
+    }
+    if (IsNewArchitecture || size > 0) {
+      applyLayout();
+    } else {
+      (_b = (_a3 = ref.current) == null ? void 0 : _a3.measure) == null ? void 0 : _b.call(_a3, (_x, _y, width, height) => {
+        layout = { height, width };
+        applyLayout();
+      });
+    }
+  }
+}
+function useContainerMeasurement({
+  containerId,
+  ctx,
+  horizontal,
+  itemKey,
+  ref
+}) {
+  const stateRef = useRef({
+    didLayout: false,
+    horizontal,
+    itemKey
+  });
+  stateRef.current.horizontal = horizontal;
+  stateRef.current.itemKey = itemKey;
+  const [layoutRenderCount, forceLayoutRender] = useState(0);
+  const onLayoutChange = useCallback(
+    (rectangle) => {
+      processContainerLayout({ containerId, ctx, rectangle, ref, state: stateRef.current });
+    },
+    [containerId, ctx, ref]
+  );
+  const triggerLayout = useCallback(() => {
+    if (IsNewArchitecture) {
+      scheduleContainerLayout(ctx, containerId);
+    } else {
+      forceLayoutRender((value) => value + 1);
+    }
+  }, [containerId, ctx]);
+  useLayoutEffect(() => {
+    ctx.containerLayoutTriggers.set(containerId, triggerLayout);
+    return () => {
+      cancelWebShrinkMeasurement(stateRef.current);
+      if (ctx.containerLayoutTriggers.get(containerId) === triggerLayout) {
+        ctx.containerLayoutTriggers.delete(containerId);
+      }
+    };
+  }, [containerId, ctx, triggerLayout]);
+  useLayoutEffect(() => {
+    if (IsNewArchitecture) {
+      scheduleContainerLayout(ctx, containerId);
+    }
+  });
+  const { onLayout } = useOnLayoutSync(
+    {
+      measureInLayoutEffect: !IsNewArchitecture,
+      onLayoutChange,
+      ref},
+    [itemKey, layoutRenderCount]
+  );
+  useEffect(() => {
+    if (!IsNewArchitecture) {
+      stateRef.current.didLayout = false;
+      const timeout = setTimeout(() => {
+        const state = stateRef.current;
+        if (!state.didLayout && state.lastSize) {
+          updateItemSizes(ctx, {
+            containerId,
+            itemKey: state.itemKey,
+            size: state.lastSize
+          });
+          state.didLayout = true;
+        }
+      }, 16);
+      return () => {
+        clearTimeout(timeout);
+      };
+    }
+  }, [containerId, ctx, itemKey]);
+  return { onLayout, triggerLayout };
+}
+
 // src/components/Container.tsx
 function getContainerPositionStyle({
   columnWrapperStyle,
@@ -5202,16 +5552,14 @@ var Container = typedMemo(function Container2({
     "extraData",
     `containerSticky${id}`
   ]);
-  const itemLayoutRef = useRef({
-    didLayout: false,
+  const ref = useRef(null);
+  const { onLayout, triggerLayout } = useContainerMeasurement({
+    containerId: id,
+    ctx,
     horizontal,
     itemKey,
-    pendingShrinkToken: 0
+    ref
   });
-  itemLayoutRef.current.horizontal = horizontal;
-  itemLayoutRef.current.itemKey = itemKey;
-  const ref = useRef(null);
-  const [layoutRenderCount, forceLayoutRender] = useState(0);
   const resolvedColumn = column > 0 ? column : 1;
   const resolvedSpan = Math.min(Math.max(span || 1, 1), numColumns);
   const otherAxisPos = numColumns > 1 ? `${(resolvedColumn - 1) / numColumns * 100}%` : 0;
@@ -5242,111 +5590,14 @@ var Container = typedMemo(function Container2({
     () => itemKey !== void 0 ? getRenderedItem2(itemKey) : null,
     [itemKey, data, extraData]
   );
-  const { index, renderedItem } = renderedItemInfo || {};
-  const onLayoutChange = useCallback((rectangle, fromLayoutEffect) => {
-    var _a3, _b;
-    const {
-      horizontal: currentHorizontal,
-      itemKey: currentItemKey,
-      lastSize,
-      pendingShrinkToken
-    } = itemLayoutRef.current;
-    if (isNullOrUndefined(currentItemKey)) {
-      return;
-    }
-    itemLayoutRef.current.didLayout = true;
-    let layout = rectangle;
-    const axis = currentHorizontal ? "width" : "height";
-    const size = roundSize(rectangle[axis]);
-    const prevSize = lastSize ? roundSize(lastSize[axis]) : void 0;
-    const doUpdate = () => {
-      itemLayoutRef.current.lastSize = layout;
-      updateItemSizes(ctx, {
-        containerId: id,
-        fromLayoutEffect,
-        itemKey: currentItemKey,
-        size: layout
-      });
-      itemLayoutRef.current.didLayout = true;
-    };
-    const shouldDeferWebShrinkLayoutUpdate = Platform.OS === "web" && !isInMVCPActiveMode(ctx.state) && prevSize !== void 0 && size + 1 < prevSize;
-    if (shouldDeferWebShrinkLayoutUpdate) {
-      const token = pendingShrinkToken + 1;
-      itemLayoutRef.current.pendingShrinkToken = token;
-      requestAnimationFrame(() => {
-        var _a4;
-        if (itemLayoutRef.current.pendingShrinkToken !== token) {
-          return;
-        }
-        const element = ref.current;
-        const rect = (_a4 = element == null ? void 0 : element.getBoundingClientRect) == null ? void 0 : _a4.call(element);
-        if (rect) {
-          layout = { height: rect.height, width: rect.width };
-        }
-        doUpdate();
-      });
-      return;
-    }
-    if (IsNewArchitecture || size > 0) {
-      doUpdate();
-    } else {
-      (_b = (_a3 = ref.current) == null ? void 0 : _a3.measure) == null ? void 0 : _b.call(_a3, (_x, _y, width, height) => {
-        layout = { height, width };
-        doUpdate();
-      });
-    }
-  }, []);
-  const triggerLayout = useCallback(() => {
-    forceLayoutRender((v) => v + 1);
-  }, []);
+  const { renderedItem } = renderedItemInfo || {};
   const contextValue = useMemo(() => {
     ctx.viewRefs.set(id, ref);
     return {
       containerId: id,
-      index,
-      itemKey,
-      triggerLayout,
-      value: data
-    };
-  }, [id, itemKey, index, data, triggerLayout]);
-  useLayoutEffect(() => {
-    ctx.containerLayoutTriggers.set(id, triggerLayout);
-    return () => {
-      if (ctx.containerLayoutTriggers.get(id) === triggerLayout) {
-        ctx.containerLayoutTriggers.delete(id);
-      }
+      triggerLayout
     };
-  }, [ctx, id, triggerLayout]);
-  const { onLayout } = useOnLayoutSync(
-    {
-      onLayoutChange,
-      ref},
-    [itemKey, layoutRenderCount]
-  );
-  if (!IsNewArchitecture) {
-    useEffect(() => {
-      if (!isNullOrUndefined(itemKey)) {
-        itemLayoutRef.current.didLayout = false;
-        const timeout = setTimeout(() => {
-          if (!itemLayoutRef.current.didLayout) {
-            const { itemKey: currentItemKey, lastSize } = itemLayoutRef.current;
-            if (lastSize && !isNullOrUndefined(currentItemKey)) {
-              updateItemSizes(ctx, {
-                containerId: id,
-                fromLayoutEffect: false,
-                itemKey: currentItemKey,
-                size: lastSize
-              });
-              itemLayoutRef.current.didLayout = true;
-            }
-          }
-        }, 16);
-        return () => {
-          clearTimeout(timeout);
-        };
-      }
-    }, [itemKey]);
-  }
+  }, [id, triggerLayout]);
   const PositionComponent = isSticky ? stickyPositionComponentInternal ? stickyPositionComponentInternal : PositionViewSticky : positionComponentInternal ? positionComponentInternal : PositionView;
   return /* @__PURE__ */ React2.createElement(
     PositionComponent,
@@ -5354,7 +5605,6 @@ var Container = typedMemo(function Container2({
       animatedScrollY: isSticky ? animatedScrollY : void 0,
       horizontal,
       id,
-      index,
       key: recycleItems ? void 0 : itemKey,
       onLayout,
       refView: ref,
@@ -5428,7 +5678,7 @@ var ContainersLayer = typedMemo(function ContainersLayer2({ children, horizontal
       }
     }
   }
-  return /* @__PURE__ */ React2.createElement(Animated.View, { style }, children);
+  return /* @__PURE__ */ React2.createElement(Animated.View, { style }, /* @__PURE__ */ React2.createElement(ContainerLayoutCoordinator, null, children));
 });
 var Containers = typedMemo(function Containers2({
   horizontal,
@@ -5615,6 +5865,8 @@ var ListComponent = typedMemo(function ListComponent2({
   refScrollView,
   renderScrollComponent,
   onLayoutFooter,
+  onInternalScrollBeginDrag,
+  onInternalScrollEnd,
   scrollAdjustHandler,
   snapToIndices,
   stickyHeaderConfig,
@@ -5676,7 +5928,7 @@ var ListComponent = typedMemo(function ListComponent2({
     SnapOrScroll,
     {
       ...rest,
-      ...ScrollComponent === ListComponentScrollView ? { useWindowScroll } : {},
+      ...Platform.OS === "web" ? ScrollComponent === ListComponentScrollView ? { onInternalScrollEnd, useWindowScroll } : {} : { onScrollBeginDrag: onInternalScrollBeginDrag },
       contentContainerStyle: [
         horizontal ? {
           height: "100%"
@@ -5782,6 +6034,7 @@ function checkResetContainers(ctx, dataProp, { didColumnsChange = false } = {})
   if (didColumnsChange) {
     state.sizes.clear();
     state.sizesKnown.clear();
+    invalidateContainerFixedItemSizes(state);
     for (const key in state.averageSizes) {
       delete state.averageSizes[key];
     }
@@ -6028,7 +6281,7 @@ function onScroll(ctx, event) {
     }
   }
   state.scrollPending = newScroll;
-  updateScroll(ctx, newScroll, insetChanged);
+  updateScroll(ctx, newScroll, insetChanged, { fromNativeScrollEvent: true });
   trackInitialScrollNativeProgress(state, newScroll);
   clearFinishedBootstrapInitialScrollTargetIfMovedAway(ctx);
   if (state.scrollingTo) {
@@ -6204,8 +6457,12 @@ function getAverageItemSizes(state) {
   return averageItemSizes;
 }
 function triggerMountedContainerLayouts(ctx) {
-  for (const triggerLayout of ctx.containerLayoutTriggers.values()) {
-    triggerLayout();
+  if (IsNewArchitecture) {
+    scheduleContainerLayout(ctx);
+  } else {
+    for (const triggerLayout of ctx.containerLayoutTriggers.values()) {
+      triggerLayout();
+    }
   }
 }
 function createImperativeHandle(ctx, scheduleImperativeScrollCommit) {
@@ -6318,6 +6575,7 @@ function createImperativeHandle(ctx, scheduleImperativeScrollCommit) {
     const mode = (_a3 = options == null ? void 0 : options.mode) != null ? _a3 : "sizes";
     state.sizes.clear();
     state.sizesKnown.clear();
+    invalidateContainerFixedItemSizes(state);
     for (const key in state.averageSizes) {
       delete state.averageSizes[key];
     }
@@ -6339,6 +6597,10 @@ function createImperativeHandle(ctx, scheduleImperativeScrollCommit) {
   return {
     clearCaches,
     flashScrollIndicators: () => refScroller.current.flashScrollIndicators(),
+    getAnimatableRef: () => {
+      var _a3, _b, _c;
+      return (_c = (_b = (_a3 = refScroller.current).getNativeScrollRef) == null ? void 0 : _b.call(_a3)) != null ? _c : refScroller.current;
+    },
     getNativeScrollRef: () => refScroller.current,
     getScrollableNode: () => refScroller.current.getScrollableNode(),
     getScrollResponder: () => refScroller.current.getScrollResponder(),
@@ -6709,6 +6971,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     onMomentumScrollEnd,
     onRefresh,
     onScroll: onScrollProp,
+    onScrollBeginDrag,
     onStartReached,
     onStartReachedThreshold = 0.5,
     onStickyHeaderChange,
@@ -6820,8 +7083,9 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         averageSizes: {},
         columnSpans: [],
         columns: [],
+        containerItemGenerations: [],
         containerItemKeys: /* @__PURE__ */ new Map(),
-        containerItemTypes: /* @__PURE__ */ new Map(),
+        containerItemMetadata: /* @__PURE__ */ new Map(),
         contentInsetOverride: void 0,
         dataChangeEpoch: 0,
         dataChangeNeedsScrollUpdate: false,
@@ -6874,7 +7138,6 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         startBuffered: -1,
         startNoBuffer: -1,
         startReachedSnapshot: void 0,
-        startReachedSnapshotDataChangeEpoch: void 0,
         stickyContainerPool: /* @__PURE__ */ new Set(),
         stickyContainers: /* @__PURE__ */ new Map(),
         timeoutAdaptiveRender: void 0,
@@ -6950,7 +7213,9 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     onFirstVisibleItemChanged,
     onItemSizeChanged,
     onLoad,
+    onMomentumScrollEnd,
     onScroll: throttleScrollFn,
+    onScrollBeginDrag,
     onStartReached,
     onStartReachedThreshold,
     onStickyHeaderChange,
@@ -7233,11 +7498,17 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       getRenderedItem: (key) => getRenderedItem(ctx, key),
       onMomentumScrollEnd: (event) => {
         checkFinishedScrollFallback(ctx);
-        if (onMomentumScrollEnd) {
-          onMomentumScrollEnd(event);
+        if (state.props.onMomentumScrollEnd) {
+          state.props.onMomentumScrollEnd(event);
         }
       },
-      onScroll: (event) => onScroll(ctx, event)
+      onScroll: (event) => onScroll(ctx, event),
+      onScrollBeginDrag: (event) => {
+        var _a4, _b2;
+        prepareReachedEdgeForNextUserScroll(ctx);
+        (_b2 = (_a4 = state.props).onScrollBeginDrag) == null ? void 0 : _b2.call(_a4, event);
+      },
+      onScrollEnd: () => prepareReachedEdgeForNextUserScroll(ctx)
     }),
     []
   );
@@ -7258,6 +7529,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       ListFooterComponent,
       ListFooterComponentStyle,
       ListHeaderComponent,
+      onInternalScrollBeginDrag: fns.onScrollBeginDrag,
+      onInternalScrollEnd: fns.onScrollEnd,
       onLayout,
       onLayoutFooter,
       onMomentumScrollEnd: fns.onMomentumScrollEnd,