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

package/dist/motion/Image.d.mts

@@ -1,5 +1,5 @@
 import { Image } from 'react-native';
-import { M as MotionComponent } from '../types-CjztO3RW.mjs';
+import { M as MotionComponent } from '../types-NmNeJjo1.mjs';
 import 'react';
 
 /**

package/dist/motion/Image.d.ts

@@ -1,5 +1,5 @@
 import { Image } from 'react-native';
-import { M as MotionComponent } from '../types-CjztO3RW.js';
+import { M as MotionComponent } from '../types-NmNeJjo1.js';
 import 'react';
 
 /**

package/dist/motion/Image.js

@@ -1451,13 +1451,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 = {
@@ -1466,6 +1470,7 @@ var DEFAULT_SPRING = {
   mass: 1
 };
 function springToReanimated(t) {
+  "worklet";
   return {
     stiffness: t.tension ?? DEFAULT_SPRING.tension,
     damping: t.friction ?? DEFAULT_SPRING.friction,
@@ -1700,21 +1705,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",
@@ -1736,6 +1748,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
@@ -1743,7 +1758,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;
@@ -1797,16 +1815,12 @@ function createMotionComponent(Component) {
     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);
-      }
+      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) {
@@ -1817,22 +1831,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 = react.useRef(
       activeKeysRef.current.some((k) => TRANSFORM_KEY_SET.has(k))
     );
+    const hasShadowOffsetRef = react.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];
@@ -1878,9 +1899,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,
@@ -1943,8 +1970,11 @@ function createMotionComponent(Component) {
     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;
@@ -1977,11 +2007,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 = react.useMemo(
@@ -2029,12 +2066,22 @@ function useAnimatableSharedValues(init2) {
   const width = Animated.useSharedValue(init2("width"));
   const height = Animated.useSharedValue(init2("height"));
   const borderRadius = Animated.useSharedValue(init2("borderRadius"));
+  const shadowOpacity = Animated.useSharedValue(init2("shadowOpacity"));
+  const shadowRadius = Animated.useSharedValue(init2("shadowRadius"));
+  const elevation = Animated.useSharedValue(init2("elevation"));
   const backgroundColor = Animated.useSharedValue(
     init2("backgroundColor")
   );
   const borderColor = Animated.useSharedValue(init2("borderColor"));
   const color = Animated.useSharedValue(init2("color"));
   const tintColor = Animated.useSharedValue(init2("tintColor"));
+  const shadowColor = Animated.useSharedValue(init2("shadowColor"));
+  const shadowOffsetWidth = Animated.useSharedValue(
+    init2("shadowOffsetWidth")
+  );
+  const shadowOffsetHeight = Animated.useSharedValue(
+    init2("shadowOffsetHeight")
+  );
   const ref = react.useRef(null);
   if (ref.current === null) {
     ref.current = {
@@ -2050,10 +2097,16 @@ function useAnimatableSharedValues(init2) {
       width,
       height,
       borderRadius,
+      shadowOpacity,
+      shadowRadius,
+      elevation,
       backgroundColor,
       borderColor,
       color,
-      tintColor
+      tintColor,
+      shadowColor,
+      shadowOffsetWidth,
+      shadowOffsetHeight
     };
   }
   return ref.current;
@@ -2121,6 +2174,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;
@@ -2190,6 +2259,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);