@rootnative/inertia 0.0.0-alpha.0 → 0.0.0-alpha.1

package/dist/index.d.ts

@@ -2,10 +2,10 @@ 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, T as TransitionConfig, A as AnimatableValue, E as EasingInput, S as SpringTransition, V as VariantController } from './types-cU43dEmH.js';
-export { a as AnimateStyle, b as AnimationCallbackInfo, D as DecayTransition, G as GestureSubStates, c as MotionProps, N as NoAnimationTransition, P as PerPropertyTransition, R as RepeatConfig, d as SequenceStep, e as TimingTransition, f as Transition, g as VariantsMap } from './types-cU43dEmH.js';
+import { M as MotionComponent, N as NamedTransitions, T as TransitionInput, a as TransitionConfig, A as AnimatableValue, E as EasingInput, S as SpringTransition, b as TransitionName, V as VariantController } from './types-BzEgiUdJ.js';
+export { c as AnimateStyle, d as AnimationCallbackInfo, D as DecayTransition, e as EasingFunction, f as EasingFunctionFactory, G as GestureSubStates, g as MotionProps, h as NoAnimationTransition, P as PerPropertyTransition, R as RegisteredTransitions, i as RepeatConfig, j as SequenceStep, k as TimingTransition, l as Transition, m as VariantsMap } from './types-BzEgiUdJ.js';
 import { SharedValue, useAnimatedStyle } from 'react-native-reanimated';
-export { U as UseGestureHandlers, a as UseGestureResult, u as useGesture } from './useGesture-BnY65PlQ.js';
+export { U as UseGestureHandlers, a as UseGestureResult, u as useGesture } from './useGesture-BRLgiNOC.js';
 export { MotionImage } from './motion/Image.js';
 export { MotionPressable } from './motion/Pressable.js';
 export { MotionScrollView } from './motion/ScrollView.js';
