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

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;
@@ -1542,5 +1659,3 @@ exports.useShouldReduceMotion = useShouldReduceMotion;
 exports.useSpring = useSpring;
 exports.useTransform = useTransform;
 exports.useVariants = useVariants;
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map