@rootnative/inertia 0.0.0-alpha.0

package/dist/touch/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/transitions/spring.ts","../../src/transitions/runtime.ts","../../src/touch/useTouchDrag.ts"],"names":[],"mappings":"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","file":"index.mjs","sourcesContent":["import { type SpringTransition } from '../types'\n\n/**\n * Default spring physics, expressed in react-spring vocabulary.\n *\n * `tension: 170` / `friction: 26` / `mass: 1` was picked over Reanimated's\n * raw `stiffness: 100` / `damping: 10` default because the raw default\n * overshoots noticeably for the small (~100px) translates that dominate\n * UI work — buttons, sheets, popovers. These numbers settle in ~350ms with\n * a single, almost-imperceptible overshoot, which matches the perceptual\n * target the rest of the library is tuned against.\n */\nexport const DEFAULT_SPRING: Required<\n  Pick<SpringTransition, 'tension' | 'friction' | 'mass'>\n> = {\n  tension: 170,\n  friction: 26,\n  mass: 1,\n}\n\n/**\n * Convert public react-spring vocabulary (`tension` / `friction` / `mass`)\n * to Reanimated's raw `stiffness` / `damping` / `mass`. This is the single\n * place the mapping lives; resolvers, value hooks, and any future surface\n * that needs a Reanimated spring config import from here.\n *\n * The mapping is identity (tension ≡ stiffness, friction ≡ damping) — the\n * names differ but the underlying physics constants are the same. We don't\n * surface the raw names publicly because the react-spring vocabulary is\n * what designers and prior-art consumers expect.\n */\nexport function springToReanimated(t: SpringTransition) {\n  'worklet'\n  return {\n    stiffness: t.tension ?? DEFAULT_SPRING.tension,\n    damping: t.friction ?? DEFAULT_SPRING.friction,\n    mass: t.mass ?? DEFAULT_SPRING.mass,\n    velocity: t.velocity,\n    restSpeedThreshold: t.restSpeedThreshold,\n    restDisplacementThreshold: t.restDisplacementThreshold,\n  }\n}\n","import {\n  Easing,\n  withDecay,\n  withSpring,\n  withTiming,\n} from 'react-native-reanimated'\nimport { springToReanimated } from './spring'\nimport { type TransitionConfig } from '../types'\n\nconst DEFAULT_TIMING_DURATION = 250\n\n/**\n * Worklet-safe single-step animation builder. Mirrors a subset of\n * `resolveTransition` for the UI-thread path where the transition config is\n * picked at gesture-release time, not at render time.\n *\n * Supported: spring / timing / decay / no-animation, single-step only.\n * Not supported: sequences, top-level repeat, easing-function\n * auto-worklet-wrapping (pass an already-worklet easing if you need a custom\n * one — most release transitions don't).\n *\n * Use this from gesture worklets (`useDrag` / `usePan` release callbacks, or\n * any custom `Gesture.Pan().onEnd(() => ...)` worklet) to animate a shared\n * value with an Inertia transition without the JS round-trip that would lose\n * the release velocity.\n *\n * For decay transitions, `toValue` is ignored — decay decelerates from the\n * SV's current position via its own physics. Pass `0` if you don't have one.\n */\nexport function buildReleaseAnimation(\n  transition: TransitionConfig,\n  toValue: number,\n): unknown {\n  'worklet'\n  if (transition.type === 'no-animation') return toValue\n  if (transition.type === 'decay') {\n    const cfg: {\n      velocity: number\n      deceleration?: number\n      clamp?: [number, number]\n    } = { velocity: transition.velocity ?? 0 }\n    if (transition.deceleration !== undefined) {\n      cfg.deceleration = transition.deceleration\n    }\n    if (transition.clamp !== undefined) cfg.clamp = transition.clamp\n    return withDecay(cfg)\n  }\n  if (transition.type === 'timing') {\n    // Reanimated 4's `Easing.bezier(...)` returns an `EasingFunctionFactory`\n    // rather than the function itself. Unwrap inline so consumers calling\n    // `buildReleaseAnimation` from a gesture worklet don't have to.\n    const e = transition.easing\n    const easingFn =\n      e && typeof e === 'object' && 'factory' in e\n        ? e.factory()\n        : (e ?? Easing.inOut(Easing.ease))\n    return withTiming(toValue, {\n      duration: transition.duration ?? DEFAULT_TIMING_DURATION,\n      easing: easingFn,\n    })\n  }\n  return withSpring(toValue, springToReanimated(transition))\n}\n","import { useMemo } from 'react'\nimport {\n  PanResponder,\n  type PanResponderGestureState,\n  type PanResponderInstance,\n} from 'react-native'\nimport {\n  useAnimatedStyle,\n  useSharedValue,\n  type SharedValue,\n} from 'react-native-reanimated'\nimport { buildReleaseAnimation } from '../transitions'\nimport type { TransitionConfig } from '../types'\n\n/**\n * Same drag-result shape as `useDrag` from `@rootnative/inertia-gestures`,\n * minus the `gesture` field (PanResponder spreads handlers, no\n * `<GestureDetector>` wrapper). The shared values + animatedStyle are\n * interchangeable across both hooks; consumers can swap implementations\n * without touching their `useAnimatedStyle` consumers.\n */\nexport interface UseTouchDragResult {\n  /** Spread onto a `View` / `Pressable` to install the pan responder. */\n  panHandlers: PanResponderInstance['panHandlers']\n  /** Stable animated `transform` style. */\n  animatedStyle: ReturnType<typeof useAnimatedStyle>\n  /** Live x translation, persistent across gestures. */\n  dragX: SharedValue<number>\n  /** Live y translation, persistent across gestures. */\n  dragY: SharedValue<number>\n  /** True while the gesture is active. */\n  isDragging: SharedValue<boolean>\n}\n\n/**\n * Release transition shape for PanResponder's JS-thread `onRelease`. Mirrors\n * the gesture-handler adapter's `ReleaseTransition` but with `to` typed as\n * required for spring/timing/no-animation (decay omits it).\n */\nexport type TouchReleaseTransition =\n  | (TransitionConfig & { type: 'spring'; to: number })\n  | (TransitionConfig & { type: 'timing'; to: number })\n  | (TransitionConfig & { type: 'decay' })\n  | (TransitionConfig & { type: 'no-animation'; to: number })\n\nexport interface TouchReleaseInfo {\n  x: number\n  y: number\n  velocity: { x: number; y: number }\n}\n\nexport interface TouchReleaseResult {\n  x?: TouchReleaseTransition\n  y?: TouchReleaseTransition\n}\n\nexport interface UseTouchDragOptions {\n  /**\n   * Restrict the drag to one axis. Defaults to `'both'`. When `'x'` is set\n   * the y-axis shared value never updates (and vice versa); velocity is\n   * still reported on both for `onDragEnd`.\n   */\n  axis?: 'x' | 'y' | 'both'\n  /**\n   * Travel bounds (px from resting). Each side is independently optional.\n   * Out-of-bounds values clamp to the limit unless `elastic > 0`.\n   */\n  constraints?: {\n    left?: number\n    right?: number\n    top?: number\n    bottom?: number\n  }\n  /**\n   * Rubber-band coefficient applied to overshoot past `constraints`. `0`\n   * (default) hard-clamps; `0.2`-`0.4` is a typical Framer-Motion feel.\n   */\n  elastic?: number\n  /**\n   * Fires when the user starts dragging. JS thread.\n   */\n  onDragStart?: () => void\n  /**\n   * Fires when the user releases or the gesture terminates. JS thread.\n   *\n   * Velocity is in px/sec to match the `@rootnative/inertia-gestures` API\n   * (PanResponder's native `vx` / `vy` are px/ms; the hook normalizes).\n   */\n  onDragEnd?: (info: TouchReleaseInfo) => void\n  /**\n   * Optional release-animation callback. Return per-axis release transitions\n   * to animate the SVs to a settled position via Inertia's transition\n   * resolver — spring snap-to-tick, decay with bounds, timing settle.\n   *\n   * Unlike the gesture-handler version, this callback runs on the **JS\n   * thread** (PanResponder is JS-only). The returned transitions still drive\n   * UI-thread animations via Reanimated — only the decision logic is JS-side.\n   */\n  onRelease?: (info: TouchReleaseInfo) => TouchReleaseResult | void\n}\n\n/**\n * PanResponder-backed drag hook. Pointer-equivalent of `useDrag` from\n * `@rootnative/inertia-gestures`, with two differences:\n *\n *   1. No `react-native-gesture-handler` peer dep required — PanResponder is\n *      built into React Native, so this lives in core.\n *   2. Returns `panHandlers` to spread on a `View` / `Pressable` instead of\n *      a `gesture` to plug into `<GestureDetector>`.\n *\n * Use this when:\n *   - You need keyboard a11y alongside drag (a slider with arrow-key step,\n *     a scrollbar with `PageUp` / `PageDown`). PanResponder composes\n *     cleanly with `onKeyDown`; gesture-handler doesn't surface keyboard.\n *   - You don't want to take `react-native-gesture-handler` as a dependency\n *     (smaller bundle, simpler install).\n *\n * Skip this when:\n *   - You're already using `react-native-gesture-handler` elsewhere (use\n *     `useDrag` from `@rootnative/inertia-gestures` for consistency and\n *     better worklet-thread fidelity on release velocity).\n *   - You need momentum semantics like the gesture-handler `usePan` —\n *     PanResponder's release velocity is JS-thread and slightly less precise.\n *\n * @example\n * ```tsx\n * import { useTouchDrag } from '@rootnative/inertia/touch'\n *\n * function Slider({ ticks }: { ticks: number[] }) {\n *   const drag = useTouchDrag({\n *     axis: 'x',\n *     constraints: { left: 0, right: 280 },\n *     onRelease: (e) => {\n *       const snap = nearestTick(e.x, ticks)\n *       return { x: { type: 'spring', to: snap, velocity: e.velocity.x } }\n *     },\n *   })\n *\n *   return (\n *     <Motion.View\n *       style={[styles.thumb, drag.animatedStyle]}\n *       {...drag.panHandlers}\n *     />\n *   )\n * }\n * ```\n */\nexport function useTouchDrag(\n  options: UseTouchDragOptions = {},\n): UseTouchDragResult {\n  const { axis = 'both', constraints, elastic = 0 } = options\n\n  const dragX = useSharedValue(0)\n  const dragY = useSharedValue(0)\n  const startX = useSharedValue(0)\n  const startY = useSharedValue(0)\n  const isDragging = useSharedValue(false)\n\n  // Snapshot scalars into local consts so the responder callbacks close over\n  // primitives, not the `options` literal — a fresh `options` each render\n  // would otherwise force the PanResponder identity to change.\n  const lockX = axis !== 'y'\n  const lockY = axis !== 'x'\n  const left = constraints?.left\n  const right = constraints?.right\n  const top = constraints?.top\n  const bottom = constraints?.bottom\n  const elasticCoef = elastic\n  const { onDragStart, onDragEnd, onRelease } = options\n\n  const responder = useMemo(\n    () => buildResponder(),\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [\n      lockX,\n      lockY,\n      left,\n      right,\n      top,\n      bottom,\n      elasticCoef,\n      onDragStart,\n      onDragEnd,\n      onRelease,\n    ],\n  )\n\n  // Hoisted out of the inline `useMemo` factory to keep the dep list readable\n  // and avoid re-declaring closure helpers each render.\n  function buildResponder(): PanResponderInstance {\n    const handleEnd = (g: PanResponderGestureState) => {\n      isDragging.value = false\n      const x = dragX.value\n      const y = dragY.value\n      // PanResponder velocity is px/ms; multiply to match the\n      // `@rootnative/inertia-gestures` API (px/sec from gesture-handler).\n      const vx = g.vx * 1000\n      const vy = g.vy * 1000\n      if (onRelease) {\n        const result = onRelease({ x, y, velocity: { x: vx, y: vy } })\n        if (result) {\n          if (result.x && lockX) {\n            const toX = 'to' in result.x ? result.x.to : x\n            dragX.value = buildReleaseAnimation(\n              result.x,\n              toX,\n            ) as unknown as number\n          }\n          if (result.y && lockY) {\n            const toY = 'to' in result.y ? result.y.to : y\n            dragY.value = buildReleaseAnimation(\n              result.y,\n              toY,\n            ) as unknown as number\n          }\n        }\n      }\n      if (onDragEnd) onDragEnd({ x, y, velocity: { x: vx, y: vy } })\n    }\n\n    return PanResponder.create({\n      // Always claim the start so taps that turn into drags don't slip\n      // through to a parent ScrollView. Consumers can compose their own\n      // capture predicates by wrapping the returned `panHandlers`.\n      onStartShouldSetPanResponder: () => true,\n      onMoveShouldSetPanResponder: () => true,\n      onPanResponderGrant: () => {\n        startX.value = dragX.value\n        startY.value = dragY.value\n        isDragging.value = true\n        if (onDragStart) onDragStart()\n      },\n      onPanResponderMove: (_e, g) => {\n        if (lockX) {\n          dragX.value = applyBounds(\n            startX.value + g.dx,\n            left,\n            right,\n            elasticCoef,\n          )\n        }\n        if (lockY) {\n          dragY.value = applyBounds(\n            startY.value + g.dy,\n            top,\n            bottom,\n            elasticCoef,\n          )\n        }\n      },\n      onPanResponderRelease: (_e, g) => handleEnd(g),\n      onPanResponderTerminate: (_e, g) => handleEnd(g),\n    })\n  }\n\n  const animatedStyle = useAnimatedStyle(() => ({\n    transform: [{ translateX: dragX.value }, { translateY: dragY.value }],\n  }))\n\n  return {\n    panHandlers: responder.panHandlers,\n    animatedStyle,\n    dragX,\n    dragY,\n    isDragging,\n  }\n}\n\n/**\n * Clamp `value` to `[min, max]`. When `elastic > 0` the overshoot past a\n * bound is scaled by `elastic`, giving a rubber-band feel. `min` / `max`\n * may be `undefined` to leave that side unbounded.\n *\n * JS-thread (PanResponder callbacks are JS, not worklets).\n */\nfunction applyBounds(\n  value: number,\n  min: number | undefined,\n  max: number | undefined,\n  elastic: number,\n): number {\n  if (min !== undefined && value < min) {\n    return elastic > 0 ? min + (value - min) * elastic : min\n  }\n  if (max !== undefined && value > max) {\n    return elastic > 0 ? max + (value - max) * elastic : max\n  }\n  return value\n}\n"]}

package/dist/types-cU43dEmH.d.mts

@@ -0,0 +1,339 @@
+import { ComponentType, ComponentProps, Ref, ReactElement } from 'react';
+import { StyleProp } from 'react-native';
+
+/**
+ * A single animation step's destination, optionally overriding the transition
+ * for that step.
+ */
+type SequenceStep<V> = V | ({
+    to: V;
+    delay?: number;
+} & TransitionConfig);
+/**
+ * A target value for an animatable property: a single value, a sequence of
+ * steps (keyframes), or a single step object.
+ */
+type AnimatableValue<V> = V | SequenceStep<V> | ReadonlyArray<SequenceStep<V>>;
+/**
+ * Spring transition — public surface uses react-spring vocabulary
+ * (`tension` / `friction` / `mass`), not Reanimated's raw stiffness/damping.
+ */
+interface SpringTransition {
+    type?: 'spring';
+    tension?: number;
+    friction?: number;
+    mass?: number;
+    velocity?: number;
+    restSpeedThreshold?: number;
+    restDisplacementThreshold?: number;
+    delay?: number;
+    repeat?: RepeatConfig;
+}
+/**
+ * Easing input accepted by `TimingTransition`. Either a plain easing function
+ * `(t: number) => number` (the pre-Reanimated-4 shape and the shape consumers
+ * author by hand) or an `EasingFunctionFactory` (the Reanimated 4 shape
+ * returned by `Easing.bezier(...)` and similar builders). The resolver
+ * unwraps the factory automatically — consumers don't have to call
+ * `.factory()` themselves.
+ */
+type EasingFunction = (t: number) => number;
+interface EasingFunctionFactory {
+    factory: () => EasingFunction;
+}
+type EasingInput = EasingFunction | EasingFunctionFactory;
+interface TimingTransition {
+    type: 'timing';
+    duration?: number;
+    easing?: EasingInput;
+    delay?: number;
+    repeat?: RepeatConfig;
+}
+interface DecayTransition {
+    type: 'decay';
+    velocity?: number;
+    deceleration?: number;
+    clamp?: [number, number];
+    delay?: number;
+}
+interface NoAnimationTransition {
+    type: 'no-animation';
+}
+type TransitionConfig = SpringTransition | TimingTransition | DecayTransition | NoAnimationTransition;
+/**
+ * Repeat config — one shape, not three flags. Default `alternate: true`.
+ */
+type RepeatConfig = number | 'infinite' | {
+    count: number | 'infinite';
+    alternate?: boolean;
+};
+/**
+ * Per-property transition map. Keys must match keys present on `animate`.
+ * Top-level entries on `transition` apply to all properties unless overridden
+ * here.
+ */
+type PerPropertyTransition<S> = {
+    [K in keyof S]?: TransitionConfig;
+};
+/**
+ * Per-gesture-layer transition map. Each `gesture` sub-state animates a
+ * progress value 0↔1 with its own transition; the worklet composites the
+ * layers in priority order (`hovered → focused → focusVisible → pressed`).
+ *
+ * Keys live on the same `transition` object as `PerPropertyTransition` because
+ * the only other place they could go (nested inside `gesture` itself) would
+ * collide with the primitive's inferred style keys.
+ */
+interface GestureLayerTransitions {
+    pressed?: TransitionConfig;
+    focused?: TransitionConfig;
+    focusVisible?: TransitionConfig;
+    hovered?: TransitionConfig;
+}
+type Transition<S> = TransitionConfig | (PerPropertyTransition<S> & GestureLayerTransitions);
+/**
+ * Transform shorthands that Inertia exposes on `animate` but that don't
+ * appear on RN's typed ViewStyle as top-level keys. RN keeps `scale`,
+ * `rotate`, `rotateX`, and `rotateY` inside the `transform` array; only
+ * `scaleX`/`scaleY` and `translateX`/`translateY` are surfaced as
+ * (deprecated) top-level shortcuts. Inertia's runtime treats these as
+ * transform-group keys (see `TRANSFORM_KEYS` in `createMotionComponent`),
+ * so they're documented as first-class animatables in `CLAUDE.md` and must
+ * be reachable from `animate` without dropping into the `transform: [...]`
+ * array form. Rotation values are degrees as numbers — the runtime appends
+ * `'deg'` before handing the transform to Reanimated.
+ */
+type AnimatableTransformExtras = {
+    scale?: AnimatableValue<number>;
+    rotate?: AnimatableValue<number>;
+    rotateX?: AnimatableValue<number>;
+    rotateY?: AnimatableValue<number>;
+};
+/**
+ * The animation state shape inferred from the underlying component's style
+ * prop. We narrow to the value side of `style` so consumers see ViewStyle on
+ * `Motion.View`, TextStyle on `Motion.Text`, etc. — no shared union.
+ *
+ * Some components (notably `Pressable`) type `style` as a union of
+ * `StyleProp<T>` and a callback `(state) => StyleProp<T>`. If we infer `S`
+ * directly from `StyleProp<infer S>`, the callback branch widens `S` to
+ * `unknown`, which collapses the animate map to `| {}` and silently
+ * accepts any key. Excluding functions first keeps inference tight.
+ */
+type _StyleValue<T> = Exclude<T, (...args: any[]) => any>;
+type AnimateStyle<C> = C extends {
+    style?: infer Raw;
+} ? _StyleValue<Raw> extends StyleProp<infer S> ? {
+    [K in keyof S]?: AnimatableValue<S[K]>;
+} & AnimatableTransformExtras : never : never;
+interface AnimationCallbackInfo<S> {
+    /**
+     * The animatable key that just settled — typically a `keyof S` (e.g.
+     * `'opacity'`, `'translateX'`). The sentinel `'transform'` is emitted in
+     * lieu of any specific transform axis (`translateX`/`Y`, `scale`/`X`/`Y`,
+     * `rotate`) when the terminal `'animation'` phase fires for a transform
+     * group, so a multi-axis translate produces one callback rather than two.
+     */
+    key: keyof S | 'transform';
+    finished: boolean;
+    value: unknown;
+    target: unknown;
+    phase: 'step' | 'sequence' | 'repeat' | 'animation';
+    step: number | undefined;
+    iteration: number;
+}
+/**
+ * A variants map: string state names → animate target objects.
+ */
+type VariantsMap<C> = Record<string, AnimateStyle<C>>;
+/**
+ * Gesture sub-states accepted by the `gesture` prop on every Motion primitive.
+ *
+ * - `pressed` — active while the user is touching the component (touch start
+ *   to touch end / cancel).
+ * - `focused` — active while a focusable component owns focus, regardless of
+ *   how focus arrived (mouse, touch, or keyboard). No-op for non-focusable
+ *   underlying components.
+ * - `focusVisible` — active only when focus arrived from the keyboard
+ *   (W3C `:focus-visible` semantics). Use this for focus rings to avoid
+ *   flashing them on click-focus on web. On native — where focus always
+ *   arrives via D-pad, screen reader, or hardware keyboard — this behaves
+ *   identically to `focused`.
+ * - `hovered` — web-only. Typed for cross-platform call sites; the runtime is
+ *   a no-op on native.
+ *
+ * Sub-states layer additively. Each declared sub-state owns an independent
+ * progress value (0↔1) that animates in/out with its own transition; the
+ * worklet composites layers in priority order (lowest-to-highest):
+ * `hovered → focused → focusVisible → pressed`. Per-property the chain is
+ *
+ *   v = base
+ *   v = lerp(v, hovered.value,      progressHovered)      // if declared
+ *   v = lerp(v, focused.value,      progressFocused)      // if declared
+ *   v = lerp(v, focusVisible.value, progressFocusVisible) // if declared
+ *   v = lerp(v, pressed.value,      progressPressed)      // if declared
+ *
+ * (Color-valued keys use `interpolateColor` instead of `lerp`.) When a single
+ * sub-state is active, this collapses to "the highest-priority declared layer
+ * wins". When multiple are mid-transition (e.g. release-while-still-hovered)
+ * each layer fades independently — a press layer fading out at 50ms while a
+ * hover layer holds at full opacity matches MD3 state-layer semantics.
+ *
+ * Configure per-layer fade timing via `transition.<stateName>` on the parent
+ * primitive (see `GestureLayerTransitions`); without it, layers default to
+ * the parent transition or the library default spring.
+ *
+ * **Priority cascade is the only composition mode on this prop.** Non-priority
+ * blends — clamped-max (`Math.max(hover*α, focus*β, press*γ)`, as used by MD3
+ * state-layer haloes), additive accumulation, or any per-key custom blend —
+ * are not expressible declaratively. Drop to `useGesture()` for those: it
+ * returns the four progress shared values and a handler bag, and you write
+ * a `useAnimatedStyle` block with whatever composition you need. The hook's
+ * JSDoc shows the clamped-max halo pattern in full.
+ */
+interface GestureSubStates<C> {
+    pressed?: AnimateStyle<C>;
+    focused?: AnimateStyle<C>;
+    focusVisible?: AnimateStyle<C>;
+    hovered?: AnimateStyle<C>;
+}
+/**
+ * Controller returned by `useVariants`. The `current` shared state is read
+ * via `controller` prop on a Motion primitive; `transitionTo` drives the
+ * controller from JS code (event handlers, async chains, etc.).
+ */
+interface VariantController<K extends string = string> {
+    current: K;
+    transitionTo(next: K): void;
+    /** @internal — subscription used by Motion primitives to re-render. */
+    subscribe(listener: (next: K) => void): () => void;
+}
+/**
+ * Props injected onto every Motion primitive.
+ *
+ * The second type parameter `V` is the concrete `variants` map. It is inferred
+ * from the `variants` prop at each JSX use (see `MotionComponent`), which is
+ * what lets `animate` narrow to the variant key union and reject typos. When
+ * no `variants` prop is passed, `V` falls back to `VariantsMap<C>` — whose key
+ * type is the open `string`, so `animate` still accepts any string and nothing
+ * regresses for the variant-less case.
+ */
+interface MotionProps<C, V extends VariantsMap<C> = VariantsMap<C>> {
+    /**
+     * Initial values applied on mount. Read once on mount and intentionally
+     * non-reactive — to reset after a state change, change the component `key`,
+     * remount via `<Presence>`, or drive the value through a controller.
+     *
+     * Pass `false` to skip the initial-mount animation entirely.
+     */
+    initial?: AnimateStyle<C> | false;
+    /**
+     * The animation target. A style object, a variant key (when `variants` is
+     * supplied), or an array of sequence steps. When `variants` is set, the
+     * string form is narrowed to the map's keys, so a key typo is a compile
+     * error and the keys autocomplete — no `as const` required.
+     */
+    animate?: AnimateStyle<C> | (keyof V & string);
+    /**
+     * Values applied while the component exits via `<Presence>`.
+     */
+    exit?: AnimateStyle<C>;
+    /**
+     * Named animation states. With `variants` set, `animate` accepts a key from
+     * this map.
+     */
+    variants?: V;
+    /**
+     * Imperative controller from `useVariants(...)`. When supplied, `animate`
+     * is read from `controller.current` and re-applied whenever the controller
+     * transitions. `animate` and `controller` should not both be set.
+     */
+    controller?: VariantController<keyof V & string>;
+    /**
+     * Gesture-driven sub-states (`pressed`, `focused`, `focusVisible`,
+     * `hovered`). When omitted, no handlers are mounted on the underlying
+     * component. Each declared sub-state animates as an independent layer
+     * fading in/out over the base `animate` target — see `GestureSubStates`
+     * for the composition model and per-layer transition wiring.
+     */
+    gesture?: GestureSubStates<C>;
+    /**
+     * Per-property or top-level transition config. Per-property entries take
+     * precedence over the top-level transition.
+     */
+    transition?: Transition<AnimateStyle<C>>;
+    /**
+     * Auto-layout animation. When the component's position or size changes
+     * because of a parent layout change (a flex sibling growing, a list
+     * reordering, a column toggling its width), interpolate between the old
+     * and new layout instead of snapping.
+     *
+     * - `true` — animate with the library's default spring.
+     * - `TransitionConfig` — spring (react-spring vocab) or timing config; the
+     *   resolver bridges to Reanimated's `LinearTransition` builder.
+     * - omitted / `false` — no layout animation (default).
+     *
+     * Only `'spring'` / `'timing'` / `'no-animation'` map to layout transitions
+     * — decay is downgraded to spring (no clear target). Reduced motion gates
+     * the prop the same way it gates `animate`.
+     *
+     * `layoutId` (below) is a related but distinct mechanism for shared
+     * element transitions across screens — `layout` animates this element's
+     * own layout changes, `layoutId` animates from a different element's
+     * last measured rect to this element's current rect.
+     */
+    layout?: boolean | TransitionConfig;
+    /**
+     * Shared-element transition id. When a Motion primitive with `layoutId`
+     * unmounts, its last on-screen rect is recorded under that id; the next
+     * mount of any Motion primitive with the same id animates from the
+     * recorded rect to its natural position via a FLIP transform stack.
+     *
+     * Reanimated 4 removed the `sharedTransitionTag` API — `layoutId` is the
+     * Inertia-side measure-based replacement. Rects are recorded in
+     * parent-relative coordinates (from `onLayout`), which composes when the
+     * source and target screens share an outer content container (the common
+     * stack-navigator case); nested-parent layouts need the v2
+     * window-coordinate path.
+     *
+     * The same `transition` prop drives the FLIP animation (spring by
+     * default; `'timing'` honored; `'decay'` downgrades to spring; reduced
+     * motion skips the transition). Out of scope for the first iteration:
+     * style-prop interpolation (border radius, colors, etc.) — only the
+     * rect-to-rect transform is animated. Two simultaneously-mounted
+     * primitives sharing the same `layoutId` are undefined behavior; pick a
+     * primitive per id at a time.
+     */
+    layoutId?: string;
+    /**
+     * Fired once per logical animation completion. See `AnimationCallbackInfo`
+     * for the payload shape — transform parents fire once, not per axis.
+     */
+    onAnimationEnd?: (info: AnimationCallbackInfo<AnimateStyle<C>>) => void;
+}
+/**
+ * Props of a Motion primitive for a given underlying component `C` and a
+ * concrete variants map `V`: the component's own props (minus `style`, which
+ * we replace with an animated style) intersected with the Motion props.
+ */
+type MotionComponentProps<C extends ComponentType<any>, V extends VariantsMap<ComponentProps<C>> = VariantsMap<ComponentProps<C>>> = Omit<ComponentProps<C>, 'style'> & MotionProps<ComponentProps<C>, V> & {
+    style?: ComponentProps<C>['style'];
+    ref?: Ref<unknown>;
+};
+/**
+ * The component type produced by `createMotionComponent`.
+ *
+ * It is a **generic call signature**, not a plain `ComponentType`: the variant
+ * map `V` is inferred from the `variants` prop at each JSX use. That inference
+ * is what narrows `animate`'s string form to the variant keys, so
+ * `<Motion.View variants={{ open, closed }} animate="opne" />` is a compile
+ * error and `open` / `closed` autocomplete. With no `variants` prop, `V` falls
+ * back to the open `VariantsMap`, so `animate` still accepts any string and the
+ * variant-less call site is unchanged.
+ */
+interface MotionComponent<C extends ComponentType<any>> {
+    <V extends VariantsMap<ComponentProps<C>> = VariantsMap<ComponentProps<C>>>(props: MotionComponentProps<C, V>): ReactElement | null;
+    displayName?: string;
+}
+
+export type { AnimatableValue as A, DecayTransition as D, EasingInput as E, GestureSubStates as G, MotionComponent as M, NoAnimationTransition as N, PerPropertyTransition as P, RepeatConfig as R, SpringTransition as S, TransitionConfig as T, VariantController as V, AnimateStyle as a, AnimationCallbackInfo as b, MotionProps as c, SequenceStep as d, TimingTransition as e, Transition as f, VariantsMap as g, GestureLayerTransitions as h };