@legendapp/list 3.0.0-beta.44 → 3.0.0-beta.45

package/reanimated.d.ts

@@ -1,18 +1,30 @@
 import * as React from 'react';
 import { Key, ComponentProps } from 'react';
-import Reanimated from 'react-native-reanimated';
+import Reanimated, { SharedValue } from 'react-native-reanimated';
 import { ScrollViewProps, NativeSyntheticEvent as NativeSyntheticEvent$1, NativeScrollEvent as NativeScrollEvent$1, ScrollView, StyleProp as StyleProp$1, ViewStyle as ViewStyle$1, ScrollViewComponent, ScrollResponderMixin, Insets as Insets$1 } from 'react-native';
 
-type ListenerType = "activeStickyIndex" | "debugComputedScroll" | "debugRawScroll" | "extraData" | "footerSize" | "headerSize" | "lastItemKeys" | "lastPositionUpdate" | "maintainVisibleContentPosition" | "numColumns" | "numContainers" | "numContainersPooled" | "otherAxisSize" | "readyToRender" | "scrollAdjust" | "scrollAdjustPending" | "scrollAdjustUserOffset" | "scrollSize" | "snapToOffsets" | "stylePaddingTop" | "totalSize" | `containerColumn${number}` | `containerSpan${number}` | `containerItemData${number}` | `containerItemKey${number}` | `containerPosition${number}` | `containerSticky${number}`;
-type LegendListListenerType = Extract<ListenerType, "activeStickyIndex" | "footerSize" | "headerSize" | "lastItemKeys" | "lastPositionUpdate" | "numContainers" | "numContainersPooled" | "otherAxisSize" | "readyToRender" | "snapToOffsets" | "totalSize">;
+interface MaintainVisibleContentPositionNormalized<ItemT = any> {
+    data: boolean;
+    size: boolean;
+    shouldRestorePosition?: (item: ItemT, index: number, data: readonly ItemT[]) => boolean;
+}
+
+type ListenerType = "activeStickyIndex" | "anchoredEndSpaceSize" | "debugComputedScroll" | "debugRawScroll" | "extraData" | "footerSize" | "headerSize" | "lastItemKeys" | "lastPositionUpdate" | "maintainVisibleContentPosition" | "numColumns" | "numContainers" | "numContainersPooled" | "otherAxisSize" | "readyToRender" | "scrollAdjust" | "scrollAdjustPending" | "scrollAdjustUserOffset" | "scrollSize" | "snapToOffsets" | "stylePaddingTop" | "totalSize" | "isAtEnd" | "isAtStart" | "isNearEnd" | "isNearStart" | "isWithinMaintainScrollAtEndThreshold" | `containerColumn${number}` | `containerSpan${number}` | `containerItemData${number}` | `containerItemKey${number}` | `containerPosition${number}` | `containerSticky${number}`;
+type LegendListListenerType = Extract<ListenerType, "activeStickyIndex" | "anchoredEndSpaceSize" | "footerSize" | "headerSize" | "isAtEnd" | "isAtStart" | "isNearEnd" | "isNearStart" | "isWithinMaintainScrollAtEndThreshold" | "lastItemKeys" | "lastPositionUpdate" | "numContainers" | "numContainersPooled" | "otherAxisSize" | "readyToRender" | "snapToOffsets" | "totalSize">;
 type ListenerTypeValueMap = {
     activeStickyIndex: number;
+    anchoredEndSpaceSize: number;
     animatedScrollY: any;
     debugComputedScroll: number;
     debugRawScroll: number;
     extraData: any;
     footerSize: number;
     headerSize: number;
+    isAtEnd: boolean;
+    isAtStart: boolean;
+    isNearEnd: boolean;
+    isNearStart: boolean;
+    isWithinMaintainScrollAtEndThreshold: boolean;
     lastItemKeys: string[];
     lastPositionUpdate: number;
     maintainVisibleContentPosition: MaintainVisibleContentPositionNormalized;
@@ -114,6 +126,11 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * Style applied to each column's wrapper view.
      */
     columnWrapperStyle?: ColumnWrapperStyle;
+    /**
+     * Version token that forces the list to treat data as updated even when the array reference is stable.
+     * Increment or change this when mutating the data array in place.
+     */
+    dataVersion?: Key;
     /**
      * Distance in pixels to pre-render items ahead of the visible area.
      * @default 250
@@ -137,33 +154,35 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * Extra data to trigger re-rendering when changed.
      */
     extraData?: any;
-    /**
-     * Version token that forces the list to treat data as updated even when the array reference is stable.
-     * Increment or change this when mutating the data array in place.
-     */
-    dataVersion?: Key;
     /**
      * In case you have distinct item sizes, you can provide a function to get the size of an item.
-     * Use instead of FlatList's getItemLayout or FlashList overrideItemLayout if you want to have accurate initialScrollOffset, you should provide this function
      */
     getEstimatedItemSize?: (item: ItemT, index: number, type: TItemType) => number;
     /**
-     * Customize layout for multi-column lists, such as allowing items to span multiple columns.
-     * Similar to FlashList's overrideItemLayout.
+     * In case items always have a fixed size, you can provide a function to return it.
      */
-    overrideItemLayout?: (layout: {
-        span?: number;
-    }, item: ItemT, index: number, maxColumns: number, extraData?: any) => void;
+    getFixedItemSize?: (item: ItemT, index: number, type: TItemType) => number | undefined;
+    /**
+     * Returns a stable item type used for pooling and size estimation.
+     */
+    getItemType?: (item: ItemT, index: number) => TItemType;
+    /**
+     * Component to render between items, receiving the leading item as prop.
+     */
+    ItemSeparatorComponent?: React.ComponentType<{
+        leadingItem: ItemT;
+    }>;
     /**
      * Ratio of initial container pool size to data length (e.g., 0.5 for half).
      * @default 2
      */
     initialContainerPoolRatio?: number | undefined;
     /**
-     * Initial scroll position in pixels.
-     * @default 0
+     * When true, the list initializes scrolled to the last item.
+     * Overrides `initialScrollIndex` and `initialScrollOffset` when data is available.
+     * @default false
      */
-    initialScrollOffset?: number;
+    initialScrollAtEnd?: boolean;
     /**
      * Index to scroll to initially.
      * @default 0
@@ -174,17 +193,14 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
         viewPosition?: number | undefined;
     };
     /**
-     * When true, the list initializes scrolled to the last item.
-     * Overrides `initialScrollIndex` and `initialScrollOffset` when data is available.
-     * @default false
+     * Initial scroll position in pixels.
+     * @default 0
      */
-    initialScrollAtEnd?: boolean;
+    initialScrollOffset?: number;
     /**
-     * Component to render between items, receiving the leading item as prop.
+     * Custom equality function to detect semantically unchanged items.
      */
-    ItemSeparatorComponent?: React.ComponentType<{
-        leadingItem: ItemT;
-    }>;
+    itemsAreEqual?: (itemPrevious: ItemT, item: ItemT, index: number, data: readonly ItemT[]) => boolean;
     /**
      * Function to extract a unique key for each item.
      */
@@ -230,10 +246,9 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      */
     maintainVisibleContentPosition?: boolean | MaintainVisibleContentPositionConfig<ItemT>;
     /**
-     * Web only: when true, listens to window/body scrolling instead of rendering a scrollable list container.
-     * @default false
+     * Keeps an item visually anchored to the start by adding trailing space when the content below it underflows.
      */
-    useWindowScroll?: boolean;
+    anchoredEndSpace?: AnchoredEndSpaceConfig;
     /**
      * Number of columns to render items in.
      * @default 1
@@ -260,6 +275,12 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
         itemKey: string;
         itemData: ItemT;
     }) => void;
+    /**
+     * Called after the initial render work completes.
+     */
+    onLoad?: (info: {
+        elapsedTimeInMs: number;
+    }) => void;
     /**
      * Called when list layout metrics change.
      */
@@ -268,6 +289,9 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * Function to call when the user pulls to refresh.
      */
     onRefresh?: () => void;
+    /**
+     * Called when the list scrolls.
+     */
     onScroll?: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
     /**
      * Called when scrolling reaches the start within onStartReachedThreshold.
@@ -291,6 +315,12 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * Called when the viewability of items changes.
      */
     onViewableItemsChanged?: OnViewableItemsChanged<ItemT> | undefined;
+    /**
+     * Customize layout for multi-column lists, such as allowing items to span multiple columns.
+     */
+    overrideItemLayout?: (layout: {
+        span?: number;
+    }, item: ItemT, index: number, maxColumns: number, extraData?: any) => void;
     /**
      * Offset in pixels for the refresh indicator.
      * @default 0
@@ -316,6 +346,10 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * @default (props) => <ScrollView {...props} />
      */
     renderScrollComponent?: (props: any) => React.ReactElement | null;
+    /**
+     * Array of item indices to use as snap points.
+     */
+    snapToIndices?: number[];
     /**
      * This will log a suggested estimatedItemSize.
      * @required
@@ -330,10 +364,6 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * Pairs of viewability configs and their callbacks for tracking visibility.
      */
     viewabilityConfigCallbackPairs?: ViewabilityConfigCallbackPairs<ItemT> | undefined;
-    onLoad?: (info: {
-        elapsedTimeInMs: number;
-    }) => void;
-    snapToIndices?: number[];
     /**
      * Array of child indices determining which children get docked to the top of the screen when scrolling.
      * For example, passing stickyHeaderIndices={[0]} will cause the first child to be fixed to the top of the scroll view.
@@ -350,9 +380,11 @@ interface LegendListSpecificProps<ItemT, TItemType extends string | undefined> {
      * @default undefined
      */
     stickyHeaderConfig?: StickyHeaderConfig;
-    getItemType?: (item: ItemT, index: number) => TItemType;
-    getFixedItemSize?: (item: ItemT, index: number, type: TItemType) => number | undefined;
-    itemsAreEqual?: (itemPrevious: ItemT, item: ItemT, index: number, data: readonly ItemT[]) => boolean;
+    /**
+     * Web only: when true, listens to window/body scrolling instead of rendering a scrollable list container.
+     * @default false
+     */
+    useWindowScroll?: boolean;
 }
 type LegendListPropsBase<ItemT, TScrollViewProps = Record<string, any>, TItemType extends string | undefined = string | undefined> = BaseScrollViewProps<TScrollViewProps> & LegendListSpecificProps<ItemT, TItemType> & (DataModeProps<ItemT, TItemType> | ChildrenModeProps);
 interface MaintainVisibleContentPositionConfig<ItemT = any> {
@@ -360,10 +392,12 @@ interface MaintainVisibleContentPositionConfig<ItemT = any> {
     size?: boolean;
     shouldRestorePosition?: (item: ItemT, index: number, data: readonly ItemT[]) => boolean;
 }
-interface MaintainVisibleContentPositionNormalized<ItemT = any> {
-    data: boolean;
-    size: boolean;
-    shouldRestorePosition?: (item: ItemT, index: number, data: readonly ItemT[]) => boolean;
+interface AnchoredEndSpaceConfig {
+    anchorIndex: number;
+    anchorOffset?: number;
+    anchorMaxSize?: number;
+    includeInEndInset?: boolean;
+    onSizeChanged?: (size: number) => void;
 }
 interface StickyHeaderConfig {
     /**
@@ -426,8 +460,11 @@ type LegendListState = {
     endBuffered: number;
     isAtEnd: boolean;
     isAtStart: boolean;
+    isNearEnd: boolean;
+    isNearStart: boolean;
     isEndReached: boolean;
     isStartReached: boolean;
+    isWithinMaintainScrollAtEndThreshold: boolean;
     listen: <T extends LegendListListenerType>(listenerType: T, callback: (value: ListenerTypeValueMap[T]) => void) => () => void;
     listenToPosition: (key: string, callback: (value: number) => void) => () => void;
     positionAtIndex: (index: number) => number;
@@ -566,10 +603,15 @@ interface ViewabilityConfigCallbackPair<ItemT = any> {
     viewabilityConfig: ViewabilityConfig;
 }
 type ViewabilityConfigCallbackPairs<ItemT> = ViewabilityConfigCallbackPair<ItemT>[];
-type OnViewableItemsChanged<ItemT> = ((info: {
-    viewableItems: Array<ViewToken<ItemT>>;
+interface OnViewableItemsChangedInfo<ItemT> {
     changed: Array<ViewToken<ItemT>>;
-}) => void) | null;
+    end: number;
+    endBuffered: number;
+    start: number;
+    startBuffered: number;
+    viewableItems: Array<ViewToken<ItemT>>;
+}
+type OnViewableItemsChanged<ItemT> = ((info: OnViewableItemsChangedInfo<ItemT>) => void) | null;
 interface ViewabilityConfig {
     /**
      * A unique ID to identify this viewability config
@@ -600,7 +642,7 @@ interface ViewabilityConfig {
     waitForInteraction?: boolean | undefined;
 }
 
-type LegendListPropsOverrides<ItemT, TItemType extends string | undefined> = Omit<LegendListPropsBase<ItemT, ScrollViewProps, TItemType>, "onScroll" | "refScrollView" | "renderScrollComponent" | "ListHeaderComponentStyle" | "ListFooterComponentStyle"> & {
+type LegendListPropsOverrides<ItemT, TItemType extends string | undefined> = Omit<LegendListPropsBase<ItemT, ScrollViewProps, TItemType>, "anchoredEndSpace" | "onScroll" | "refScrollView" | "renderScrollComponent" | "ListHeaderComponentStyle" | "ListFooterComponentStyle"> & {
     onScroll?: (event: NativeSyntheticEvent$1<NativeScrollEvent$1>) => void;
     refScrollView?: React.Ref<ScrollView>;
     renderScrollComponent?: (props: ScrollViewProps) => React.ReactElement<ScrollViewProps>;
@@ -618,9 +660,19 @@ type KeysToOmit = "getEstimatedItemSize" | "getFixedItemSize" | "getItemType" |
 type PropsBase<ItemT> = LegendListProps<ItemT>;
 type AnimatedScrollView = React.ElementRef<typeof Reanimated.ScrollView>;
 type ReanimatedLayoutAnimation = ComponentProps<typeof Reanimated.View>["layout"];
+interface AnimatedLegendListSharedValues {
+    activeStickyIndex?: SharedValue<number>;
+    isAtEnd?: SharedValue<boolean>;
+    isAtStart?: SharedValue<boolean>;
+    isNearEnd?: SharedValue<boolean>;
+    isNearStart?: SharedValue<boolean>;
+    isWithinMaintainScrollAtEndThreshold?: SharedValue<boolean>;
+    scrollOffset?: SharedValue<number>;
+}
 interface AnimatedLegendListPropsBase<ItemT> extends Omit<PropsBase<ItemT>, KeysToOmit | "refScrollView"> {
     animatedProps?: ComponentProps<typeof Reanimated.ScrollView>["animatedProps"];
     refScrollView?: React.Ref<AnimatedScrollView>;
+    sharedValues?: AnimatedLegendListSharedValues;
     /**
      * Reanimated layout transition applied to each item container position view.
      * Example: `LinearTransition.duration(280)`.
@@ -634,4 +686,4 @@ type AnimatedLegendListDefinition = <ItemT>(props: AnimatedLegendListProps<ItemT
 }) => React.ReactElement | null;
 declare const AnimatedLegendList: AnimatedLegendListDefinition;
 
-export { AnimatedLegendList, type AnimatedLegendListProps, type AnimatedLegendListPropsBase };
+export { AnimatedLegendList, type AnimatedLegendListProps, type AnimatedLegendListPropsBase, type AnimatedLegendListSharedValues };

package/reanimated.js

@@ -29,9 +29,16 @@ var React__namespace = /*#__PURE__*/_interopNamespace(React);
 var Reanimated__default = /*#__PURE__*/_interopDefault(Reanimated);
 
 // src/integrations/reanimated.tsx
-var { POSITION_OUT_OF_VIEW, IsNewArchitecture, useArr$, useCombinedRef, getComponent } = reactNative.internal;
+var {
+  POSITION_OUT_OF_VIEW,
+  IsNewArchitecture,
+  getStickyPushLimit,
+  typedMemo,
+  useArr$,
+  useCombinedRef,
+  getComponent
+} = reactNative.internal;
 var { peek$, useStateContext } = reactNative.internal;
-var typedMemo = React.memo;
 var ReanimatedScrollBridge = typedMemo(function ReanimatedScrollBridgeComponent({
   forwardedRef,
   scrollOffset,
@@ -67,18 +74,27 @@ var StickyOverlay = typedMemo(function StickyOverlayComponent({ stickyHeaderConf
 });
 var ReanimatedPositionViewSticky = typedMemo(function ReanimatedPositionViewStickyComponent(props) {
   var _a;
+  const ctx = useStateContext();
   const { id, horizontal, style, refView, stickyScrollOffset, stickyHeaderConfig, index, children, ...rest } = props;
-  const [position = POSITION_OUT_OF_VIEW, headerSize = 0, stylePaddingTop = 0] = useArr$([
+  const [position = POSITION_OUT_OF_VIEW, headerSize = 0, stylePaddingTop = 0, itemKey, _totalSize = 0] = useArr$([
     `containerPosition${id}`,
     "headerSize",
-    "stylePaddingTop"
+    "stylePaddingTop",
+    `containerItemKey${id}`,
+    "totalSize"
   ]);
+  const pushLimit = React__namespace.useMemo(
+    () => getStickyPushLimit(ctx.state, index, itemKey),
+    [ctx.state, index, itemKey, _totalSize]
+  );
   const stickyOffset = (_a = stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.offset) != null ? _a : 0;
   const stickyStart = position + headerSize + stylePaddingTop - stickyOffset;
   const transformStyle = Reanimated.useAnimatedStyle(() => {
     const delta = Math.max(0, stickyScrollOffset.value - stickyStart);
-    return horizontal ? { transform: [{ translateX: position + delta }] } : { transform: [{ translateY: position + delta }] };
-  }, [horizontal, position, stickyStart]);
+    const stickyPosition = position + delta;
+    const resolvedPosition = pushLimit !== void 0 ? Math.min(stickyPosition, pushLimit) : stickyPosition;
+    return horizontal ? { transform: [{ translateX: resolvedPosition }] } : { transform: [{ translateY: resolvedPosition }] };
+  }, [horizontal, position, pushLimit, stickyStart]);
   const viewStyle = React__namespace.useMemo(
     () => [style, { zIndex: index + 1e3 }, transformStyle],
     [index, style, transformStyle]
@@ -116,18 +132,71 @@ var ReanimatedPositionView = typedMemo(function ReanimatedPositionViewComponent(
     children
   );
 });
+function setSharedValueValue(sharedValue, value) {
+  if (!sharedValue) {
+    return;
+  }
+  const sharedValueWithMethods = sharedValue;
+  const currentValue = typeof sharedValueWithMethods.get === "function" ? sharedValueWithMethods.get() : sharedValueWithMethods.value;
+  if (currentValue === value) {
+    return;
+  }
+  if (typeof sharedValueWithMethods.set === "function") {
+    sharedValueWithMethods.set(value);
+  } else {
+    sharedValueWithMethods.value = value;
+  }
+}
+function useAnimatedLegendListSharedValuesSync(legendList, sharedValues) {
+  React__namespace.useEffect(() => {
+    if (!legendList || !sharedValues) {
+      return;
+    }
+    const state = legendList.getState();
+    setSharedValueValue(sharedValues.activeStickyIndex, state.activeStickyIndex);
+    setSharedValueValue(sharedValues.isAtEnd, state.isAtEnd);
+    setSharedValueValue(sharedValues.isAtStart, state.isAtStart);
+    setSharedValueValue(sharedValues.isNearEnd, state.isNearEnd);
+    setSharedValueValue(sharedValues.isNearStart, state.isNearStart);
+    setSharedValueValue(
+      sharedValues.isWithinMaintainScrollAtEndThreshold,
+      state.isWithinMaintainScrollAtEndThreshold
+    );
+    setSharedValueValue(sharedValues.scrollOffset, state.scroll);
+    const unsubscribers = [
+      sharedValues.activeStickyIndex ? state.listen(
+        "activeStickyIndex",
+        (value) => setSharedValueValue(sharedValues.activeStickyIndex, value)
+      ) : void 0,
+      sharedValues.isAtEnd ? state.listen("isAtEnd", (value) => setSharedValueValue(sharedValues.isAtEnd, value)) : void 0,
+      sharedValues.isAtStart ? state.listen("isAtStart", (value) => setSharedValueValue(sharedValues.isAtStart, value)) : void 0,
+      sharedValues.isNearEnd ? state.listen("isNearEnd", (value) => setSharedValueValue(sharedValues.isNearEnd, value)) : void 0,
+      sharedValues.isNearStart ? state.listen("isNearStart", (value) => setSharedValueValue(sharedValues.isNearStart, value)) : void 0,
+      sharedValues.isWithinMaintainScrollAtEndThreshold ? state.listen(
+        "isWithinMaintainScrollAtEndThreshold",
+        (value) => setSharedValueValue(sharedValues.isWithinMaintainScrollAtEndThreshold, value)
+      ) : void 0
+    ];
+    return () => {
+      for (const unsubscribe of unsubscribers) {
+        unsubscribe == null ? void 0 : unsubscribe();
+      }
+    };
+  }, [legendList, sharedValues]);
+}
 var LegendListForwardedRef = typedMemo(
   // biome-ignore lint/nursery/noShadow: const function name shadowing is intentional
   React__namespace.forwardRef(function LegendListForwardedRef2(props, ref) {
-    const { itemLayoutAnimation, recycleItems, refLegendList, renderScrollComponent, ...rest } = props;
+    var _a;
+    const { itemLayoutAnimation, recycleItems, refLegendList, renderScrollComponent, sharedValues, ...rest } = props;
     const refFn = React.useCallback(
       (r) => {
         refLegendList(r);
       },
       [refLegendList]
     );
-    const stickyScrollOffset = Reanimated.useSharedValue(0);
-    const shouldUseReanimatedScrollView = IsNewArchitecture;
+    const internalScrollOffset = Reanimated.useSharedValue(0);
+    const scrollOffset = (_a = sharedValues == null ? void 0 : sharedValues.scrollOffset) != null ? _a : internalScrollOffset;
     const renderScrollComponentForBridge = React__namespace.useMemo(
       () => renderScrollComponent ? (scrollViewProps) => renderScrollComponent(scrollViewProps) : void 0,
       [renderScrollComponent]
@@ -141,17 +210,17 @@ var LegendListForwardedRef = typedMemo(
             ...restScrollViewProps,
             forwardedRef,
             renderScrollComponent: renderScrollComponentForBridge,
-            scrollOffset: stickyScrollOffset
+            scrollOffset
           }
         );
       },
-      [renderScrollComponentForBridge, stickyScrollOffset]
+      [renderScrollComponentForBridge, scrollOffset]
     );
     const stickyPositionComponentInternal = React__namespace.useMemo(
       () => function StickyPositionComponent(stickyProps) {
-        return /* @__PURE__ */ React__namespace.createElement(ReanimatedPositionViewSticky, { ...stickyProps, stickyScrollOffset });
+        return /* @__PURE__ */ React__namespace.createElement(ReanimatedPositionViewSticky, { ...stickyProps, stickyScrollOffset: scrollOffset });
       },
-      [stickyScrollOffset]
+      [scrollOffset]
     );
     const itemLayoutAnimationRef = React__namespace.useRef(itemLayoutAnimation);
     itemLayoutAnimationRef.current = itemLayoutAnimation;
@@ -175,10 +244,10 @@ var LegendListForwardedRef = typedMemo(
       ...rest,
       positionComponentInternal,
       recycleItems,
-      ...shouldUseReanimatedScrollView ? {
+      ...{
         renderScrollComponent: renderReanimatedScrollComponent,
-        stickyPositionComponentInternal
-      } : {}
+        ...IsNewArchitecture ? { stickyPositionComponentInternal } : {}
+      } 
     };
     return /* @__PURE__ */ React__namespace.createElement(reactNative.LegendList, { ref: refFn, refScrollView: ref, ...legendListProps });
   })
@@ -189,9 +258,15 @@ var AnimatedLegendList = typedMemo(
   // biome-ignore lint/nursery/noShadow: const function name shadowing is intentional
   React__namespace.forwardRef(function AnimatedLegendList2(props, ref) {
     const { refScrollView, ...rest } = props;
-    const { animatedProps } = props;
-    const refLegendList = React__namespace.useRef(null);
-    const combinedRef = useCombinedRef(refLegendList, ref);
+    const { animatedProps, sharedValues } = props;
+    const [legendList, setLegendList] = React__namespace.useState(null);
+    const combinedRef = useCombinedRef(
+      React__namespace.useCallback((instance) => {
+        setLegendList((prev) => prev === instance ? prev : instance);
+      }, []),
+      ref
+    );
+    useAnimatedLegendListSharedValuesSync(legendList, sharedValues);
     const forwardedProps = {
       ...rest,
       animatedPropsInternal: animatedProps,

package/reanimated.mjs

@@ -1,13 +1,20 @@
 import * as React from 'react';
-import { useCallback, memo } from 'react';
+import { useCallback } from 'react';
 import { View } from 'react-native';
 import Reanimated, { useAnimatedRef, useScrollViewOffset, useAnimatedStyle, useSharedValue } from 'react-native-reanimated';
 import { internal, LegendList } from '@legendapp/list/react-native';
 
 // src/integrations/reanimated.tsx
-var { POSITION_OUT_OF_VIEW, IsNewArchitecture, useArr$, useCombinedRef, getComponent } = internal;
+var {
+  POSITION_OUT_OF_VIEW,
+  IsNewArchitecture,
+  getStickyPushLimit,
+  typedMemo,
+  useArr$,
+  useCombinedRef,
+  getComponent
+} = internal;
 var { peek$, useStateContext } = internal;
-var typedMemo = memo;
 var ReanimatedScrollBridge = typedMemo(function ReanimatedScrollBridgeComponent({
   forwardedRef,
   scrollOffset,
@@ -43,18 +50,27 @@ var StickyOverlay = typedMemo(function StickyOverlayComponent({ stickyHeaderConf
 });
 var ReanimatedPositionViewSticky = typedMemo(function ReanimatedPositionViewStickyComponent(props) {
   var _a;
+  const ctx = useStateContext();
   const { id, horizontal, style, refView, stickyScrollOffset, stickyHeaderConfig, index, children, ...rest } = props;
-  const [position = POSITION_OUT_OF_VIEW, headerSize = 0, stylePaddingTop = 0] = useArr$([
+  const [position = POSITION_OUT_OF_VIEW, headerSize = 0, stylePaddingTop = 0, itemKey, _totalSize = 0] = useArr$([
     `containerPosition${id}`,
     "headerSize",
-    "stylePaddingTop"
+    "stylePaddingTop",
+    `containerItemKey${id}`,
+    "totalSize"
   ]);
+  const pushLimit = React.useMemo(
+    () => getStickyPushLimit(ctx.state, index, itemKey),
+    [ctx.state, index, itemKey, _totalSize]
+  );
   const stickyOffset = (_a = stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.offset) != null ? _a : 0;
   const stickyStart = position + headerSize + stylePaddingTop - stickyOffset;
   const transformStyle = useAnimatedStyle(() => {
     const delta = Math.max(0, stickyScrollOffset.value - stickyStart);
-    return horizontal ? { transform: [{ translateX: position + delta }] } : { transform: [{ translateY: position + delta }] };
-  }, [horizontal, position, stickyStart]);
+    const stickyPosition = position + delta;
+    const resolvedPosition = pushLimit !== void 0 ? Math.min(stickyPosition, pushLimit) : stickyPosition;
+    return horizontal ? { transform: [{ translateX: resolvedPosition }] } : { transform: [{ translateY: resolvedPosition }] };
+  }, [horizontal, position, pushLimit, stickyStart]);
   const viewStyle = React.useMemo(
     () => [style, { zIndex: index + 1e3 }, transformStyle],
     [index, style, transformStyle]
@@ -92,18 +108,71 @@ var ReanimatedPositionView = typedMemo(function ReanimatedPositionViewComponent(
     children
   );
 });
+function setSharedValueValue(sharedValue, value) {
+  if (!sharedValue) {
+    return;
+  }
+  const sharedValueWithMethods = sharedValue;
+  const currentValue = typeof sharedValueWithMethods.get === "function" ? sharedValueWithMethods.get() : sharedValueWithMethods.value;
+  if (currentValue === value) {
+    return;
+  }
+  if (typeof sharedValueWithMethods.set === "function") {
+    sharedValueWithMethods.set(value);
+  } else {
+    sharedValueWithMethods.value = value;
+  }
+}
+function useAnimatedLegendListSharedValuesSync(legendList, sharedValues) {
+  React.useEffect(() => {
+    if (!legendList || !sharedValues) {
+      return;
+    }
+    const state = legendList.getState();
+    setSharedValueValue(sharedValues.activeStickyIndex, state.activeStickyIndex);
+    setSharedValueValue(sharedValues.isAtEnd, state.isAtEnd);
+    setSharedValueValue(sharedValues.isAtStart, state.isAtStart);
+    setSharedValueValue(sharedValues.isNearEnd, state.isNearEnd);
+    setSharedValueValue(sharedValues.isNearStart, state.isNearStart);
+    setSharedValueValue(
+      sharedValues.isWithinMaintainScrollAtEndThreshold,
+      state.isWithinMaintainScrollAtEndThreshold
+    );
+    setSharedValueValue(sharedValues.scrollOffset, state.scroll);
+    const unsubscribers = [
+      sharedValues.activeStickyIndex ? state.listen(
+        "activeStickyIndex",
+        (value) => setSharedValueValue(sharedValues.activeStickyIndex, value)
+      ) : void 0,
+      sharedValues.isAtEnd ? state.listen("isAtEnd", (value) => setSharedValueValue(sharedValues.isAtEnd, value)) : void 0,
+      sharedValues.isAtStart ? state.listen("isAtStart", (value) => setSharedValueValue(sharedValues.isAtStart, value)) : void 0,
+      sharedValues.isNearEnd ? state.listen("isNearEnd", (value) => setSharedValueValue(sharedValues.isNearEnd, value)) : void 0,
+      sharedValues.isNearStart ? state.listen("isNearStart", (value) => setSharedValueValue(sharedValues.isNearStart, value)) : void 0,
+      sharedValues.isWithinMaintainScrollAtEndThreshold ? state.listen(
+        "isWithinMaintainScrollAtEndThreshold",
+        (value) => setSharedValueValue(sharedValues.isWithinMaintainScrollAtEndThreshold, value)
+      ) : void 0
+    ];
+    return () => {
+      for (const unsubscribe of unsubscribers) {
+        unsubscribe == null ? void 0 : unsubscribe();
+      }
+    };
+  }, [legendList, sharedValues]);
+}
 var LegendListForwardedRef = typedMemo(
   // biome-ignore lint/nursery/noShadow: const function name shadowing is intentional
   React.forwardRef(function LegendListForwardedRef2(props, ref) {
-    const { itemLayoutAnimation, recycleItems, refLegendList, renderScrollComponent, ...rest } = props;
+    var _a;
+    const { itemLayoutAnimation, recycleItems, refLegendList, renderScrollComponent, sharedValues, ...rest } = props;
     const refFn = useCallback(
       (r) => {
         refLegendList(r);
       },
       [refLegendList]
     );
-    const stickyScrollOffset = useSharedValue(0);
-    const shouldUseReanimatedScrollView = IsNewArchitecture;
+    const internalScrollOffset = useSharedValue(0);
+    const scrollOffset = (_a = sharedValues == null ? void 0 : sharedValues.scrollOffset) != null ? _a : internalScrollOffset;
     const renderScrollComponentForBridge = React.useMemo(
       () => renderScrollComponent ? (scrollViewProps) => renderScrollComponent(scrollViewProps) : void 0,
       [renderScrollComponent]
@@ -117,17 +186,17 @@ var LegendListForwardedRef = typedMemo(
             ...restScrollViewProps,
             forwardedRef,
             renderScrollComponent: renderScrollComponentForBridge,
-            scrollOffset: stickyScrollOffset
+            scrollOffset
           }
         );
       },
-      [renderScrollComponentForBridge, stickyScrollOffset]
+      [renderScrollComponentForBridge, scrollOffset]
     );
     const stickyPositionComponentInternal = React.useMemo(
       () => function StickyPositionComponent(stickyProps) {
-        return /* @__PURE__ */ React.createElement(ReanimatedPositionViewSticky, { ...stickyProps, stickyScrollOffset });
+        return /* @__PURE__ */ React.createElement(ReanimatedPositionViewSticky, { ...stickyProps, stickyScrollOffset: scrollOffset });
       },
-      [stickyScrollOffset]
+      [scrollOffset]
     );
     const itemLayoutAnimationRef = React.useRef(itemLayoutAnimation);
     itemLayoutAnimationRef.current = itemLayoutAnimation;
@@ -151,10 +220,10 @@ var LegendListForwardedRef = typedMemo(
       ...rest,
       positionComponentInternal,
       recycleItems,
-      ...shouldUseReanimatedScrollView ? {
+      ...{
         renderScrollComponent: renderReanimatedScrollComponent,
-        stickyPositionComponentInternal
-      } : {}
+        ...IsNewArchitecture ? { stickyPositionComponentInternal } : {}
+      } 
     };
     return /* @__PURE__ */ React.createElement(LegendList, { ref: refFn, refScrollView: ref, ...legendListProps });
   })
@@ -165,9 +234,15 @@ var AnimatedLegendList = typedMemo(
   // biome-ignore lint/nursery/noShadow: const function name shadowing is intentional
   React.forwardRef(function AnimatedLegendList2(props, ref) {
     const { refScrollView, ...rest } = props;
-    const { animatedProps } = props;
-    const refLegendList = React.useRef(null);
-    const combinedRef = useCombinedRef(refLegendList, ref);
+    const { animatedProps, sharedValues } = props;
+    const [legendList, setLegendList] = React.useState(null);
+    const combinedRef = useCombinedRef(
+      React.useCallback((instance) => {
+        setLegendList((prev) => prev === instance ? prev : instance);
+      }, []),
+      ref
+    );
+    useAnimatedLegendListSharedValuesSync(legendList, sharedValues);
     const forwardedProps = {
       ...rest,
       animatedPropsInternal: animatedProps,