@onlynative/inertia 0.0.1-alpha.4 → 0.0.1-alpha.6

package/dist/index.mjs

@@ -1455,13 +1455,17 @@ if (globalThis._ALWAYS_FALSE) {
 // src/transitions/easing.ts
 function ensureWorkletEasing(easing) {
   if (!easing) return void 0;
-  if (isWorkletFunction(easing)) return easing;
+  const fn = isEasingFactory(easing) ? easing.factory() : easing;
+  if (isWorkletFunction(fn)) return fn;
   const wrapped = (t) => {
     "worklet";
-    return easing(t);
+    return fn(t);
   };
   return wrapped;
 }
+function isEasingFactory(value) {
+  return typeof value === "object" && value !== null && "factory" in value && typeof value.factory === "function";
+}
 
 // src/transitions/spring.ts
 var DEFAULT_SPRING = {
@@ -1470,6 +1474,7 @@ var DEFAULT_SPRING = {
   mass: 1
 };
 function springToReanimated(t) {
+  "worklet";
   return {
     stiffness: t.tension ?? DEFAULT_SPRING.tension,
     damping: t.friction ?? DEFAULT_SPRING.friction,
@@ -1724,6 +1729,28 @@ function isTopLevelTransition(t) {
   if (keys.length === 0) return false;
   return keys.every((k) => TRANSITION_CONFIG_KEYS.has(k));
 }
+var DEFAULT_TIMING_DURATION2 = 250;
+function buildReleaseAnimation(transition, toValue) {
+  "worklet";
+  if (transition.type === "no-animation") return toValue;
+  if (transition.type === "decay") {
+    const cfg = { velocity: transition.velocity ?? 0 };
+    if (transition.deceleration !== void 0) {
+      cfg.deceleration = transition.deceleration;
+    }
+    if (transition.clamp !== void 0) cfg.clamp = transition.clamp;
+    return withDecay(cfg);
+  }
+  if (transition.type === "timing") {
+    const e = transition.easing;
+    const easingFn = e && typeof e === "object" && "factory" in e ? e.factory() : e ?? Easing.inOut(Easing.ease);
+    return withTiming(toValue, {
+      duration: transition.duration ?? DEFAULT_TIMING_DURATION2,
+      easing: easingFn
+    });
+  }
+  return withSpring(toValue, springToReanimated(transition));
+}
 
 // src/transitions/sig.ts
 function stableSig(value) {
@@ -1795,21 +1822,28 @@ var NUMERIC_TOP_LEVEL_KEYS = [
   "opacity",
   "width",
   "height",
-  "borderRadius"
+  "borderRadius",
+  "shadowOpacity",
+  "shadowRadius",
+  "elevation"
 ];
 var COLOR_KEYS = [
   "backgroundColor",
   "borderColor",
   "color",
-  "tintColor"
+  "tintColor",
+  "shadowColor"
 ];
+var SHADOW_OFFSET_KEYS = ["shadowOffsetWidth", "shadowOffsetHeight"];
 var ALL_KEYS = [
   ...TRANSFORM_KEYS,
   ...NUMERIC_TOP_LEVEL_KEYS,
-  ...COLOR_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",
@@ -1831,6 +1865,9 @@ var DEFAULT_RESTING = {
   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
@@ -1838,7 +1875,10 @@ var DEFAULT_RESTING = {
   backgroundColor: "transparent",
   borderColor: "transparent",
   color: "transparent",
-  tintColor: "transparent"
+  tintColor: "transparent",
+  shadowColor: "transparent",
+  shadowOffsetWidth: 0,
+  shadowOffsetHeight: 0
 };
 function transitionFor(prop, transition) {
   if (!transition) return void 0;
@@ -1892,16 +1932,12 @@ function createMotionComponent(Component) {
     const activeKeysRef = 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);
-      }
+      collectTouchedKeys(touched, animateRecord);
+      if (initialRecord) collectTouchedKeys(touched, initialRecord);
       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);
-          }
+          collectTouchedKeys(touched, variant);
         }
       }
       if (gesture) {
@@ -1912,22 +1948,29 @@ function createMotionComponent(Component) {
           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);
+          collectTouchedKeys(touched, subState);
         }
       }
+      if (exitRecord) collectTouchedKeys(touched, exitRecord);
       activeKeysRef.current = ALL_KEYS.filter((k) => touched.has(k));
     }
     const hasTransformRef = useRef(
       activeKeysRef.current.some((k) => TRANSFORM_KEY_SET.has(k))
     );
+    const hasShadowOffsetRef = useRef(
+      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];
@@ -1973,9 +2016,15 @@ function createMotionComponent(Component) {
       }
       const transformGroup = transformPending > 0 ? { remaining: transformPending } : void 0;
       for (const key of ALL_KEYS) {
-        const target = baseRecord[key];
+        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(key, transition);
+        const cfg = shouldReduceMotion ? { type: "no-animation" } : transitionFor(
+          SHADOW_OFFSET_KEY_SET.has(key) ? "shadowOffset" : key,
+          transition
+        );
         if (isExiting) pending++;
         const factory = makeKeyCallbackFactory(
           key,
@@ -2038,8 +2087,11 @@ function createMotionComponent(Component) {
     const animatedStyle = 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;
@@ -2072,11 +2124,18 @@ function createMotionComponent(Component) {
           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 (hasTransform) out.transform = transform;
+      if (hasShadowOffset) {
+        out.shadowOffset = { width: shadowOffsetW, height: shadowOffsetH };
+      }
       return out;
     });
     const mergedStyle = useMemo(
@@ -2124,12 +2183,22 @@ function useAnimatableSharedValues(init2) {
   const width = useSharedValue(init2("width"));
   const height = useSharedValue(init2("height"));
   const borderRadius = useSharedValue(init2("borderRadius"));
+  const shadowOpacity = useSharedValue(init2("shadowOpacity"));
+  const shadowRadius = useSharedValue(init2("shadowRadius"));
+  const elevation = useSharedValue(init2("elevation"));
   const backgroundColor = useSharedValue(
     init2("backgroundColor")
   );
   const borderColor = useSharedValue(init2("borderColor"));
   const color = useSharedValue(init2("color"));
   const tintColor = useSharedValue(init2("tintColor"));
+  const shadowColor = useSharedValue(init2("shadowColor"));
+  const shadowOffsetWidth = useSharedValue(
+    init2("shadowOffsetWidth")
+  );
+  const shadowOffsetHeight = useSharedValue(
+    init2("shadowOffsetHeight")
+  );
   const ref = useRef(null);
   if (ref.current === null) {
     ref.current = {
@@ -2145,10 +2214,16 @@ function useAnimatableSharedValues(init2) {
       width,
       height,
       borderRadius,
+      shadowOpacity,
+      shadowRadius,
+      elevation,
       backgroundColor,
       borderColor,
       color,
-      tintColor
+      tintColor,
+      shadowColor,
+      shadowOffsetWidth,
+      shadowOffsetHeight
     };
   }
   return ref.current;
@@ -2216,6 +2291,22 @@ function makeKeyCallbackFactory(key, sharedValue, target, onAnimationEndRef, met
     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;
@@ -2285,6 +2376,13 @@ function resolveGestureLayers(gesture) {
     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);
@@ -2564,6 +2662,6 @@ function useVariants(variants, initial) {
   }, []);
 }
 
-export { Motion, MotionConfig, MotionImage, MotionPressable, MotionScrollView, MotionText, MotionView, Presence, createMotionComponent, ensureWorkletEasing, resolveAnimatableValue, resolveTransition, useAnimation, useGesture, useMotionConfig, useMotionValue, usePresence, useScroll, useShouldReduceMotion, useSpring, useTransform, useVariants };
+export { Motion, MotionConfig, MotionImage, MotionPressable, MotionScrollView, MotionText, MotionView, Presence, buildReleaseAnimation, createMotionComponent, ensureWorkletEasing, resolveAnimatableValue, resolveTransition, useAnimation, useGesture, useMotionConfig, useMotionValue, usePresence, useScroll, useShouldReduceMotion, useSpring, useTransform, useVariants };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map