@onlynative/inertia 0.0.1-alpha.0

package/dist/index.js

@@ -0,0 +1,817 @@
+'use strict';
+
+var reactNative = require('react-native');
+var react = require('react');
+var Animated = require('react-native-reanimated');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Animated__default = /*#__PURE__*/_interopDefault(Animated);
+
+// src/motion/Image.tsx
+var DEFAULT_MOTION_CONFIG = {
+  reducedMotion: "user"
+};
+var MotionConfigContext = react.createContext(
+  DEFAULT_MOTION_CONFIG
+);
+function useMotionConfig() {
+  return react.useContext(MotionConfigContext);
+}
+function useShouldReduceMotion() {
+  const { reducedMotion } = useMotionConfig();
+  const osReduced = Animated.useReducedMotion();
+  if (reducedMotion === "never") return false;
+  if (reducedMotion === "always") return true;
+  return osReduced;
+}
+function MotionConfig({
+  reducedMotion = "user",
+  children
+}) {
+  const value = react.useMemo(
+    () => ({ reducedMotion }),
+    [reducedMotion]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(MotionConfigContext.Provider, { value, children });
+}
+var PresenceContext = react.createContext(null);
+function usePresence() {
+  return react.useContext(PresenceContext);
+}
+function Presence({ children }) {
+  const incoming = react.useMemo(() => {
+    const out = [];
+    react.Children.forEach(children, (child) => {
+      if (!react.isValidElement(child)) return;
+      if (child.key === null) {
+        if (__DEV__) {
+          console.warn(
+            "[inertia] <Presence> children must have a `key`. Skipping a keyless child."
+          );
+        }
+        return;
+      }
+      out.push(child);
+    });
+    return out;
+  }, [children]);
+  const [exiting, setExiting] = react.useState(
+    () => /* @__PURE__ */ new Map()
+  );
+  const prevIncomingRef = react.useRef(incoming);
+  if (prevIncomingRef.current !== incoming) {
+    const prev = prevIncomingRef.current;
+    prevIncomingRef.current = incoming;
+    const incomingKeys = new Set(incoming.map((el) => el.key));
+    let next = null;
+    const ensureMutable = () => {
+      if (!next) next = new Map(exiting);
+      return next;
+    };
+    for (const oldEl of prev) {
+      const key = oldEl.key;
+      if (!incomingKeys.has(key) && !exiting.has(key)) {
+        ensureMutable().set(key, oldEl);
+      }
+    }
+    for (const el of incoming) {
+      const key = el.key;
+      if (exiting.has(key)) {
+        ensureMutable().delete(key);
+      }
+    }
+    if (next) setExiting(next);
+  }
+  const handleRemove = react.useCallback((key) => {
+    setExiting((prev) => {
+      if (!prev.has(key)) return prev;
+      const next = new Map(prev);
+      next.delete(key);
+      return next;
+    });
+  }, []);
+  const renderList = [];
+  for (const el of incoming) {
+    renderList.push({
+      key: el.key,
+      element: el,
+      isPresent: true
+    });
+  }
+  for (const [key, el] of exiting) {
+    if (!renderList.some((entry) => entry.key === key)) {
+      renderList.push({ key, element: el, isPresent: false });
+    }
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: renderList.map(({ key, element, isPresent }) => /* @__PURE__ */ jsxRuntime.jsx(
+    PresenceItem,
+    {
+      itemKey: key,
+      isPresent,
+      onRemove: handleRemove,
+      children: element
+    },
+    key
+  )) });
+}
+function PresenceItem({
+  itemKey,
+  isPresent,
+  onRemove,
+  children
+}) {
+  const value = react.useMemo(
+    () => ({
+      isPresent,
+      safeToRemove: () => onRemove(itemKey)
+    }),
+    [isPresent, itemKey, onRemove]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(PresenceContext.Provider, { value, children });
+}
+function ensureWorkletEasing(easing) {
+  if (!easing) return void 0;
+  if (Animated.isWorkletFunction(easing)) return easing;
+  const wrapped = (t) => {
+    "worklet";
+    return easing(t);
+  };
+  return wrapped;
+}
+
+// src/transitions/resolve.ts
+var DEFAULT_SPRING = {
+  tension: 170,
+  friction: 26,
+  mass: 1
+};
+var DEFAULT_TIMING_DURATION = 250;
+function springToReanimated(t) {
+  return {
+    stiffness: t.tension ?? DEFAULT_SPRING.tension,
+    damping: t.friction ?? DEFAULT_SPRING.friction,
+    mass: t.mass ?? DEFAULT_SPRING.mass,
+    velocity: t.velocity,
+    restSpeedThreshold: t.restSpeedThreshold,
+    restDisplacementThreshold: t.restDisplacementThreshold
+  };
+}
+function buildSpring(cfg, toValue, cb) {
+  return Animated.withSpring(toValue, springToReanimated(cfg), cb);
+}
+function buildTiming(cfg, toValue, cb) {
+  return Animated.withTiming(
+    toValue,
+    {
+      duration: cfg.duration ?? DEFAULT_TIMING_DURATION,
+      easing: ensureWorkletEasing(cfg.easing) ?? Animated.Easing.inOut(Animated.Easing.ease)
+    },
+    cb
+  );
+}
+function buildDecay(cfg, cb) {
+  return Animated.withDecay(
+    {
+      velocity: cfg.velocity ?? 0,
+      deceleration: cfg.deceleration,
+      clamp: cfg.clamp
+    },
+    cb
+  );
+}
+function buildOne(cfg, toValue, cb) {
+  if (cfg.type === "no-animation") {
+    if (cb) cb(true, toValue);
+    return toValue;
+  }
+  if (cfg.type === "decay") return buildDecay(cfg, cb);
+  if (cfg.type === "timing") return buildTiming(cfg, toValue, cb);
+  return buildSpring(cfg, toValue, cb);
+}
+function applyRepeat(animation, repeat) {
+  if (repeat === void 0) return animation;
+  if (repeat === "infinite") {
+    return Animated.withRepeat(animation, -1, true);
+  }
+  if (typeof repeat === "number") {
+    return Animated.withRepeat(animation, repeat, true);
+  }
+  const count = repeat.count === "infinite" ? -1 : repeat.count;
+  const alternate = repeat.alternate ?? true;
+  return Animated.withRepeat(animation, count, alternate);
+}
+function applyDelay(animation, delay) {
+  if (!delay || delay <= 0) return animation;
+  return Animated.withDelay(delay, animation);
+}
+function resolveTransition(config, toValue, callback) {
+  const cfg = config ?? { type: "spring" };
+  const base = buildOne(cfg, toValue, callback);
+  const repeated = applyRepeat(base, repeatOf(cfg));
+  return applyDelay(repeated, delayOf(cfg));
+}
+function repeatOf(cfg) {
+  if (cfg.type === "no-animation" || cfg.type === "decay") return void 0;
+  return cfg.repeat;
+}
+function stripRepeat(cfg) {
+  if (!cfg) return cfg;
+  if (cfg.type === "no-animation" || cfg.type === "decay") return cfg;
+  if (cfg.repeat === void 0) return cfg;
+  const next = { ...cfg };
+  delete next.repeat;
+  return next;
+}
+function delayOf(cfg) {
+  if (cfg.type === "no-animation") return void 0;
+  return cfg.delay;
+}
+function isStepObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) && "to" in v;
+}
+function resolveAnimatableValue(value, base, factory) {
+  if (Array.isArray(value)) {
+    const steps = value;
+    const stepBase = stripRepeat(base);
+    const animations = steps.map(
+      (step2, i) => resolveStep(step2, stepBase, factory?.("step", i))
+    );
+    const seq = Animated.withSequence(...animations);
+    return applyRepeat(seq, base ? repeatOf(base) : void 0);
+  }
+  const step = value;
+  const cb = factory?.("animation", void 0);
+  if (isStepObject(step)) {
+    return resolveStep(step, base, cb);
+  }
+  return resolveTransition(base, step, cb);
+}
+function resolveStep(step, base, cb) {
+  if (isStepObject(step)) {
+    const { to, ...override } = step;
+    const merged = mergeTransition(base, override);
+    return resolveTransition(merged, to, cb);
+  }
+  return resolveTransition(base, step, cb);
+}
+function mergeTransition(base, override) {
+  if (override.type && base && override.type !== base.type) {
+    return override;
+  }
+  return { ...base ?? { type: "spring" }, ...override };
+}
+var TRANSFORM_KEYS = [
+  "translateX",
+  "translateY",
+  "scale",
+  "scaleX",
+  "scaleY",
+  "rotate"
+];
+var TOP_LEVEL_KEYS = ["opacity", "width", "height", "borderRadius"];
+var ALL_KEYS = [...TRANSFORM_KEYS, ...TOP_LEVEL_KEYS];
+var TRANSFORM_KEY_SET = new Set(TRANSFORM_KEYS);
+var EXITING_POINTER_EVENTS_STYLE = { pointerEvents: "none" };
+var DEFAULT_RESTING = {
+  translateX: 0,
+  translateY: 0,
+  scale: 1,
+  scaleX: 1,
+  scaleY: 1,
+  rotate: 0,
+  opacity: 1,
+  width: 0,
+  height: 0,
+  borderRadius: 0
+};
+var TRANSITION_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_KEYS.has(k));
+}
+function transitionFor(prop, transition) {
+  if (!transition) return void 0;
+  if (isTopLevelTransition(transition)) return transition;
+  return transition[prop];
+}
+function createMotionComponent(Component) {
+  const AnimatedComponent = Animated__default.default.createAnimatedComponent(
+    Component
+  );
+  const Motion2 = react.forwardRef(function Motion3(props, ref) {
+    const {
+      initial,
+      animate,
+      exit,
+      transition,
+      variants,
+      controller,
+      gesture,
+      onAnimationEnd,
+      style,
+      ...rest
+    } = props;
+    const presence = usePresence();
+    const isExiting = presence !== null && presence.isPresent === false;
+    const shouldReduceMotion = useShouldReduceMotion();
+    const onAnimationEndRef = react.useRef(onAnimationEnd);
+    onAnimationEndRef.current = onAnimationEnd;
+    const variantKey = useControllerKey(controller);
+    const resolvedAnimate = resolveAnimateInput(
+      animate,
+      variants,
+      variantKey
+    );
+    const animateRecord = resolvedAnimate ?? {};
+    const initialRecord = initial && initial !== false ? initial : void 0;
+    const exitRecord = exit ? exit : void 0;
+    const [pressed, setPressed] = react.useState(false);
+    const [focused, setFocused] = react.useState(false);
+    const [hovered, setHovered] = react.useState(false);
+    const activeKeysRef = react.useRef(null);
+    if (activeKeysRef.current === null) {
+      const touched = /* @__PURE__ */ new Set();
+      for (const k of ALL_KEYS) {
+        if (k in animateRecord) touched.add(k);
+        if (initialRecord && k in initialRecord) touched.add(k);
+      }
+      if (variants) {
+        for (const variant of Object.values(variants)) {
+          if (!variant) continue;
+          for (const k of ALL_KEYS) {
+            if (k in variant) touched.add(k);
+          }
+        }
+      }
+      if (gesture) {
+        for (const subState of [
+          gesture.pressed,
+          gesture.focused,
+          gesture.hovered
+        ]) {
+          if (!subState) continue;
+          for (const k of ALL_KEYS) {
+            if (k in subState) touched.add(k);
+          }
+        }
+      }
+      if (exitRecord) {
+        for (const k of ALL_KEYS) {
+          if (k in exitRecord) touched.add(k);
+        }
+      }
+      activeKeysRef.current = ALL_KEYS.filter((k) => touched.has(k));
+    }
+    const hasTransformRef = react.useRef(
+      activeKeysRef.current.some((k) => TRANSFORM_KEY_SET.has(k))
+    );
+    const sharedValues = useAnimatableSharedValues((key) => {
+      if (initial === false) {
+        const a = animateRecord[key];
+        return restValue(a) ?? DEFAULT_RESTING[key];
+      }
+      return initialRecord?.[key] ?? restValue(animateRecord[key]) ?? DEFAULT_RESTING[key];
+    });
+    const mergedRecord = isExiting && exitRecord ? { ...animateRecord, ...exitRecord } : mergeGestureTargets(animateRecord, gesture, {
+      pressed,
+      focused,
+      hovered
+    });
+    const mergedSig = stableSig(mergedRecord) + (isExiting ? "|exit" : "") + (shouldReduceMotion ? "|rm" : "");
+    const transitionSig = stableSig(transition);
+    const safeToRemoveRef = react.useRef(void 0);
+    safeToRemoveRef.current = presence?.safeToRemove;
+    react.useEffect(() => {
+      if (isExiting && (!exitRecord || Object.keys(exitRecord).length === 0)) {
+        safeToRemoveRef.current?.();
+        return;
+      }
+      let pending = 0;
+      let done = false;
+      const onSettle = () => {
+        if (done) return;
+        pending--;
+        if (pending <= 0) {
+          done = true;
+          if (isExiting) safeToRemoveRef.current?.();
+        }
+      };
+      let transformPending = 0;
+      for (const k of ALL_KEYS) {
+        if (TRANSFORM_KEY_SET.has(k) && mergedRecord[k] !== void 0) {
+          transformPending++;
+        }
+      }
+      const transformGroup = transformPending > 0 ? { remaining: transformPending } : void 0;
+      for (const key of ALL_KEYS) {
+        const target = mergedRecord[key];
+        if (target === void 0) continue;
+        const cfg = shouldReduceMotion ? { type: "no-animation" } : transitionFor(key, transition);
+        if (isExiting) pending++;
+        const factory = makeKeyCallbackFactory(
+          key,
+          sharedValues[key],
+          targetEndValue(target),
+          onAnimationEndRef,
+          {
+            stepCount: stepCountOf(target),
+            totalIterations: totalIterationsOf(cfg)
+          },
+          isExiting ? onSettle : void 0,
+          TRANSFORM_KEY_SET.has(key) ? transformGroup : void 0
+        );
+        sharedValues[key].value = resolveAnimatableValue(
+          target,
+          cfg,
+          factory
+        );
+      }
+      if (isExiting && pending === 0) {
+        safeToRemoveRef.current?.();
+      }
+    }, [mergedSig, transitionSig]);
+    const animatedStyle = Animated.useAnimatedStyle(() => {
+      const activeKeys = activeKeysRef.current;
+      const hasTransform = hasTransformRef.current;
+      const out = {};
+      const transform = [];
+      for (const key of activeKeys) {
+        const v = sharedValues[key].value;
+        if (TRANSFORM_KEY_SET.has(key)) {
+          transform.push(
+            key === "rotate" ? { rotate: `${v}deg` } : { [key]: v }
+          );
+        } else {
+          out[key] = v;
+        }
+      }
+      if (hasTransform) out.transform = transform;
+      return out;
+    });
+    const mergedStyle = react.useMemo(
+      () => isExiting ? [style, animatedStyle, EXITING_POINTER_EVENTS_STYLE] : [style, animatedStyle],
+      [style, animatedStyle, isExiting]
+    );
+    const gestureHandlers = useGestureHandlers(
+      gesture,
+      rest,
+      setPressed,
+      setFocused,
+      setHovered
+    );
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      AnimatedComponent,
+      {
+        ref,
+        ...rest,
+        ...gestureHandlers,
+        style: mergedStyle
+      }
+    );
+  });
+  Motion2.displayName = `Motion(${Component.displayName ?? Component.name ?? "Component"})`;
+  return Motion2;
+}
+function useAnimatableSharedValues(init) {
+  const translateX = Animated.useSharedValue(init("translateX"));
+  const translateY = Animated.useSharedValue(init("translateY"));
+  const scale = Animated.useSharedValue(init("scale"));
+  const scaleX = Animated.useSharedValue(init("scaleX"));
+  const scaleY = Animated.useSharedValue(init("scaleY"));
+  const rotate = Animated.useSharedValue(init("rotate"));
+  const opacity = Animated.useSharedValue(init("opacity"));
+  const width = Animated.useSharedValue(init("width"));
+  const height = Animated.useSharedValue(init("height"));
+  const borderRadius = Animated.useSharedValue(init("borderRadius"));
+  const ref = react.useRef(null);
+  if (ref.current === null) {
+    ref.current = {
+      translateX,
+      translateY,
+      scale,
+      scaleX,
+      scaleY,
+      rotate,
+      opacity,
+      width,
+      height,
+      borderRadius
+    };
+  }
+  return ref.current;
+}
+function makeKeyCallbackFactory(key, sharedValue, target, onAnimationEndRef, meta, onSettle, transformGroup) {
+  if (!onAnimationEndRef.current && !onSettle) return void 0;
+  const state = { iteration: 0 };
+  const isTransformKey = TRANSFORM_KEY_SET.has(key);
+  const dispatch = (rawPhase, step, finished, value) => {
+    const isLastIteration = state.iteration >= meta.totalIterations - 1;
+    let phase;
+    let isTerminal = false;
+    if (rawPhase === "step") {
+      const isLastInPass = step !== void 0 && step === meta.stepCount - 1;
+      if (!isLastInPass) {
+        phase = "step";
+      } else if (isLastIteration) {
+        phase = "animation";
+        isTerminal = true;
+      } else {
+        phase = "sequence";
+      }
+    } else if (isLastIteration) {
+      phase = "animation";
+      isTerminal = true;
+    } else {
+      phase = "repeat";
+    }
+    const reportedIteration = state.iteration;
+    if (phase === "sequence" || phase === "repeat") state.iteration++;
+    const fn = onAnimationEndRef.current;
+    if (fn) {
+      if (isTransformKey && transformGroup && phase === "animation") {
+        transformGroup.remaining--;
+        if (transformGroup.remaining <= 0) {
+          fn({
+            key: "transform",
+            finished,
+            value,
+            target,
+            phase,
+            step,
+            iteration: reportedIteration
+          });
+        }
+      } else {
+        fn({
+          key,
+          finished,
+          value,
+          target,
+          phase,
+          step,
+          iteration: reportedIteration
+        });
+      }
+    }
+    if (onSettle && isTerminal) onSettle();
+  };
+  return (rawPhase, step) => {
+    const cb = (finished) => {
+      "worklet";
+      Animated.runOnJS(dispatch)(rawPhase, step, !!finished, sharedValue.value);
+    };
+    return cb;
+  };
+}
+function stepCountOf(v) {
+  if (Array.isArray(v)) return v.length;
+  return 1;
+}
+function totalIterationsOf(cfg) {
+  if (!cfg || cfg.type === "no-animation" || cfg.type === "decay") return 1;
+  const r = cfg.repeat;
+  if (r === void 0) return 1;
+  if (r === "infinite") return Number.POSITIVE_INFINITY;
+  if (typeof r === "number") return r;
+  if (r.count === "infinite") return Number.POSITIVE_INFINITY;
+  return r.count;
+}
+function targetEndValue(v) {
+  if (v === void 0) return void 0;
+  if (typeof v === "number" || typeof v === "string") return v;
+  if (Array.isArray(v)) {
+    return v.length > 0 ? targetEndValue(v[v.length - 1]) : void 0;
+  }
+  if (typeof v === "object" && v !== null && "to" in v) {
+    const to = v.to;
+    return typeof to === "number" || typeof to === "string" ? to : void 0;
+  }
+  return void 0;
+}
+function useControllerKey(controller) {
+  const [, setTick] = react.useState(0);
+  react.useEffect(() => {
+    if (!controller) return;
+    const unsub = controller.subscribe(() => setTick((n) => n + 1));
+    return unsub;
+  }, [controller]);
+  return controller?.current;
+}
+function resolveAnimateInput(animate, variants, controllerKey) {
+  if (controllerKey !== void 0 && variants && controllerKey in variants) {
+    return variants[controllerKey];
+  }
+  if (typeof animate === "string") {
+    if (variants && animate in variants) return variants[animate];
+    if (__DEV__) {
+      console.warn(
+        `[inertia] animate="${animate}" but no matching variant. Did you forget to pass \`variants\`?`
+      );
+    }
+    return void 0;
+  }
+  return animate;
+}
+function restValue(v) {
+  if (v === void 0) return void 0;
+  if (typeof v === "number") return v;
+  if (Array.isArray(v)) {
+    return v.length > 0 ? restValue(v[0]) : void 0;
+  }
+  if (typeof v === "object" && v !== null && "to" in v) {
+    const to = v.to;
+    return typeof to === "number" ? to : void 0;
+  }
+  return void 0;
+}
+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(",") + "}";
+}
+function mergeGestureTargets(base, gesture, active) {
+  if (!gesture) return base;
+  const merged = {
+    ...base
+  };
+  const subStates = [
+    gesture.hovered,
+    gesture.focused,
+    gesture.pressed
+  ];
+  for (const sub of subStates) {
+    if (!sub) continue;
+    for (const k of ALL_KEYS) {
+      if (k in sub && !(k in merged)) {
+        merged[k] = DEFAULT_RESTING[k];
+      }
+    }
+  }
+  if (active.hovered && gesture.hovered) {
+    Object.assign(
+      merged,
+      gesture.hovered
+    );
+  }
+  if (active.focused && gesture.focused) {
+    Object.assign(
+      merged,
+      gesture.focused
+    );
+  }
+  if (active.pressed && gesture.pressed) {
+    Object.assign(
+      merged,
+      gesture.pressed
+    );
+  }
+  return merged;
+}
+function useGestureHandlers(gesture, rest, setPressed, setFocused, setHovered) {
+  return react.useMemo(() => {
+    if (!gesture) return {};
+    const handlers = {};
+    if (gesture.pressed) {
+      handlers.onTouchStart = compose(rest.onTouchStart, () => setPressed(true));
+      handlers.onTouchEnd = compose(rest.onTouchEnd, () => setPressed(false));
+      handlers.onTouchCancel = compose(
+        rest.onTouchCancel,
+        () => setPressed(false)
+      );
+      handlers.onPressIn = compose(rest.onPressIn, () => setPressed(true));
+      handlers.onPressOut = compose(rest.onPressOut, () => setPressed(false));
+    }
+    if (gesture.focused) {
+      handlers.onFocus = compose(rest.onFocus, () => setFocused(true));
+      handlers.onBlur = compose(rest.onBlur, () => setFocused(false));
+    }
+    if (gesture.hovered) {
+      handlers.onMouseEnter = compose(rest.onMouseEnter, () => setHovered(true));
+      handlers.onMouseLeave = compose(
+        rest.onMouseLeave,
+        () => setHovered(false)
+      );
+    }
+    return handlers;
+  }, [
+    gesture?.pressed ? 1 : 0,
+    gesture?.focused ? 1 : 0,
+    gesture?.hovered ? 1 : 0,
+    rest.onTouchStart,
+    rest.onTouchEnd,
+    rest.onTouchCancel,
+    rest.onPressIn,
+    rest.onPressOut,
+    rest.onFocus,
+    rest.onBlur,
+    rest.onMouseEnter,
+    rest.onMouseLeave
+  ]);
+}
+function compose(user, ours) {
+  if (typeof user !== "function") return ours;
+  return (event) => {
+    user(event);
+    ours(event);
+  };
+}
+
+// src/motion/Image.tsx
+var MotionImage = createMotionComponent(reactNative.Image);
+var MotionPressable = createMotionComponent(reactNative.Pressable);
+var MotionScrollView = createMotionComponent(reactNative.ScrollView);
+var MotionText = createMotionComponent(reactNative.Text);
+var MotionView = createMotionComponent(reactNative.View);
+
+// src/motion/index.ts
+var Motion = {
+  View: MotionView,
+  Text: MotionText,
+  Image: MotionImage,
+  Pressable: MotionPressable,
+  ScrollView: MotionScrollView
+};
+function useVariants(variants, initial) {
+  const variantsRef = react.useRef(variants);
+  return react.useMemo(() => {
+    const listeners = /* @__PURE__ */ new Set();
+    let current = initial ?? (Object.keys(variantsRef.current)[0] ?? "");
+    const controller = {
+      get current() {
+        return current;
+      },
+      transitionTo(next) {
+        if (next === current) return;
+        if (!(next in variantsRef.current)) {
+          if (__DEV__) {
+            console.warn(
+              `[inertia] useVariants: unknown variant "${String(next)}". Known keys: ${Object.keys(variantsRef.current).join(", ")}`
+            );
+          }
+          return;
+        }
+        current = next;
+        for (const fn of listeners) fn(next);
+      },
+      subscribe(listener) {
+        listeners.add(listener);
+        return () => {
+          listeners.delete(listener);
+        };
+      }
+    };
+    return controller;
+  }, []);
+}
+
+exports.Motion = Motion;
+exports.MotionConfig = MotionConfig;
+exports.MotionImage = MotionImage;
+exports.MotionPressable = MotionPressable;
+exports.MotionScrollView = MotionScrollView;
+exports.MotionText = MotionText;
+exports.MotionView = MotionView;
+exports.Presence = Presence;
+exports.createMotionComponent = createMotionComponent;
+exports.ensureWorkletEasing = ensureWorkletEasing;
+exports.resolveAnimatableValue = resolveAnimatableValue;
+exports.resolveTransition = resolveTransition;
+exports.useMotionConfig = useMotionConfig;
+exports.usePresence = usePresence;
+exports.useShouldReduceMotion = useShouldReduceMotion;
+exports.useVariants = useVariants;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map