@@ -51,6 +51,12 @@ declare const Motion: {
 type ReducedMotion = 'user' | 'never' | 'always';
 interface MotionConfigValue {
     reducedMotion: ReducedMotion;
+    /**
+     * Named transitions registered by ancestor `<MotionConfig transitions>`
+     * providers, already merged (nearest provider wins per name). Empty with no
+     * provider — every name then resolves to the unknown-name fallback.
+     */
+    transitions: NamedTransitions;
 }
 /**
  * Read the active `<MotionConfig>` from a descendant. Returns the default
@@ -63,18 +69,64 @@ declare function useMotionConfig(): MotionConfigValue;
  * primitives call this to decide whether to swap transitions for
  * `no-animation`.
  */
+/**
+ * Read the merged named-transition registry from the nearest `<MotionConfig>`
+ * ancestors. This is what the Motion primitives and value-layer hooks consult
+ * when a `TransitionName` string is passed where a `TransitionConfig` is
+ * accepted; custom animated components (and adapter packages) use it together
+ * with `resolveNamedTransition` to support names on their own surface.
+ */
+declare function useNamedTransitions(): NamedTransitions;
 declare function useShouldReduceMotion(): boolean;
 
+interface MotionConfigProps {
+    /**
+     * How descendants respond to reduced-motion preferences. Inherits from the
+     * nearest ancestor `<MotionConfig>` when omitted (the root default is
+     * `'user'` — respect the OS accessibility setting).
+     */
+    reducedMotion?: ReducedMotion;
+    /**
+     * Named transitions available to every descendant wherever a
+     * `TransitionConfig` is accepted — the `transition` prop (top-level and
+     * per-property), the `layout` prop, and the value-layer hooks:
+     *
+     * ```tsx
+     * <MotionConfig
+     *   transitions={{
+     *     'state-press': { type: 'timing', duration: 100 },
+     *     selection: { type: 'spring', tension: 380, friction: 33 },
+     *   }}
+     * >
+     *   <Motion.View animate={{ scale: 1 }} transition="selection" />
+     * </MotionConfig>
+     * ```
+     *
+     * Names resolve at the nearest provider; nested providers merge with the
+     * ancestor registry, child entries overriding same-named ancestor entries.
+     * Unknown names warn in dev and fall back to the library default spring.
+     * Names are consumer vocabulary — Inertia ships no presets.
+     */
+    transitions?: NamedTransitions;
+    children: ReactNode;
+}
 /**
- * Provider that controls how descendant Motion primitives respond to
- * reduced-motion preferences. Wrap the root of your app once with the
+ * Provider for subtree-wide animation config: reduced-motion behaviour and
+ * the named-transition registry. Wrap the root of your app once with the
  * default (`reducedMotion="user"`) to respect the OS accessibility setting,
  * or scope a subtree with `'always'` / `'never'` for specific use cases.
+ * Nested providers inherit from their ancestor: an omitted prop keeps the
+ * ancestor's value, and `transitions` maps merge per name (child wins).
  */
-declare function MotionConfig({ reducedMotion, children, }: {
-    reducedMotion?: ReducedMotion;
-    children: ReactNode;
-}): react.JSX.Element;
+declare function MotionConfig({ reducedMotion, transitions, children, }: MotionConfigProps): react.JSX.Element;
+
+/**
+ * Resolve a single transition input — a `TransitionConfig` passes through
+ * untouched, a `TransitionName` is looked up in `registry`. This is the
+ * building block adapter packages use to accept names wherever they accept a
+ * config (pair it with `useNamedTransitions()` for the registry).
+ */
+declare function resolveNamedTransition(input: TransitionInput | undefined, registry: NamedTransitions): TransitionConfig | undefined;
 
 /**
  * Wrap a list of children with mount / unmount transitions. When a child is
@@ -154,6 +206,47 @@ declare function resolveTransition(config: TransitionConfig | undefined, toValue
  */
 declare function resolveAnimatableValue<V extends number | string>(value: AnimatableValue<V>, base: TransitionConfig | undefined, factory?: CallbackFactory): unknown;
 
+/**
+ * Build a `timing.easing` value from cubic-bezier control points — as four
+ * numbers, as a W3C CSS `cubic-bezier(...)` string, or as a CSS easing
+ * keyword. Design systems store easing tokens in the CSS format; this helper
+ * makes any such token file directly consumable without hand-translating to
+ * `Easing.bezier` calls:
+ *
+ * ```ts
+ * cubicBezier(0.2, 0, 0, 1)                  // number form
+ * cubicBezier('cubic-bezier(0.2, 0, 0, 1)')  // CSS token form
+ * cubicBezier('ease-out')                    // CSS keywords, incl. 'linear'
+ * ```
+ *
+ * The return value is exactly what `timing.easing` accepts (Reanimated's
+ * bezier factory; the resolver worklet-wraps it via `ensureWorkletEasing`
+ * like every other easing input), so it works in the `transition` prop, in
+ * named transitions registered on `<MotionConfig transitions>`, and in the
+ * value-layer hooks:
+ *
+ * ```tsx
+ * <MotionConfig
+ *   transitions={{
+ *     'state-hover': {
+ *       type: 'timing',
+ *       duration: 150,
+ *       easing: cubicBezier(theme.motion.easingStandard),
+ *     },
+ *   }}
+ * >
+ * ```
+ *
+ * Invalid input **throws** rather than warning: easing tokens are constructed
+ * at theme/module setup, and a malformed token should fail loudly there, not
+ * silently animate with the wrong curve. Per the CSS spec, `x1` / `x2` must
+ * be within `[0, 1]` (`y1` / `y2` are unrestricted). The stepping keywords
+ * (`step-start` / `step-end`) and the CSS `linear(...)` function are not
+ * easing curves this helper produces — they're intentionally unsupported.
+ */
+declare function cubicBezier(x1: number, y1: number, x2: number, y2: number): EasingInput;
+declare function cubicBezier(css: string): EasingInput;
+
 /**
  * Reanimated 3.9+ validates that easing functions used in nested-transition
  * contexts (variants, sequences, per-property maps) are worklets, and crashes
@@ -200,7 +293,8 @@ declare function buildReleaseAnimation(transition: TransitionConfig, toValue: nu
 
 /**
  * Drive a `SharedValue<number>` toward `target` with **any** transition shape
- * — spring, timing, decay, or no-animation. The general-purpose value-layer
+ * — spring, timing, decay, or no-animation — or a `TransitionName` registered
+ * on the nearest `<MotionConfig transitions>`. The general-purpose value-layer
  * hook: reach for it when you need raw `useSharedValue + useEffect + withX`
  * outside the declarative `animate` flow.
  *
@@ -242,7 +336,7 @@ declare function buildReleaseAnimation(transition: TransitionConfig, toValue: nu
  * })
  * ```
  */
-declare function useAnimation(target: number, transition?: TransitionConfig): SharedValue<number>;
+declare function useAnimation(target: number, transition?: TransitionInput): SharedValue<number>;
 
 /**
  * Toggle a 0↔1 progress value with a spring whenever `active` flips.
@@ -265,9 +359,11 @@ declare function useAnimation(target: number, transition?: TransitionConfig): Sh
  *
  * The spring config follows the same react-spring vocabulary as the rest of
  * the library (`tension` / `friction` / `mass`); omit it to take the
- * library's defaults.
+ * library's defaults, or pass a `TransitionName` registered on the nearest
+ * `<MotionConfig transitions>` (spring-typed names only — see `useSpring`
+ * for the non-spring fallback behaviour).
  */
-declare function useBooleanSpring(active: boolean, springConfig?: SpringTransition): SharedValue<number>;
+declare function useBooleanSpring(active: boolean, springConfig?: SpringTransition | TransitionName): SharedValue<number>;
 
 /**
  * Color style keys understood by React Native that this hook can target.
@@ -334,6 +430,8 @@ declare function useColorTransition(progress: SharedValue<number>, range: readon
  * onPress={() => { x.value = 100 }}
  * ```
  */
+declare function useMotionValue(initial: number): SharedValue<number>;
+declare function useMotionValue(initial: string): SharedValue<string>;
 declare function useMotionValue<T extends number | string>(initial: T): SharedValue<T>;
 
 /**
@@ -349,8 +447,14 @@ declare function useMotionValue<T extends number | string>(initial: T): SharedVa
  *
  * Both call sites end up at the same `withSpring` invocation; the split is
  * just about which thread observes the source change.
+ *
+ * `config` also accepts a `TransitionName` registered on the nearest
+ * `<MotionConfig transitions>`. Because this hook is spring-only, the name
+ * must resolve to a spring config — a name registered as timing / decay /
+ * no-animation warns in dev and falls back to the default spring (reach for
+ * `useAnimation` when the named transition's type should be honored).
  */
-declare function useSpring(target: number | SharedValue<number>, config?: SpringTransition): SharedValue<number>;
+declare function useSpring(target: number | SharedValue<number>, config?: SpringTransition | TransitionName): SharedValue<number>;
 
 /**
  * Extrapolation behavior at the edges of the input range. Mirrors
@@ -415,10 +519,13 @@ interface UseScrollResult {
  * ```tsx
  * const { scrollY, onScroll } = useScroll()
  * const headerOpacity = useTransform(scrollY, [0, 100], [1, 0])
+ * const headerStyle = useAnimatedStyle(() => ({
+ *   opacity: headerOpacity.value,
+ * }))
  *
  * return (
  *   <>
- *     <Motion.View animate={{ opacity: headerOpacity }} />
+ *     <Animated.View style={headerStyle} />
  *     <Motion.ScrollView onScroll={onScroll} scrollEventThrottle={16}>
  *       …
  *     </Motion.ScrollView>
@@ -426,6 +533,10 @@ interface UseScrollResult {
  * )
  * ```
  *
+ * The derived shared values are consumed through Reanimated interop
+ * (`useAnimatedStyle` / `useDerivedValue`) — the declarative `animate` prop
+ * takes target values, not shared values.
+ *
  * Scroll events fire on the UI thread, so `scrollX` / `scrollY` are safe to
  * read from any worklet (`useAnimatedStyle`, `useDerivedValue`,
  * `useTransform`) without a JS-thread bounce.
@@ -504,4 +615,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 ColorStyleKey, type ExtrapolationMode, Motion, MotionComponent, MotionConfig, type MotionConfigValue, Presence, type PresenceContextValue, type ReducedMotion, type ShadowConfig, SpringTransition, TransitionConfig, type UseColorTransitionOptions, type UseScrollResult, type UseShadowOptions, type UseTransformOptions, VariantController, buildReleaseAnimation, createMotionComponent, ensureWorkletEasing, resolveAnimatableValue, resolveTransition, useAnimation, useBooleanSpring, useColorTransition, useMotionConfig, useMotionValue, usePresence, useScroll, useShadow, useShouldReduceMotion, useSpring, useTransform, useVariants };
+export { AnimatableValue, type ColorStyleKey, EasingInput, type ExtrapolationMode, Motion, MotionComponent, MotionConfig, type MotionConfigProps, type MotionConfigValue, NamedTransitions, Presence, type PresenceContextValue, type ReducedMotion, type ShadowConfig, SpringTransition, TransitionConfig, TransitionInput, TransitionName, type UseColorTransitionOptions, type UseScrollResult, type UseShadowOptions, type UseTransformOptions, VariantController, buildReleaseAnimation, createMotionComponent, cubicBezier, ensureWorkletEasing, resolveAnimatableValue, resolveNamedTransition, resolveTransition, useAnimation, useBooleanSpring, useColorTransition, useMotionConfig, useMotionValue, useNamedTransitions, usePresence, useScroll, useShadow, useShouldReduceMotion, useSpring, useTransform, useVariants };

package/dist/index.js

@@ -11,8 +11,31 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 var Animated__default = /*#__PURE__*/_interopDefault(Animated);
 
 // src/motion/Image.tsx
+
+// src/transitions/sig.ts
+function stableSig(value) {
+  if (value === void 0) return "";
+  try {
+    return stableStringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function stableStringify(v) {
+  if (v === null || typeof v !== "object") {
+    if (typeof v === "function" || v === void 0) return "null";
+    return JSON.stringify(v);
+  }
+  if (Array.isArray(v)) {
+    return "[" + v.map(stableStringify).join(",") + "]";
+  }
+  const obj = v;
+  const keys = Object.keys(obj).sort();
+  return "{" + keys.map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k])).join(",") + "}";
+}
 var DEFAULT_MOTION_CONFIG = {
-  reducedMotion: "user"
+  reducedMotion: "user",
+  transitions: {}
 };
 var MotionConfigContext = react.createContext(
   DEFAULT_MOTION_CONFIG
@@ -20,6 +43,9 @@ var MotionConfigContext = react.createContext(
 function useMotionConfig() {
   return react.useContext(MotionConfigContext);
 }
+function useNamedTransitions() {
+  return useMotionConfig().transitions;
+}
 function useShouldReduceMotion() {
   const { reducedMotion } = useMotionConfig();
   const osReduced = Animated.useReducedMotion();
@@ -28,15 +54,80 @@ function useShouldReduceMotion() {
   return osReduced;
 }
 function MotionConfig({
-  reducedMotion = "user",
+  reducedMotion,
+  transitions,
   children
 }) {
+  const parent = useMotionConfig();
+  const transitionsSig = stableSig(transitions);
   const value = react.useMemo(
-    () => ({ reducedMotion }),
-    [reducedMotion]
+    () => ({
+      reducedMotion: reducedMotion ?? parent.reducedMotion,
+      transitions: transitions ? { ...parent.transitions, ...transitions } : parent.transitions
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [reducedMotion, transitionsSig, parent]
   );
   return /* @__PURE__ */ jsxRuntime.jsx(MotionConfigContext.Provider, { value, children });
 }
+
+// src/transitions/keys.ts
+var TRANSITION_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "tension",
+  "friction",
+  "mass",
+  "velocity",
+  "restSpeedThreshold",
+  "restDisplacementThreshold",
+  "duration",
+  "easing",
+  "delay",
+  "repeat",
+  "deceleration",
+  "clamp"
+]);
+function isTopLevelTransition(t) {
+  if (t === null || typeof t !== "object") return false;
+  const keys = Object.keys(t);
+  if (keys.length === 0) return false;
+  return keys.every((k) => TRANSITION_CONFIG_KEYS.has(k));
+}
+
+// src/config/namedTransitions.ts
+var UNKNOWN_NAME_FALLBACK = { type: "spring" };
+function lookupNamedTransition(name, registry) {
+  const cfg = registry[name];
+  if (cfg) return cfg;
+  if (__DEV__) {
+    console.warn(
+      `[inertia] Unknown transition name "${name}" \u2014 falling back to the default spring. Register it on a provider: <MotionConfig transitions={{ '${name}': { ... } }}>.`
+    );
+  }
+  return UNKNOWN_NAME_FALLBACK;
+}
+function resolveNamedTransition(input, registry) {
+  if (input === void 0) return void 0;
+  if (typeof input === "string") return lookupNamedTransition(input, registry);
+  return input;
+}
+function resolveNamedTransitionProp(transition, registry) {
+  if (transition === void 0) return void 0;
+  if (typeof transition === "string") {
+    return lookupNamedTransition(transition, registry);
+  }
+  if (isTopLevelTransition(transition)) return transition;
+  const map = transition;
+  let out = null;
+  for (const key in map) {
+    const value = map[key];
+    if (typeof value === "string") {
+      if (out === null) out = { ...map };
+      out[key] = lookupNamedTransition(value, registry);
+    }
+  }
+  return out ?? transition;
+}
 var modality = "keyboard";
 var installed = false;
 function setKeyboard() {
@@ -464,28 +555,51 @@ function mergeTransition(base, override) {
   }
   return { ...base ?? { type: "spring" }, ...override };
 }
-
-// src/transitions/keys.ts
-var TRANSITION_CONFIG_KEYS = /* @__PURE__ */ new Set([
-  "type",
-  "tension",
-  "friction",
-  "mass",
-  "velocity",
-  "restSpeedThreshold",
-  "restDisplacementThreshold",
-  "duration",
-  "easing",
-  "delay",
-  "repeat",
-  "deceleration",
-  "clamp"
-]);
-function isTopLevelTransition(t) {
-  if (t === null || typeof t !== "object") return false;
-  const keys = Object.keys(t);
-  if (keys.length === 0) return false;
-  return keys.every((k) => TRANSITION_CONFIG_KEYS.has(k));
+var CSS_KEYWORDS = {
+  ease: [0.25, 0.1, 0.25, 1],
+  "ease-in": [0.42, 0, 1, 1],
+  "ease-out": [0, 0, 0.58, 1],
+  "ease-in-out": [0.42, 0, 0.58, 1]
+};
+var CSS_FUNCTION = /^cubic-bezier\((.*)\)$/;
+function cubicBezier(first, y1, x2, y2) {
+  if (typeof first === "string") return fromCss(first);
+  return bezier(first, y1, x2, y2, void 0);
+}
+function fromCss(input) {
+  const token = input.trim().toLowerCase();
+  if (token === "linear") return Animated.Easing.linear;
+  const keyword = CSS_KEYWORDS[token];
+  if (keyword) return bezier(...keyword, input);
+  const match = CSS_FUNCTION.exec(token);
+  if (!match) {
+    throw new Error(
+      `[inertia] cubicBezier: unsupported easing token ${JSON.stringify(input)}. Expected four numbers, a 'cubic-bezier(x1, y1, x2, y2)' string, or one of the CSS keywords 'linear' | 'ease' | 'ease-in' | 'ease-out' | 'ease-in-out'.`
+    );
+  }
+  const parts = match[1].split(",").map((p) => Number(p.trim()));
+  if (parts.length !== 4 || parts.some((n) => !Number.isFinite(n))) {
+    throw new Error(
+      `[inertia] cubicBezier: could not parse ${JSON.stringify(input)} \u2014 expected exactly four finite numbers inside cubic-bezier(...).`
+    );
+  }
+  return bezier(parts[0], parts[1], parts[2], parts[3], input);
+}
+function bezier(x1, y1, x2, y2, source) {
+  const describe = () => source !== void 0 ? JSON.stringify(source) : `cubicBezier(${x1}, ${y1}, ${x2}, ${y2})`;
+  for (const n of [x1, y1, x2, y2]) {
+    if (typeof n !== "number" || !Number.isFinite(n)) {
+      throw new Error(
+        `[inertia] cubicBezier: ${describe()} \u2014 every control point must be a finite number.`
+      );
+    }
+  }
+  if (x1 < 0 || x1 > 1 || x2 < 0 || x2 > 1) {
+    throw new Error(
+      `[inertia] cubicBezier: ${describe()} \u2014 x1 and x2 must be within [0, 1] (got x1=${x1}, x2=${x2}).`
+    );
+  }
+  return Animated.Easing.bezier(x1, y1, x2, y2);
 }
 var DEFAULT_TIMING_DURATION2 = 250;
 function buildReleaseAnimation(transition, toValue) {
@@ -509,28 +623,6 @@ function buildReleaseAnimation(transition, toValue) {
   }
   return Animated.withSpring(toValue, springToReanimated(transition));
 }
-
-// src/transitions/sig.ts
-function stableSig(value) {
-  if (value === void 0) return "";
-  try {
-    return stableStringify(value);
-  } catch {
-    return String(value);
-  }
-}
-function stableStringify(v) {
-  if (v === null || typeof v !== "object") {
-    if (typeof v === "function" || v === void 0) return "null";
-    return JSON.stringify(v);
-  }
-  if (Array.isArray(v)) {
-    return "[" + v.map(stableStringify).join(",") + "]";
-  }
-  const obj = v;
-  const keys = Object.keys(obj).sort();
-  return "{" + keys.map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k])).join(",") + "}";
-}
 var alreadyChecked = false;
 function ensureReanimatedInstalled() {
   if (!__DEV__ || alreadyChecked) return;
@@ -633,12 +725,14 @@ var DEFAULT_RESTING = {
 };
 function transitionFor(prop, transition) {
   if (!transition) return void 0;
+  if (typeof transition === "string") return void 0;
   if (isTopLevelTransition(transition)) return transition;
   if (GESTURE_LAYER_NAME_SET.has(prop)) return void 0;
   return transition[prop];
 }
 function gestureLayerTransitionFor(layer, transition) {
   if (!transition) return void 0;
+  if (typeof transition === "string") return void 0;
   if (isTopLevelTransition(transition)) return transition;
   return transition[layer];
 }
@@ -653,17 +747,23 @@ function createMotionComponent(Component) {
       initial,
       animate,
       exit,
-      transition,
+      transition: transitionProp,
       variants,
       controller,
       gesture,
-      layout,
+      layout: layoutProp,
       layoutId,
       onAnimationEnd,
       style,
       onLayout: userOnLayout,
       ...rest
     } = props;
+    const namedTransitions = useNamedTransitions();
+    const transition = resolveNamedTransitionProp(
+      transitionProp,
+      namedTransitions
+    );
+    const layout = typeof layoutProp === "string" ? lookupNamedTransition(layoutProp, namedTransitions) : layoutProp;
     if (__DEV__ && typeof style === "function") {
       throw new Error(
         "[inertia] `style` must be a style object or array of style objects, not a function. The function-form `style={(state) => ...}` Pressable API is not supported \u2014 use `gesture.pressed` (or `gesture.focused`, etc.) to drive state-dependent styling instead."
@@ -1271,28 +1371,30 @@ var Motion = {
 function useAnimation(target, transition) {
   const output = Animated.useSharedValue(target);
   const shouldReduceMotion = useShouldReduceMotion();
-  const cfgSig = stableSig(transition);
+  const resolved = resolveNamedTransition(transition, useNamedTransitions());
+  const cfgSig = stableSig(resolved);
   react.useEffect(() => {
-    const cfg = shouldReduceMotion ? { type: "no-animation" } : transition ?? { type: "spring" };
+    const cfg = shouldReduceMotion ? { type: "no-animation" } : resolved ?? { type: "spring" };
     output.value = resolveTransition(cfg, target);
   }, [target, cfgSig, shouldReduceMotion]);
   return output;
 }
 function useSpring(target, config) {
+  const spring = resolveSpringInput(config, useNamedTransitions());
   const reanimConfig = react.useMemo(
-    () => springToReanimated(config ?? {}),
+    () => springToReanimated(spring ?? {}),
     // Keyed on the resolved primitive fields rather than the `config` object
     // identity: callers routinely pass a fresh object literal each render, so
     // depending on `config` itself would rebuild the Reanimated config on
     // every render and defeat the memo.
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [
-      config?.tension,
-      config?.friction,
-      config?.mass,
-      config?.velocity,
-      config?.restSpeedThreshold,
-      config?.restDisplacementThreshold
+      spring?.tension,
+      spring?.friction,
+      spring?.mass,
+      spring?.velocity,
+      spring?.restSpeedThreshold,
+      spring?.restDisplacementThreshold
     ]
   );
   const isSharedTarget = isSharedValue(target);
@@ -1317,6 +1419,17 @@ function useSpring(target, config) {
   );
   return output;
 }
+function resolveSpringInput(config, registry) {
+  if (typeof config !== "string") return config;
+  const cfg = lookupNamedTransition(config, registry);
+  if (cfg.type === void 0 || cfg.type === "spring") return cfg;
+  if (__DEV__) {
+    console.warn(
+      `[inertia] Named transition "${config}" resolves to type '${cfg.type}', but useSpring / useBooleanSpring are spring-only \u2014 falling back to the default spring. Use useAnimation to honor non-spring named transitions.`
+    );
+  }
+  return void 0;
+}
 function isSharedValue(v) {
   return typeof v === "object" && v !== null && "value" in v;
 }
@@ -1340,9 +1453,10 @@ function useGesture(transition) {
   const focusVisible = Animated.useSharedValue(0);
   const hovered = Animated.useSharedValue(0);
   const shouldReduceMotion = useShouldReduceMotion();
+  const resolved = resolveNamedTransitionProp(transition, useNamedTransitions());
   const setLayer = react.useCallback(
     (sv, layer, target) => {
-      const cfg = shouldReduceMotion ? { type: "no-animation" } : layerTransition(layer, transition) ?? { type: "spring" };
+      const cfg = shouldReduceMotion ? { type: "no-animation" } : layerTransition(layer, resolved) ?? { type: "spring" };
       sv.value = resolveTransition(cfg, target);
     },
     // The transition is intentionally read on every call rather than cooked
@@ -1526,8 +1640,10 @@ exports.MotionView = MotionView;
 exports.Presence = Presence;
 exports.buildReleaseAnimation = buildReleaseAnimation;
 exports.createMotionComponent = createMotionComponent;
+exports.cubicBezier = cubicBezier;
 exports.ensureWorkletEasing = ensureWorkletEasing;
 exports.resolveAnimatableValue = resolveAnimatableValue;
+exports.resolveNamedTransition = resolveNamedTransition;
 exports.resolveTransition = resolveTransition;
 exports.useAnimation = useAnimation;
 exports.useBooleanSpring = useBooleanSpring;
@@ -1535,6 +1651,7 @@ exports.useColorTransition = useColorTransition;
 exports.useGesture = useGesture;
 exports.useMotionConfig = useMotionConfig;
 exports.useMotionValue = useMotionValue;
+exports.useNamedTransitions = useNamedTransitions;
 exports.usePresence = usePresence;
 exports.useScroll = useScroll;
 exports.useShadow = useShadow;