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

package/dist/chunk-6UQ4KA6V.js

@@ -0,0 +1,1011 @@
+'use strict';
+
+var chunk6EP3S2PN_js = require('./chunk-6EP3S2PN.js');
+var chunkSFRNO6AW_js = require('./chunk-SFRNO6AW.js');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var Animated = require('react-native-reanimated');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Animated__default = /*#__PURE__*/_interopDefault(Animated);
+
+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 resolveLayoutTransition(layout) {
+  if (!layout) return void 0;
+  const cfg = layout === true ? { type: "spring" } : layout;
+  if (cfg.type === "no-animation") return void 0;
+  if (cfg.type === "timing") {
+    let builder2 = Animated.LinearTransition.duration(cfg.duration ?? 300);
+    const easing = chunkSFRNO6AW_js.ensureWorkletEasing(cfg.easing);
+    if (easing) builder2 = builder2.easing(easing);
+    if (cfg.delay) builder2 = builder2.delay(cfg.delay);
+    return builder2;
+  }
+  const spring = cfg.type === "decay" ? { type: "spring" } : cfg;
+  const { stiffness, damping, mass } = chunkSFRNO6AW_js.springToReanimated({
+    ...chunkSFRNO6AW_js.DEFAULT_SPRING,
+    ...spring
+  });
+  let builder = Animated.LinearTransition.springify().stiffness(stiffness).damping(damping).mass(mass);
+  if ("delay" in spring && spring.delay) builder = builder.delay(spring.delay);
+  return builder;
+}
+
+// src/layout/sharedRegistry.ts
+var REGISTRY = /* @__PURE__ */ new Map();
+var SHARED_LAYOUT_TTL_MS = 1e3;
+var now = () => Date.now();
+function registerLayout(id, rect) {
+  REGISTRY.set(id, { rect, expiresAt: now() + SHARED_LAYOUT_TTL_MS });
+}
+function releaseLayout(id, rect) {
+  REGISTRY.set(id, { rect, expiresAt: now() + SHARED_LAYOUT_TTL_MS });
+}
+function consumeLayout(id) {
+  const entry = REGISTRY.get(id);
+  if (!entry) return void 0;
+  REGISTRY.delete(id);
+  if (entry.expiresAt < now()) return void 0;
+  return entry.rect;
+}
+function useSharedLayout(options) {
+  const { layoutId, userRef, transition, shouldReduceMotion, userOnLayout } = options;
+  const dx = Animated.useSharedValue(0);
+  const dy = Animated.useSharedValue(0);
+  const sx = Animated.useSharedValue(1);
+  const sy = Animated.useSharedValue(1);
+  const lastRectRef = react.useRef(null);
+  const consumedRef = react.useRef(false);
+  const transitionRef = react.useRef(transition);
+  transitionRef.current = transition;
+  const reducedMotionRef = react.useRef(shouldReduceMotion);
+  reducedMotionRef.current = shouldReduceMotion;
+  const setRef = react.useCallback(
+    (node) => {
+      if (typeof userRef === "function") userRef(node);
+      else if (userRef) userRef.current = node;
+    },
+    [userRef]
+  );
+  const onLayout = react.useCallback(
+    (event) => {
+      userOnLayout?.(event);
+      if (!layoutId) return;
+      const { x, y, width, height } = event.nativeEvent.layout;
+      const rect = { x, y, width, height };
+      lastRectRef.current = rect;
+      let source;
+      if (!consumedRef.current) {
+        consumedRef.current = true;
+        source = consumeLayout(layoutId);
+      }
+      registerLayout(layoutId, rect);
+      if (source) {
+        applyFlip({
+          source,
+          target: rect,
+          dx,
+          dy,
+          sx,
+          sy,
+          transition: transitionRef.current,
+          shouldReduceMotion: reducedMotionRef.current
+        });
+      }
+    },
+    // dx/dy/sx/sy are stable refs from useSharedValue, but eslint's
+    // exhaustive-deps would flag them — including them is harmless and
+    // silences the warning.
+    [layoutId, userOnLayout, dx, dy, sx, sy]
+  );
+  react.useEffect(() => {
+    consumedRef.current = false;
+  }, [layoutId]);
+  react.useEffect(() => {
+    return () => {
+      if (!layoutId) return;
+      const rect = lastRectRef.current;
+      if (!rect) return;
+      releaseLayout(layoutId, rect);
+    };
+  }, [layoutId]);
+  return react.useMemo(
+    () => ({
+      flip: { dx, dy, sx, sy },
+      setRef,
+      onLayout
+    }),
+    [dx, dy, sx, sy, setRef, onLayout]
+  );
+}
+function applyFlip(args) {
+  const { source, target, dx, dy, sx, sy, transition, shouldReduceMotion } = args;
+  const sourceCenterX = source.x + source.width / 2;
+  const sourceCenterY = source.y + source.height / 2;
+  const targetCenterX = target.x + target.width / 2;
+  const targetCenterY = target.y + target.height / 2;
+  const deltaX = sourceCenterX - targetCenterX;
+  const deltaY = sourceCenterY - targetCenterY;
+  const scaleX = target.width > 0 ? source.width / target.width : 1;
+  const scaleY = target.height > 0 ? source.height / target.height : 1;
+  if (shouldReduceMotion) {
+    dx.value = 0;
+    dy.value = 0;
+    sx.value = 1;
+    sy.value = 1;
+    return;
+  }
+  if (transition?.type === "no-animation") {
+    dx.value = 0;
+    dy.value = 0;
+    sx.value = 1;
+    sy.value = 1;
+    return;
+  }
+  if (transition?.type === "timing") {
+    const duration = transition.duration ?? 300;
+    dx.value = Animated.withSequence(
+      Animated.withTiming(deltaX, { duration: 0 }),
+      Animated.withTiming(0, { duration })
+    );
+    dy.value = Animated.withSequence(
+      Animated.withTiming(deltaY, { duration: 0 }),
+      Animated.withTiming(0, { duration })
+    );
+    sx.value = Animated.withSequence(
+      Animated.withTiming(scaleX, { duration: 0 }),
+      Animated.withTiming(1, { duration })
+    );
+    sy.value = Animated.withSequence(
+      Animated.withTiming(scaleY, { duration: 0 }),
+      Animated.withTiming(1, { duration })
+    );
+    return;
+  }
+  const springCfg = transition?.type === "spring" ? { ...chunkSFRNO6AW_js.DEFAULT_SPRING, ...transition } : { type: "spring", ...chunkSFRNO6AW_js.DEFAULT_SPRING };
+  const springParams = chunkSFRNO6AW_js.springToReanimated(springCfg);
+  dx.value = Animated.withSequence(
+    Animated.withTiming(deltaX, { duration: 0 }),
+    Animated.withSpring(0, springParams)
+  );
+  dy.value = Animated.withSequence(
+    Animated.withTiming(deltaY, { duration: 0 }),
+    Animated.withSpring(0, springParams)
+  );
+  sx.value = Animated.withSequence(
+    Animated.withTiming(scaleX, { duration: 0 }),
+    Animated.withSpring(1, springParams)
+  );
+  sy.value = Animated.withSequence(
+    Animated.withTiming(scaleY, { duration: 0 }),
+    Animated.withSpring(1, springParams)
+  );
+}
+var alreadyChecked = false;
+function ensureReanimatedInstalled() {
+  if (!__DEV__ || alreadyChecked) return;
+  if (typeof process !== "undefined" && process.env?.NODE_ENV === "test") {
+    return;
+  }
+  alreadyChecked = true;
+  const version = Animated.reanimatedVersion;
+  if (version) {
+    const major = parseInt(version.split(".")[0] ?? "0", 10);
+    if (major < 4) {
+      console.error(
+        `[inertia] react-native-reanimated v${version} is installed, but @rootnative/inertia requires v4.0.0 or later. Upgrade with \`pnpm add react-native-reanimated@^4\` (or your package manager's equivalent).`
+      );
+      return;
+    }
+  }
+  const probe = function probe2() {
+    "worklet";
+    return 0;
+  };
+  if (typeof probe.__workletHash !== "number") {
+    console.error(
+      `[inertia] The Reanimated worklets babel plugin is not configured. Add \`'react-native-worklets/plugin'\` as the LAST entry in the \`plugins\` array of your \`babel.config.js\`, then restart Metro with a fresh cache: \`npx expo start -c\` or \`npx react-native start --reset-cache\`.`
+    );
+  }
+}
+var TRANSFORM_KEYS = [
+  "translateX",
+  "translateY",
+  "scale",
+  "scaleX",
+  "scaleY",
+  "rotate",
+  "rotateX",
+  "rotateY"
+];
+var ROTATION_KEYS = /* @__PURE__ */ new Set(["rotate", "rotateX", "rotateY"]);
+var NUMERIC_TOP_LEVEL_KEYS = [
+  "opacity",
+  "width",
+  "height",
+  "borderRadius",
+  "shadowOpacity",
+  "shadowRadius",
+  "elevation"
+];
+var COLOR_KEYS = [
+  "backgroundColor",
+  "borderColor",
+  "color",
+  "tintColor",
+  "shadowColor"
+];
+var SHADOW_OFFSET_KEYS = ["shadowOffsetWidth", "shadowOffsetHeight"];
+var ALL_KEYS = [
+  ...TRANSFORM_KEYS,
+  ...NUMERIC_TOP_LEVEL_KEYS,
+  ...COLOR_KEYS,
+  ...SHADOW_OFFSET_KEYS
+];
+var TRANSFORM_KEY_SET = new Set(TRANSFORM_KEYS);
+var COLOR_KEY_SET = new Set(COLOR_KEYS);
+var SHADOW_OFFSET_KEY_SET = new Set(SHADOW_OFFSET_KEYS);
+var GESTURE_LAYER_NAMES = [
+  "hovered",
+  "focused",
+  "focusVisible",
+  "pressed"
+];
+var GESTURE_LAYER_NAME_SET = new Set(GESTURE_LAYER_NAMES);
+var EXITING_POINTER_EVENTS_STYLE = { pointerEvents: "none" };
+var DEFAULT_RESTING = {
+  translateX: 0,
+  translateY: 0,
+  scale: 1,
+  scaleX: 1,
+  scaleY: 1,
+  rotate: 0,
+  rotateX: 0,
+  rotateY: 0,
+  opacity: 1,
+  width: 0,
+  height: 0,
+  borderRadius: 0,
+  shadowOpacity: 0,
+  shadowRadius: 0,
+  elevation: 0,
+  // 'transparent' is the only safe universal default for colors: it works as
+  // an initial seed for any color animation (no jarring opaque flash on mount
+  // when `initial` is omitted) and rgba(0,0,0,0) interpolates cleanly into
+  // any opaque target via Reanimated's color util.
+  backgroundColor: "transparent",
+  borderColor: "transparent",
+  color: "transparent",
+  tintColor: "transparent",
+  shadowColor: "transparent",
+  shadowOffsetWidth: 0,
+  shadowOffsetHeight: 0
+};
+function transitionFor(prop, transition) {
+  if (!transition) return void 0;
+  if (typeof transition === "string") return void 0;
+  if (chunkSFRNO6AW_js.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 (chunkSFRNO6AW_js.isTopLevelTransition(transition)) return transition;
+  return transition[layer];
+}
+function createMotionComponent(Component) {
+  ensureReanimatedInstalled();
+  const AnimatedComponent = Animated__default.default.createAnimatedComponent(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Component
+  );
+  const Motion = react.forwardRef(function Motion2(props, ref) {
+    const {
+      initial,
+      animate,
+      exit,
+      transition: transitionProp,
+      variants,
+      controller,
+      gesture,
+      layout: layoutProp,
+      layoutId,
+      onAnimationEnd,
+      style,
+      onLayout: userOnLayout,
+      ...rest
+    } = props;
+    const namedTransitions = chunk6EP3S2PN_js.useNamedTransitions();
+    const transition = chunk6EP3S2PN_js.resolveNamedTransitionProp(
+      transitionProp,
+      namedTransitions
+    );
+    const layout = typeof layoutProp === "string" ? chunk6EP3S2PN_js.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."
+      );
+    }
+    const presence = usePresence();
+    const isExiting = presence !== null && presence.isPresent === false;
+    const shouldReduceMotion = chunk6EP3S2PN_js.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 [focusVisible, setFocusVisible] = react.useState(false);
+    const [hovered, setHovered] = react.useState(false);
+    const touched = /* @__PURE__ */ new Set();
+    collectTouchedKeys(touched, animateRecord);
+    if (initialRecord) collectTouchedKeys(touched, initialRecord);
+    if (variants) {
+      for (const variant of Object.values(variants)) {
+        if (!variant) continue;
+        collectTouchedKeys(touched, variant);
+      }
+    }
+    if (gesture) {
+      for (const subState of [
+        gesture.pressed,
+        gesture.focused,
+        gesture.focusVisible,
+        gesture.hovered
+      ]) {
+        if (!subState) continue;
+        collectTouchedKeys(touched, subState);
+      }
+    }
+    if (exitRecord) collectTouchedKeys(touched, exitRecord);
+    const activeKeysRef = react.useRef(null);
+    const hasTransformRef = react.useRef(false);
+    const hasShadowOffsetRef = react.useRef(false);
+    const prevActive = activeKeysRef.current;
+    let grew = prevActive === null;
+    if (!grew && prevActive) {
+      for (const k of touched) {
+        if (!prevActive.includes(k)) {
+          grew = true;
+          break;
+        }
+      }
+    }
+    if (grew) {
+      const merged = new Set(prevActive ?? []);
+      for (const k of touched) merged.add(k);
+      activeKeysRef.current = ALL_KEYS.filter((k) => merged.has(k));
+      hasTransformRef.current = activeKeysRef.current.some(
+        (k) => TRANSFORM_KEY_SET.has(k)
+      );
+      hasShadowOffsetRef.current = activeKeysRef.current.some(
+        (k) => SHADOW_OFFSET_KEY_SET.has(k)
+      );
+    }
+    const sharedValues = useAnimatableSharedValues((key) => {
+      if (SHADOW_OFFSET_KEY_SET.has(key)) {
+        const axis = shadowOffsetAxisFor(key);
+        if (initial === false) {
+          return shadowOffsetAxisValue(animateRecord.shadowOffset, axis) ?? DEFAULT_RESTING[key];
+        }
+        return shadowOffsetAxisValue(
+          initialRecord?.shadowOffset,
+          axis
+        ) ?? shadowOffsetAxisValue(animateRecord.shadowOffset, axis) ?? DEFAULT_RESTING[key];
+      }
+      if (initial === false) {
+        const a = animateRecord[key];
+        return restValue(a) ?? DEFAULT_RESTING[key];
+      }
+      return initialRecord?.[key] ?? restValue(animateRecord[key]) ?? DEFAULT_RESTING[key];
+    });
+    const pressedProgress = Animated.useSharedValue(0);
+    const focusedProgress = Animated.useSharedValue(0);
+    const focusVisibleProgress = Animated.useSharedValue(0);
+    const hoveredProgress = Animated.useSharedValue(0);
+    const gestureSV = Animated.useSharedValue(
+      resolveGestureLayers(gesture)
+    );
+    const gestureTargetsSig = chunkSFRNO6AW_js.stableSig(gesture);
+    react.useEffect(() => {
+      gestureSV.value = resolveGestureLayers(gesture);
+    }, [gestureTargetsSig]);
+    const baseRecord = isExiting && exitRecord ? { ...animateRecord, ...exitRecord } : animateRecord;
+    const baseSig = chunkSFRNO6AW_js.stableSig(baseRecord) + (isExiting ? "|exit" : "") + (shouldReduceMotion ? "|rm" : "");
+    const transitionSig = chunkSFRNO6AW_js.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) && baseRecord[k] !== void 0) {
+          transformPending++;
+        }
+      }
+      const transformGroup = transformPending > 0 ? { remaining: transformPending } : void 0;
+      for (const key of ALL_KEYS) {
+        const target = SHADOW_OFFSET_KEY_SET.has(key) ? shadowOffsetAxisValue(
+          baseRecord.shadowOffset,
+          shadowOffsetAxisFor(key)
+        ) : baseRecord[key];
+        if (target === void 0) continue;
+        const cfg = shouldReduceMotion ? { type: "no-animation" } : transitionFor(
+          SHADOW_OFFSET_KEY_SET.has(key) ? "shadowOffset" : 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 = chunkSFRNO6AW_js.resolveAnimatableValue(
+          target,
+          cfg,
+          factory
+        );
+      }
+      if (isExiting && pending === 0) {
+        safeToRemoveRef.current?.();
+      }
+    }, [baseSig, transitionSig]);
+    useGestureLayerProgress(
+      pressedProgress,
+      pressed,
+      gesture?.pressed != null,
+      "pressed",
+      transition,
+      isExiting,
+      shouldReduceMotion
+    );
+    useGestureLayerProgress(
+      focusedProgress,
+      focused,
+      gesture?.focused != null,
+      "focused",
+      transition,
+      isExiting,
+      shouldReduceMotion
+    );
+    useGestureLayerProgress(
+      focusVisibleProgress,
+      focusVisible,
+      gesture?.focusVisible != null,
+      "focusVisible",
+      transition,
+      isExiting,
+      shouldReduceMotion
+    );
+    useGestureLayerProgress(
+      hoveredProgress,
+      hovered,
+      gesture?.hovered != null,
+      "hovered",
+      transition,
+      isExiting,
+      shouldReduceMotion
+    );
+    const sharedLayout = useSharedLayout({
+      layoutId,
+      userRef: ref,
+      transition: chunkSFRNO6AW_js.isTopLevelTransition(transition) ? transition : void 0,
+      shouldReduceMotion,
+      userOnLayout
+    });
+    const flip = sharedLayout.flip;
+    const hasLayoutId = layoutId !== void 0;
+    const animatedStyle = Animated.useAnimatedStyle(() => {
+      const activeKeys = activeKeysRef.current;
+      const hasTransform = hasTransformRef.current;
+      const hasShadowOffset = hasShadowOffsetRef.current;
+      const out = {};
+      const transform = [];
+      let shadowOffsetW = 0;
+      let shadowOffsetH = 0;
+      const ph = hoveredProgress.value;
+      const pf = focusedProgress.value;
+      const pfv = focusVisibleProgress.value;
+      const pp = pressedProgress.value;
+      const layers = gestureSV.value;
+      const hoveredLayer = layers ? layers.hovered : null;
+      const focusedLayer = layers ? layers.focused : null;
+      const focusVisibleLayer = layers ? layers.focusVisible : null;
+      const pressedLayer = layers ? layers.pressed : null;
+      for (const key of activeKeys) {
+        let v = sharedValues[key].value;
+        const isColor = COLOR_KEY_SET.has(key);
+        if (hoveredLayer && ph > 0 && hoveredLayer[key] !== void 0) {
+          const t = hoveredLayer[key];
+          v = isColor ? Animated.interpolateColor(ph, [0, 1], [v, t]) : v + (t - v) * ph;
+        }
+        if (focusedLayer && pf > 0 && focusedLayer[key] !== void 0) {
+          const t = focusedLayer[key];
+          v = isColor ? Animated.interpolateColor(pf, [0, 1], [v, t]) : v + (t - v) * pf;
+        }
+        if (focusVisibleLayer && pfv > 0 && focusVisibleLayer[key] !== void 0) {
+          const t = focusVisibleLayer[key];
+          v = isColor ? Animated.interpolateColor(pfv, [0, 1], [v, t]) : v + (t - v) * pfv;
+        }
+        if (pressedLayer && pp > 0 && pressedLayer[key] !== void 0) {
+          const t = pressedLayer[key];
+          v = isColor ? Animated.interpolateColor(pp, [0, 1], [v, t]) : v + (t - v) * pp;
+        }
+        if (TRANSFORM_KEY_SET.has(key)) {
+          transform.push(
+            ROTATION_KEYS.has(key) ? { [key]: `${v}deg` } : { [key]: v }
+          );
+        } else if (key === "shadowOffsetWidth") {
+          shadowOffsetW = v;
+        } else if (key === "shadowOffsetHeight") {
+          shadowOffsetH = v;
+        } else {
+          out[key] = v;
+        }
+      }
+      if (hasLayoutId) {
+        transform.push({ translateX: flip.dx.value });
+        transform.push({ translateY: flip.dy.value });
+        transform.push({ scaleX: flip.sx.value });
+        transform.push({ scaleY: flip.sy.value });
+      }
+      if (hasTransform || hasLayoutId) out.transform = transform;
+      if (hasShadowOffset) {
+        out.shadowOffset = { width: shadowOffsetW, height: shadowOffsetH };
+      }
+      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,
+      setFocusVisible,
+      setHovered
+    );
+    const layoutSig = chunkSFRNO6AW_js.stableSig(layout);
+    const layoutTransition = react.useMemo(
+      () => shouldReduceMotion ? void 0 : resolveLayoutTransition(layout),
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      [layoutSig, shouldReduceMotion]
+    );
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      AnimatedComponent,
+      {
+        ref: sharedLayout.setRef,
+        ...rest,
+        ...gestureHandlers,
+        onLayout: sharedLayout.onLayout,
+        layout: layoutTransition,
+        style: mergedStyle
+      }
+    );
+  });
+  Motion.displayName = `Motion(${Component.displayName ?? Component.name ?? "Component"})`;
+  return Motion;
+}
+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 rotateX = Animated.useSharedValue(init("rotateX"));
+  const rotateY = Animated.useSharedValue(init("rotateY"));
+  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 shadowOpacity = Animated.useSharedValue(init("shadowOpacity"));
+  const shadowRadius = Animated.useSharedValue(init("shadowRadius"));
+  const elevation = Animated.useSharedValue(init("elevation"));
+  const backgroundColor = Animated.useSharedValue(
+    init("backgroundColor")
+  );
+  const borderColor = Animated.useSharedValue(init("borderColor"));
+  const color = Animated.useSharedValue(init("color"));
+  const tintColor = Animated.useSharedValue(init("tintColor"));
+  const shadowColor = Animated.useSharedValue(init("shadowColor"));
+  const shadowOffsetWidth = Animated.useSharedValue(
+    init("shadowOffsetWidth")
+  );
+  const shadowOffsetHeight = Animated.useSharedValue(
+    init("shadowOffsetHeight")
+  );
+  const ref = react.useRef(null);
+  if (ref.current === null) {
+    ref.current = {
+      translateX,
+      translateY,
+      scale,
+      scaleX,
+      scaleY,
+      rotate,
+      rotateX,
+      rotateY,
+      opacity,
+      width,
+      height,
+      borderRadius,
+      shadowOpacity,
+      shadowRadius,
+      elevation,
+      backgroundColor,
+      borderColor,
+      color,
+      tintColor,
+      shadowColor,
+      shadowOffsetWidth,
+      shadowOffsetHeight
+    };
+  }
+  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 shadowOffsetAxisFor(key) {
+  return key === "shadowOffsetWidth" ? "width" : "height";
+}
+function shadowOffsetAxisValue(source, axis) {
+  return source?.[axis];
+}
+function collectTouchedKeys(touched, record) {
+  for (const k of ALL_KEYS) {
+    if (k in record) touched.add(k);
+  }
+  if ("shadowOffset" in record && record.shadowOffset) {
+    const so = record.shadowOffset;
+    if (so.width !== void 0) touched.add("shadowOffsetWidth");
+    if (so.height !== void 0) touched.add("shadowOffsetHeight");
+  }
+}
+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" || typeof v === "string") 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" || typeof to === "string" ? to : void 0;
+  }
+  return void 0;
+}
+function resolveGestureLayers(gesture) {
+  if (!gesture) return null;
+  const out = {};
+  for (const layer of GESTURE_LAYER_NAMES) {
+    const subState = gesture[layer];
+    if (!subState) continue;
+    const resolved = {};
+    for (const key of ALL_KEYS) {
+      if (SHADOW_OFFSET_KEY_SET.has(key)) {
+        const axis = shadowOffsetAxisFor(key);
+        const so = subState.shadowOffset;
+        const v = shadowOffsetAxisValue(so, axis);
+        if (v !== void 0) resolved[key] = v;
+        continue;
+      }
+      const raw = subState[key];
+      if (raw === void 0) continue;
+      const t = targetEndValue(raw);
+      if (t !== void 0) resolved[key] = t;
+    }
+    out[layer] = resolved;
+  }
+  return out;
+}
+function useGestureLayerProgress(progress, active, declared, layer, transition, isExiting, shouldReduceMotion) {
+  const layerCfgSig = chunkSFRNO6AW_js.stableSig(gestureLayerTransitionFor(layer, transition));
+  react.useEffect(() => {
+    if (!declared) return;
+    if (isExiting) {
+      progress.value = 0;
+      return;
+    }
+    const target = active ? 1 : 0;
+    const cfg = shouldReduceMotion ? { type: "no-animation" } : gestureLayerTransitionFor(layer, transition) ?? { type: "spring" };
+    progress.value = chunkSFRNO6AW_js.resolveTransition(cfg, target);
+  }, [active, declared, isExiting, shouldReduceMotion, layerCfgSig]);
+}
+function useGestureHandlers(gesture, rest, setPressed, setFocused, setFocusVisible, setHovered) {
+  const hasPressed = gesture?.pressed ? 1 : 0;
+  const hasFocused = gesture?.focused ? 1 : 0;
+  const hasFocusVisible = gesture?.focusVisible ? 1 : 0;
+  const hasHovered = gesture?.hovered ? 1 : 0;
+  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 || gesture.focusVisible) {
+      handlers.onFocus = compose(rest.onFocus, () => {
+        if (gesture.focused) setFocused(true);
+        if (gesture.focusVisible && chunk6EP3S2PN_js.isFocusVisible()) setFocusVisible(true);
+      });
+      handlers.onBlur = compose(rest.onBlur, () => {
+        if (gesture.focused) setFocused(false);
+        if (gesture.focusVisible) setFocusVisible(false);
+      });
+    }
+    if (gesture.hovered) {
+      handlers.onMouseEnter = compose(rest.onMouseEnter, () => setHovered(true));
+      handlers.onMouseLeave = compose(
+        rest.onMouseLeave,
+        () => setHovered(false)
+      );
+    }
+    return handlers;
+  }, [
+    hasPressed,
+    hasFocused,
+    hasFocusVisible,
+    hasHovered,
+    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);
+  };
+}
+
+exports.Presence = Presence;
+exports.createMotionComponent = createMotionComponent;
+exports.usePresence = usePresence;