@rootnative/inertia 0.0.6 → 0.0.8

package/dist/{chunk-BAAQI37F.mjs → chunk-M4766VUV.mjs}

@@ -1,4 +1,4 @@
-import { createMotionComponent } from './chunk-2ICQLWH2.mjs';
+import { createMotionComponent } from './chunk-IX6SEOSK.mjs';
 import { ScrollView } from 'react-native';
 
 var MotionScrollView = createMotionComponent(ScrollView);

package/dist/{chunk-Z3HCJ43H.mjs → chunk-MFAFB4K7.mjs}

@@ -1,4 +1,4 @@
-import { stableSig, isTopLevelTransition } from './chunk-REYL77RE.mjs';
+import { stableSig, isTopLevelTransition } from './chunk-W7NTRSPD.mjs';
 import { createContext, useContext, useMemo } from 'react';
 import { useReducedMotion } from 'react-native-reanimated';
 import { jsx } from 'react/jsx-runtime';

package/dist/{chunk-4NAMD62I.js → chunk-MUT6BTZS.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var chunkOBRGJAST_js = require('./chunk-OBRGJAST.js');
-var chunkPM6CVGXJ_js = require('./chunk-PM6CVGXJ.js');
+var chunk6AN5X3YE_js = require('./chunk-6AN5X3YE.js');
+var chunkWNVHPMBI_js = require('./chunk-WNVHPMBI.js');
 var react = require('react');
 var reactNativeReanimated = require('react-native-reanimated');
 
@@ -10,12 +10,12 @@ function useGesture(transition) {
   const focused = reactNativeReanimated.useSharedValue(0);
   const focusVisible = reactNativeReanimated.useSharedValue(0);
   const hovered = reactNativeReanimated.useSharedValue(0);
-  const shouldReduceMotion = chunkOBRGJAST_js.useShouldReduceMotion();
-  const resolved = chunkOBRGJAST_js.resolveNamedTransitionProp(transition, chunkOBRGJAST_js.useNamedTransitions());
+  const shouldReduceMotion = chunk6AN5X3YE_js.useShouldReduceMotion();
+  const resolved = chunk6AN5X3YE_js.resolveNamedTransitionProp(transition, chunk6AN5X3YE_js.useNamedTransitions());
   const setLayer = react.useCallback(
     (sv, layer, target) => {
       const cfg = shouldReduceMotion ? { type: "no-animation" } : layerTransition(layer, resolved) ?? { type: "spring" };
-      sv.value = chunkPM6CVGXJ_js.resolveTransition(cfg, target);
+      sv.value = chunkWNVHPMBI_js.resolveTransition(cfg, target);
     },
     // The transition is intentionally read on every call rather than cooked
     // into the dep array — a fresh literal each render would otherwise
@@ -34,7 +34,7 @@ function useGesture(transition) {
       onHoverOut: () => setLayer(hovered, "hovered", 0),
       onFocus: () => {
         setLayer(focused, "focused", 1);
-        if (chunkOBRGJAST_js.isFocusVisible()) setLayer(focusVisible, "focusVisible", 1);
+        if (chunk6AN5X3YE_js.isFocusVisible()) setLayer(focusVisible, "focusVisible", 1);
       },
       onBlur: () => {
         setLayer(focused, "focused", 0);
@@ -47,7 +47,7 @@ function useGesture(transition) {
 }
 function layerTransition(layer, transition) {
   if (!transition) return void 0;
-  if (chunkPM6CVGXJ_js.isTopLevelTransition(transition)) return transition;
+  if (chunkWNVHPMBI_js.isTopLevelTransition(transition)) return transition;
   return transition[layer];
 }
 

package/dist/{chunk-F7LJX56B.mjs → chunk-QNLSCOR5.mjs}

@@ -1,4 +1,4 @@
-import { createMotionComponent } from './chunk-2ICQLWH2.mjs';
+import { createMotionComponent } from './chunk-IX6SEOSK.mjs';
 import { Text } from 'react-native';
 
 var MotionText = createMotionComponent(Text);

package/dist/{chunk-REYL77RE.mjs → chunk-W7NTRSPD.mjs}

@@ -1,5 +1,5 @@
 import { isWorkletFunction } from 'react-native-worklets';
-import { withSequence, Easing, withDecay, withTiming, withSpring, withRepeat, withDelay } from 'react-native-reanimated';
+import { withDelay, withSequence, Easing, withDecay, withTiming, withSpring, withRepeat } from 'react-native-reanimated';
 
 // src/transitions/easing.ts
 
@@ -210,26 +210,33 @@ function bezier(x1, y1, x2, y2, source) {
   return Easing.bezier(x1, y1, x2, y2);
 }
 var DEFAULT_TIMING_DURATION2 = 250;
-function buildReleaseAnimation(transition, toValue) {
+function buildReleaseAnimation(transition, toValue, callback) {
   "worklet";
-  if (transition.type === "no-animation") return toValue;
+  if (transition.type === "no-animation") {
+    if (callback) callback(true, toValue);
+    return toValue;
+  }
   if (transition.type === "decay") {
     const cfg = { velocity: transition.velocity ?? 0 };
     if (transition.deceleration !== void 0) {
       cfg.deceleration = transition.deceleration;
     }
     if (transition.clamp !== void 0) cfg.clamp = transition.clamp;
-    return withDecay(cfg);
+    return withDecay(cfg, callback);
   }
   if (transition.type === "timing") {
     const e = transition.easing;
     const easingFn = e && typeof e === "object" && "factory" in e ? e.factory() : e ?? Easing.inOut(Easing.ease);
-    return withTiming(toValue, {
-      duration: transition.duration ?? DEFAULT_TIMING_DURATION2,
-      easing: easingFn
-    });
+    return withTiming(
+      toValue,
+      {
+        duration: transition.duration ?? DEFAULT_TIMING_DURATION2,
+        easing: easingFn
+      },
+      callback
+    );
   }
-  return withSpring(toValue, springToReanimated(transition));
+  return withSpring(toValue, springToReanimated(transition), callback);
 }
 
 // src/transitions/keys.ts
@@ -277,4 +284,4 @@ function stableStringify(v) {
   return "{" + keys.map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k])).join(",") + "}";
 }
 
-export { DEFAULT_SPRING, buildReleaseAnimation, cubicBezier, ensureWorkletEasing, isTopLevelTransition, resolveAnimatableValue, resolveTransition, springToReanimated, stableSig, warnNonWorkletOnce, warnOnce };
+export { DEFAULT_SPRING, applyDelay, buildReleaseAnimation, cubicBezier, ensureWorkletEasing, isTopLevelTransition, resolveAnimatableValue, resolveTransition, springToReanimated, stableSig, warnNonWorkletOnce, warnOnce };

package/dist/{chunk-PM6CVGXJ.js → chunk-WNVHPMBI.js}

@@ -212,26 +212,33 @@ function bezier(x1, y1, x2, y2, source) {
   return reactNativeReanimated.Easing.bezier(x1, y1, x2, y2);
 }
 var DEFAULT_TIMING_DURATION2 = 250;
-function buildReleaseAnimation(transition, toValue) {
+function buildReleaseAnimation(transition, toValue, callback) {
   "worklet";
-  if (transition.type === "no-animation") return toValue;
+  if (transition.type === "no-animation") {
+    if (callback) callback(true, toValue);
+    return toValue;
+  }
   if (transition.type === "decay") {
     const cfg = { velocity: transition.velocity ?? 0 };
     if (transition.deceleration !== void 0) {
       cfg.deceleration = transition.deceleration;
     }
     if (transition.clamp !== void 0) cfg.clamp = transition.clamp;
-    return reactNativeReanimated.withDecay(cfg);
+    return reactNativeReanimated.withDecay(cfg, callback);
   }
   if (transition.type === "timing") {
     const e = transition.easing;
     const easingFn = e && typeof e === "object" && "factory" in e ? e.factory() : e ?? reactNativeReanimated.Easing.inOut(reactNativeReanimated.Easing.ease);
-    return reactNativeReanimated.withTiming(toValue, {
-      duration: transition.duration ?? DEFAULT_TIMING_DURATION2,
-      easing: easingFn
-    });
+    return reactNativeReanimated.withTiming(
+      toValue,
+      {
+        duration: transition.duration ?? DEFAULT_TIMING_DURATION2,
+        easing: easingFn
+      },
+      callback
+    );
   }
-  return reactNativeReanimated.withSpring(toValue, springToReanimated(transition));
+  return reactNativeReanimated.withSpring(toValue, springToReanimated(transition), callback);
 }
 
 // src/transitions/keys.ts
@@ -280,6 +287,7 @@ function stableStringify(v) {
 }
 
 exports.DEFAULT_SPRING = DEFAULT_SPRING;
+exports.applyDelay = applyDelay;
 exports.buildReleaseAnimation = buildReleaseAnimation;
 exports.cubicBezier = cubicBezier;
 exports.ensureWorkletEasing = ensureWorkletEasing;

package/dist/chunk-Z5USXWTE.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var chunkE3ALFSH2_js = require('./chunk-E3ALFSH2.js');
+var reactNative = require('react-native');
+
+var MotionImage = chunkE3ALFSH2_js.createMotionComponent(reactNative.Image);
+
+exports.MotionImage = MotionImage;

package/dist/{chunk-X7B5WR5A.js → chunk-ZBHQPVWE.js}

@@ -1,8 +1,8 @@
 'use strict';
 
-var chunk767UKZXG_js = require('./chunk-767UKZXG.js');
+var chunkE3ALFSH2_js = require('./chunk-E3ALFSH2.js');
 var reactNative = require('react-native');
 
-var MotionScrollView = chunk767UKZXG_js.createMotionComponent(reactNative.ScrollView);
+var MotionScrollView = chunkE3ALFSH2_js.createMotionComponent(reactNative.ScrollView);
 
 exports.MotionScrollView = MotionScrollView;

package/dist/gestureLayer/index.d.mts

@@ -1,6 +1,6 @@
 import { SharedValue, AnimatedStyle } from 'react-native-reanimated';
-import { U as UseGestureHandlers } from '../useGesture-DfaTx-3t.mjs';
-import { a as TransitionInput, G as GestureLayerTransitions } from '../types-BQgLJeQG.mjs';
+import { U as UseGestureHandlers } from '../useGesture-CnZQnYHH.mjs';
+import { b as TransitionInput, G as GestureLayerTransitions } from '../types-DyJpG64F.mjs';
 import 'react';
 import 'react-native';
 

package/dist/gestureLayer/index.d.ts

@@ -1,6 +1,6 @@
 import { SharedValue, AnimatedStyle } from 'react-native-reanimated';
-import { U as UseGestureHandlers } from '../useGesture-B0_CzOUz.js';
-import { a as TransitionInput, G as GestureLayerTransitions } from '../types-BQgLJeQG.js';
+import { U as UseGestureHandlers } from '../useGesture-DbH46EBp.js';
+import { b as TransitionInput, G as GestureLayerTransitions } from '../types-DyJpG64F.js';
 import 'react';
 import 'react-native';
 

package/dist/gestureLayer/index.js

@@ -1,25 +1,25 @@
 'use strict';
 
-var chunk4NAMD62I_js = require('../chunk-4NAMD62I.js');
-var chunkOBRGJAST_js = require('../chunk-OBRGJAST.js');
-var chunkPM6CVGXJ_js = require('../chunk-PM6CVGXJ.js');
+var chunkMUT6BTZS_js = require('../chunk-MUT6BTZS.js');
+var chunk6AN5X3YE_js = require('../chunk-6AN5X3YE.js');
+var chunkWNVHPMBI_js = require('../chunk-WNVHPMBI.js');
 var react = require('react');
 var reactNativeReanimated = require('react-native-reanimated');
 
 function useGestureLayer(states, options = {}) {
   const { disabled: isDisabled = false, transition: transitionInput } = options;
-  const shouldReduceMotion = chunkOBRGJAST_js.useShouldReduceMotion();
-  const transition = chunkOBRGJAST_js.resolveNamedTransitionProp(
+  const shouldReduceMotion = chunk6AN5X3YE_js.useShouldReduceMotion();
+  const transition = chunk6AN5X3YE_js.resolveNamedTransitionProp(
     transitionInput,
-    chunkOBRGJAST_js.useNamedTransitions()
+    chunk6AN5X3YE_js.useNamedTransitions()
   );
-  const gesture = chunk4NAMD62I_js.useGesture(transition);
+  const gesture = chunkMUT6BTZS_js.useGesture(transition);
   const disabledProgress = reactNativeReanimated.useSharedValue(0);
-  const transitionSig = chunkPM6CVGXJ_js.stableSig(transition);
+  const transitionSig = chunkWNVHPMBI_js.stableSig(transition);
   react.useEffect(() => {
     const target = isDisabled ? 1 : 0;
     const cfg = shouldReduceMotion ? { type: "no-animation" } : disabledTransition(transition) ?? { type: "spring" };
-    disabledProgress.value = chunkPM6CVGXJ_js.resolveTransition(cfg, target);
+    disabledProgress.value = chunkWNVHPMBI_js.resolveTransition(cfg, target);
   }, [isDisabled, shouldReduceMotion, transitionSig, disabledProgress]);
   const meta = react.useMemo(() => {
     const layers = {
@@ -154,7 +154,7 @@ function useGestureLayer(states, options = {}) {
 }
 function disabledTransition(transition) {
   if (!transition) return void 0;
-  if (chunkPM6CVGXJ_js.isTopLevelTransition(transition)) return transition;
+  if (chunkWNVHPMBI_js.isTopLevelTransition(transition)) return transition;
   return void 0;
 }
 

package/dist/gestureLayer/index.mjs

@@ -1,6 +1,6 @@
-import { useGesture } from '../chunk-OW5XTGVN.mjs';
-import { useShouldReduceMotion, resolveNamedTransitionProp, useNamedTransitions } from '../chunk-Z3HCJ43H.mjs';
-import { stableSig, resolveTransition, isTopLevelTransition } from '../chunk-REYL77RE.mjs';
+import { useGesture } from '../chunk-L4JFECXU.mjs';
+import { useShouldReduceMotion, resolveNamedTransitionProp, useNamedTransitions } from '../chunk-MFAFB4K7.mjs';
+import { stableSig, resolveTransition, isTopLevelTransition } from '../chunk-W7NTRSPD.mjs';
 import { useEffect, useMemo } from 'react';
 import { useSharedValue, useAnimatedStyle, interpolateColor } from 'react-native-reanimated';
 

package/dist/index.d.mts

@@ -2,11 +2,12 @@ import * as react from 'react';
 import { ComponentType, ReactNode } from 'react';
 import * as react_native from 'react-native';
 import { NativeSyntheticEvent, NativeScrollEvent } from 'react-native';
-import { M as MotionComponent, N as NamedTransitions, a as TransitionInput, T as TransitionConfig, A as AnimatableValue, E as EasingInput, S as SpringTransition, b as TransitionName, V as VariantController } from './types-BQgLJeQG.mjs';
-export { c as AnimateStyle, d as AnimationCallbackInfo, B as BoxShadowInput, D as DecayTransition, e as EasingFunction, f as EasingFunctionFactory, g as GestureSubStates, h as MotionProps, i as NoAnimationTransition, P as PerPropertyTransition, R as RegisteredTransitions, j as RepeatConfig, k as SequenceStep, l as TimingTransition, m as Transition, n as VariantsMap } from './types-BQgLJeQG.mjs';
+import { M as MotionComponent, V as VariantsMap, a as MotionProps, N as NamedTransitions, b as TransitionInput, T as TransitionConfig, A as AnimatableValue, E as EasingInput, S as SpringTransition, c as TransitionName, d as VariantController } from './types-DyJpG64F.mjs';
+export { e as AnimateStyle, f as AnimationCallbackInfo, B as BoxShadowInput, D as DecayTransition, g as EasingFunction, h as EasingFunctionFactory, i as GestureSubStates, j as NoAnimationTransition, P as PerPropertyTransition, R as RegisteredTransitions, k as RepeatConfig, l as SequenceStep, m as TimingTransition, n as Transition } from './types-DyJpG64F.mjs';
 import { SharedValue, useAnimatedStyle } from 'react-native-reanimated';
 export { SharedValue } from 'react-native-reanimated';
-export { U as UseGestureHandlers, a as UseGestureResult, u as useGesture } from './useGesture-DfaTx-3t.mjs';
+export { U as UseGestureHandlers, a as UseGestureResult, u as useGesture } from './useGesture-CnZQnYHH.mjs';
+export { MotionFlatList } from './motion/FlatList.mjs';
 export { MotionImage } from './motion/Image.mjs';
 export { MotionPressable } from './motion/Pressable.mjs';
 export { MotionScrollView } from './motion/ScrollView.mjs';
@@ -36,6 +37,9 @@ declare const Motion: {
     readonly Image: MotionComponent<typeof react_native.Image>;
     readonly Pressable: MotionComponent<react.ForwardRefExoticComponent<react_native.PressableProps & react.RefAttributes<react_native.View>>>;
     readonly ScrollView: MotionComponent<typeof react_native.ScrollView>;
+    readonly FlatList: <ItemT = any, V extends VariantsMap<react_native.FlatListProps<ItemT>> = VariantsMap<react_native.FlatListProps<ItemT>>>(props: react_native.FlatListProps<ItemT> & MotionProps<react_native.FlatListProps<ItemT>, V> & {
+        ref?: React.Ref<react_native.FlatList<ItemT>>;
+    }) => React.ReactElement;
 };
 
 /**
@@ -170,6 +174,64 @@ interface PresenceContextValue {
  */
 declare function usePresence(): PresenceContextValue | null;
 
+interface StaggerProps {
+    children?: ReactNode;
+    /**
+     * Milliseconds between consecutive children. Child `i` (in render order)
+     * receives a delay of `delay + i * interval`.
+     */
+    interval: number;
+    /**
+     * Base delay in milliseconds applied to every child before the interval,
+     * so the whole cascade can start late without pushing the spacing into
+     * each child. Defaults to `0`.
+     */
+    delay?: number;
+    /**
+     * Which end of the child list starts the cascade. `'first'` (default)
+     * staggers top-down in render order; `'last'` reverses it, so the final
+     * child animates first.
+     */
+    from?: 'first' | 'last';
+    /**
+     * Turn the stagger on or off in one place. When `false`, every child gets
+     * a delay of `0` — the single-switch escape hatch for "cascade in, but
+     * not back out": pass `enabled={revealed}` and the hide direction snaps
+     * together. Defaults to `true`.
+     */
+    enabled?: boolean;
+}
+/**
+ * Assign each child a stagger delay from its position, so a list entrance
+ * cascades without every child computing `index * ms` itself.
+ *
+ * The parent owns the timing: reordering, filtering, or reversing the list
+ * re-derives every delay from the new render order, and `enabled` turns the
+ * whole cascade off in one place. Each child slot gets its own provider, so
+ * a `Motion.*` primitive anywhere inside child `i`'s subtree inherits child
+ * `i`'s delay.
+ *
+ * The delay applies to the declarative animations of the `Motion.*`
+ * primitives underneath — the mount animation (`initial` → `animate`) and
+ * any later `animate` change. It deliberately does not delay `gesture`
+ * feedback, `<Presence>` exits, or reduced-motion snaps.
+ *
+ * `<Stagger>` renders no host view — only per-child context providers.
+ */
+declare function Stagger({ children, interval, delay, from, enabled, }: StaggerProps): react.JSX.Element;
+
+/**
+ * The stagger delay (in milliseconds) assigned to this element's child slot
+ * by the nearest `<Stagger>` ancestor. `0` when there is none, when the
+ * stagger is disabled, or for the first child of a zero-`delay` stagger.
+ *
+ * The `Motion.*` primitives consume this automatically. Custom animated
+ * components built on `resolveTransition` / `resolveAnimatableValue` call
+ * this hook and add the returned value to their animation delay so they
+ * participate in a `<Stagger>` the same way the built-in primitives do.
+ */
+declare function useStaggerDelay(): number;
+
 /**
  * UI-thread callback Reanimated invokes when an animation settles. Must be a
  * worklet — callers either author one with `'worklet'` or build one via
@@ -183,6 +245,13 @@ type AnimationCallback = (finished?: boolean, current?: number | string) => void
  * `withDecay` call.
  */
 type CallbackFactory = (phase: 'step' | 'animation', step: number | undefined) => AnimationCallback | undefined;
+/**
+ * Wrap an animation in `withDelay`. A missing / zero / negative delay is a
+ * pass-through. Exported for the factory's stagger wrap, which must delay a
+ * fully-resolved animation exactly once — merging the delay into the base
+ * config instead would re-apply it per sequence step.
+ */
+declare function applyDelay(animation: unknown, delay: number | undefined): unknown;
 /**
  * Build a Reanimated animation for a single property. Runs on the JS thread
  * once per change and produces a baked `withSpring` / `withTiming` /
@@ -289,8 +358,14 @@ declare function ensureWorkletEasing(easing: EasingInput | undefined): ((t: numb
  *
  * For decay transitions, `toValue` is ignored — decay decelerates from the
  * SV's current position via its own physics. Pass `0` if you don't have one.
+ *
+ * `callback`, when provided, fires once when the animation settles — the same
+ * `(finished) => void` shape Reanimated's `with*` factories accept. It runs on
+ * the UI thread, so bridge to JS with `runOnJS(...)` inside it. For
+ * `no-animation` the callback fires synchronously with `finished: true`, since
+ * a direct assignment has no settle point of its own.
  */
-declare function buildReleaseAnimation(transition: TransitionConfig, toValue: number): unknown;
+declare function buildReleaseAnimation(transition: TransitionConfig, toValue: number, callback?: AnimationCallback): unknown;
 
 /**
  * The one colour spelling Reanimated's animation drivers cannot accept.
@@ -731,10 +806,10 @@ interface UseScrollResult {
     /** Vertical scroll offset in points. */
     scrollY: SharedValue<number>;
     /**
-     * Handler to pass to a `Motion.ScrollView`'s `onScroll` prop (or any other
-     * Reanimated `Animated.ScrollView`). The handler is opaque to JS — it runs
-     * as a worklet — but the type narrows to the same shape RN's native
-     * `onScroll` prop expects so it composes cleanly.
+     * Handler to pass to the `onScroll` prop of `Motion.ScrollView` or
+     * `Motion.FlatList` (or any other Reanimated animated scroller). The handler
+     * is opaque to JS — it runs as a worklet — but the type narrows to the same
+     * shape RN's native `onScroll` prop expects so it composes cleanly.
      */
     onScroll: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
 }
@@ -766,9 +841,13 @@ interface UseScrollResult {
  * read from any worklet (`useAnimatedStyle`, `useDerivedValue`,
  * `useTransform`) without a JS-thread bounce.
  *
- * Remember to set `scrollEventThrottle={16}` on the `ScrollView` for 60Hz
+ * Remember to set `scrollEventThrottle={16}` on a `Motion.ScrollView` for 60Hz
  * updates — RN's default is to dispatch on every event, which on iOS still
  * means one per frame, but Android benefits from the explicit cap.
+ *
+ * `Motion.FlatList` needs no such setting — it defaults `scrollEventThrottle`
+ * to 1 for you. Prefer it over `Motion.ScrollView` for long or unbounded lists:
+ * it virtualizes, and both accept this handler.
  */
 declare function useScroll(): UseScrollResult;
 
@@ -897,4 +976,4 @@ declare function useShadow({ from, to, progress, }: UseShadowOptions): ReturnTyp
  */
 declare function useVariants<V extends Readonly<Record<string, object>>>(variants: V, initial?: keyof V & string): VariantController<keyof V & string>;
 
-export { AnimatableValue, type Animator, type BoxShadowLayer, type ColorCascadeLayer, type ColorStyleKey, EasingInput, type ExtrapolationMode, type InterpolatedStyleMap, Motion, MotionComponent, MotionConfig, type MotionConfigProps, type MotionConfigValue, NamedTransitions, type NumericStyleKey, Presence, type PresenceContextValue, type ReducedMotion, type ShadowConfig, SpringTransition, TRANSPARENT, type TransformKey, TransitionConfig, TransitionInput, TransitionName, type UseColorCascadeOptions, type UseColorTransitionOptions, type UseInterpolatedStyleOptions, type UseScrollResult, type UseShadowOptions, type UseTransformOptions, VariantController, buildReleaseAnimation, createMotionComponent, cubicBezier, ensureWorkletEasing, resolveAnimatableValue, resolveNamedTransition, resolveTransition, useAnimation, useAnimator, useBooleanSpring, useColorCascade, useColorTransition, useInterpolatedStyle, useMotionConfig, useMotionValue, useNamedTransitions, usePresence, useScroll, useShadow, useShouldReduceMotion, useSpring, useTransform, useVariants };
+export { AnimatableValue, type AnimationCallback, type Animator, type BoxShadowLayer, type ColorCascadeLayer, type ColorStyleKey, EasingInput, type ExtrapolationMode, type InterpolatedStyleMap, Motion, MotionComponent, MotionConfig, type MotionConfigProps, type MotionConfigValue, MotionProps, NamedTransitions, type NumericStyleKey, Presence, type PresenceContextValue, type ReducedMotion, type ShadowConfig, SpringTransition, Stagger, type StaggerProps, TRANSPARENT, type TransformKey, TransitionConfig, TransitionInput, TransitionName, type UseColorCascadeOptions, type UseColorTransitionOptions, type UseInterpolatedStyleOptions, type UseScrollResult, type UseShadowOptions, type UseTransformOptions, VariantController, VariantsMap, applyDelay, buildReleaseAnimation, createMotionComponent, cubicBezier, ensureWorkletEasing, resolveAnimatableValue, resolveNamedTransition, resolveTransition, useAnimation, useAnimator, useBooleanSpring, useColorCascade, useColorTransition, useInterpolatedStyle, useMotionConfig, useMotionValue, useNamedTransitions, usePresence, useScroll, useShadow, useShouldReduceMotion, useSpring, useStaggerDelay, useTransform, useVariants };

package/dist/index.d.ts

@@ -2,11 +2,12 @@ import * as react from 'react';
 import { ComponentType, ReactNode } from 'react';
 import * as react_native from 'react-native';
 import { NativeSyntheticEvent, NativeScrollEvent } from 'react-native';
-import { M as MotionComponent, N as NamedTransitions, a as TransitionInput, T as TransitionConfig, A as AnimatableValue, E as EasingInput, S as SpringTransition, b as TransitionName, V as VariantController } from './types-BQgLJeQG.js';
-export { c as AnimateStyle, d as AnimationCallbackInfo, B as BoxShadowInput, D as DecayTransition, e as EasingFunction, f as EasingFunctionFactory, g as GestureSubStates, h as MotionProps, i as NoAnimationTransition, P as PerPropertyTransition, R as RegisteredTransitions, j as RepeatConfig, k as SequenceStep, l as TimingTransition, m as Transition, n as VariantsMap } from './types-BQgLJeQG.js';
+import { M as MotionComponent, V as VariantsMap, a as MotionProps, N as NamedTransitions, b as TransitionInput, T as TransitionConfig, A as AnimatableValue, E as EasingInput, S as SpringTransition, c as TransitionName, d as VariantController } from './types-DyJpG64F.js';
+export { e as AnimateStyle, f as AnimationCallbackInfo, B as BoxShadowInput, D as DecayTransition, g as EasingFunction, h as EasingFunctionFactory, i as GestureSubStates, j as NoAnimationTransition, P as PerPropertyTransition, R as RegisteredTransitions, k as RepeatConfig, l as SequenceStep, m as TimingTransition, n as Transition } from './types-DyJpG64F.js';
 import { SharedValue, useAnimatedStyle } from 'react-native-reanimated';
 export { SharedValue } from 'react-native-reanimated';
-export { U as UseGestureHandlers, a as UseGestureResult, u as useGesture } from './useGesture-B0_CzOUz.js';
+export { U as UseGestureHandlers, a as UseGestureResult, u as useGesture } from './useGesture-DbH46EBp.js';
+export { MotionFlatList } from './motion/FlatList.js';
 export { MotionImage } from './motion/Image.js';
 export { MotionPressable } from './motion/Pressable.js';
 export { MotionScrollView } from './motion/ScrollView.js';
@@ -36,6 +37,9 @@ declare const Motion: {
     readonly Image: MotionComponent<typeof react_native.Image>;
     readonly Pressable: MotionComponent<react.ForwardRefExoticComponent<react_native.PressableProps & react.RefAttributes<react_native.View>>>;
     readonly ScrollView: MotionComponent<typeof react_native.ScrollView>;
+    readonly FlatList: <ItemT = any, V extends VariantsMap<react_native.FlatListProps<ItemT>> = VariantsMap<react_native.FlatListProps<ItemT>>>(props: react_native.FlatListProps<ItemT> & MotionProps<react_native.FlatListProps<ItemT>, V> & {
+        ref?: React.Ref<react_native.FlatList<ItemT>>;
+    }) => React.ReactElement;
 };
 
 /**
@@ -170,6 +174,64 @@ interface PresenceContextValue {
  */
 declare function usePresence(): PresenceContextValue | null;
 
+interface StaggerProps {
+    children?: ReactNode;
+    /**
+     * Milliseconds between consecutive children. Child `i` (in render order)
+     * receives a delay of `delay + i * interval`.
+     */
+    interval: number;
+    /**
+     * Base delay in milliseconds applied to every child before the interval,
+     * so the whole cascade can start late without pushing the spacing into
+     * each child. Defaults to `0`.
+     */
+    delay?: number;
+    /**
+     * Which end of the child list starts the cascade. `'first'` (default)
+     * staggers top-down in render order; `'last'` reverses it, so the final
+     * child animates first.
+     */
+    from?: 'first' | 'last';
+    /**
+     * Turn the stagger on or off in one place. When `false`, every child gets
+     * a delay of `0` — the single-switch escape hatch for "cascade in, but
+     * not back out": pass `enabled={revealed}` and the hide direction snaps
+     * together. Defaults to `true`.
+     */
+    enabled?: boolean;
+}
+/**
+ * Assign each child a stagger delay from its position, so a list entrance
+ * cascades without every child computing `index * ms` itself.
+ *
+ * The parent owns the timing: reordering, filtering, or reversing the list
+ * re-derives every delay from the new render order, and `enabled` turns the
+ * whole cascade off in one place. Each child slot gets its own provider, so
+ * a `Motion.*` primitive anywhere inside child `i`'s subtree inherits child
+ * `i`'s delay.
+ *
+ * The delay applies to the declarative animations of the `Motion.*`
+ * primitives underneath — the mount animation (`initial` → `animate`) and
+ * any later `animate` change. It deliberately does not delay `gesture`
+ * feedback, `<Presence>` exits, or reduced-motion snaps.
+ *
+ * `<Stagger>` renders no host view — only per-child context providers.
+ */
+declare function Stagger({ children, interval, delay, from, enabled, }: StaggerProps): react.JSX.Element;
+
+/**
+ * The stagger delay (in milliseconds) assigned to this element's child slot
+ * by the nearest `<Stagger>` ancestor. `0` when there is none, when the
+ * stagger is disabled, or for the first child of a zero-`delay` stagger.
+ *
+ * The `Motion.*` primitives consume this automatically. Custom animated
+ * components built on `resolveTransition` / `resolveAnimatableValue` call
+ * this hook and add the returned value to their animation delay so they
+ * participate in a `<Stagger>` the same way the built-in primitives do.
+ */
+declare function useStaggerDelay(): number;
+
 /**
  * UI-thread callback Reanimated invokes when an animation settles. Must be a
  * worklet — callers either author one with `'worklet'` or build one via
@@ -183,6 +245,13 @@ type AnimationCallback = (finished?: boolean, current?: number | string) => void
  * `withDecay` call.
  */
 type CallbackFactory = (phase: 'step' | 'animation', step: number | undefined) => AnimationCallback | undefined;
+/**
+ * Wrap an animation in `withDelay`. A missing / zero / negative delay is a
+ * pass-through. Exported for the factory's stagger wrap, which must delay a
+ * fully-resolved animation exactly once — merging the delay into the base
+ * config instead would re-apply it per sequence step.
+ */
+declare function applyDelay(animation: unknown, delay: number | undefined): unknown;
 /**
  * Build a Reanimated animation for a single property. Runs on the JS thread
  * once per change and produces a baked `withSpring` / `withTiming` /
@@ -289,8 +358,14 @@ declare function ensureWorkletEasing(easing: EasingInput | undefined): ((t: numb
  *
  * For decay transitions, `toValue` is ignored — decay decelerates from the
  * SV's current position via its own physics. Pass `0` if you don't have one.
+ *
+ * `callback`, when provided, fires once when the animation settles — the same
+ * `(finished) => void` shape Reanimated's `with*` factories accept. It runs on
+ * the UI thread, so bridge to JS with `runOnJS(...)` inside it. For
+ * `no-animation` the callback fires synchronously with `finished: true`, since
+ * a direct assignment has no settle point of its own.
  */
-declare function buildReleaseAnimation(transition: TransitionConfig, toValue: number): unknown;
+declare function buildReleaseAnimation(transition: TransitionConfig, toValue: number, callback?: AnimationCallback): unknown;
 
 /**
  * The one colour spelling Reanimated's animation drivers cannot accept.
@@ -731,10 +806,10 @@ interface UseScrollResult {
     /** Vertical scroll offset in points. */
     scrollY: SharedValue<number>;
     /**
-     * Handler to pass to a `Motion.ScrollView`'s `onScroll` prop (or any other
-     * Reanimated `Animated.ScrollView`). The handler is opaque to JS — it runs
-     * as a worklet — but the type narrows to the same shape RN's native
-     * `onScroll` prop expects so it composes cleanly.
+     * Handler to pass to the `onScroll` prop of `Motion.ScrollView` or
+     * `Motion.FlatList` (or any other Reanimated animated scroller). The handler
+     * is opaque to JS — it runs as a worklet — but the type narrows to the same
+     * shape RN's native `onScroll` prop expects so it composes cleanly.
      */
     onScroll: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
 }
@@ -766,9 +841,13 @@ interface UseScrollResult {
  * read from any worklet (`useAnimatedStyle`, `useDerivedValue`,
  * `useTransform`) without a JS-thread bounce.
  *
- * Remember to set `scrollEventThrottle={16}` on the `ScrollView` for 60Hz
+ * Remember to set `scrollEventThrottle={16}` on a `Motion.ScrollView` for 60Hz
  * updates — RN's default is to dispatch on every event, which on iOS still
  * means one per frame, but Android benefits from the explicit cap.
+ *
+ * `Motion.FlatList` needs no such setting — it defaults `scrollEventThrottle`
+ * to 1 for you. Prefer it over `Motion.ScrollView` for long or unbounded lists:
+ * it virtualizes, and both accept this handler.
  */
 declare function useScroll(): UseScrollResult;
 
@@ -897,4 +976,4 @@ declare function useShadow({ from, to, progress, }: UseShadowOptions): ReturnTyp
  */
 declare function useVariants<V extends Readonly<Record<string, object>>>(variants: V, initial?: keyof V & string): VariantController<keyof V & string>;
 
-export { AnimatableValue, type Animator, type BoxShadowLayer, type ColorCascadeLayer, type ColorStyleKey, EasingInput, type ExtrapolationMode, type InterpolatedStyleMap, Motion, MotionComponent, MotionConfig, type MotionConfigProps, type MotionConfigValue, NamedTransitions, type NumericStyleKey, Presence, type PresenceContextValue, type ReducedMotion, type ShadowConfig, SpringTransition, TRANSPARENT, type TransformKey, TransitionConfig, TransitionInput, TransitionName, type UseColorCascadeOptions, type UseColorTransitionOptions, type UseInterpolatedStyleOptions, type UseScrollResult, type UseShadowOptions, type UseTransformOptions, VariantController, buildReleaseAnimation, createMotionComponent, cubicBezier, ensureWorkletEasing, resolveAnimatableValue, resolveNamedTransition, resolveTransition, useAnimation, useAnimator, useBooleanSpring, useColorCascade, useColorTransition, useInterpolatedStyle, useMotionConfig, useMotionValue, useNamedTransitions, usePresence, useScroll, useShadow, useShouldReduceMotion, useSpring, useTransform, useVariants };
+export { AnimatableValue, type AnimationCallback, type Animator, type BoxShadowLayer, type ColorCascadeLayer, type ColorStyleKey, EasingInput, type ExtrapolationMode, type InterpolatedStyleMap, Motion, MotionComponent, MotionConfig, type MotionConfigProps, type MotionConfigValue, MotionProps, NamedTransitions, type NumericStyleKey, Presence, type PresenceContextValue, type ReducedMotion, type ShadowConfig, SpringTransition, Stagger, type StaggerProps, TRANSPARENT, type TransformKey, TransitionConfig, TransitionInput, TransitionName, type UseColorCascadeOptions, type UseColorTransitionOptions, type UseInterpolatedStyleOptions, type UseScrollResult, type UseShadowOptions, type UseTransformOptions, VariantController, VariantsMap, applyDelay, buildReleaseAnimation, createMotionComponent, cubicBezier, ensureWorkletEasing, resolveAnimatableValue, resolveNamedTransition, resolveTransition, useAnimation, useAnimator, useBooleanSpring, useColorCascade, useColorTransition, useInterpolatedStyle, useMotionConfig, useMotionValue, useNamedTransitions, usePresence, useScroll, useShadow, useShouldReduceMotion, useSpring, useStaggerDelay, useTransform, useVariants };