react-native-ease 0.3.0 → 0.4.0

package/android/src/main/java/com/ease/EaseViewManager.kt

@@ -3,6 +3,7 @@ package com.ease
 import android.graphics.Color
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.uimanager.PixelUtil
@@ -126,56 +127,11 @@ class EaseViewManager : ReactViewManager() {
         view.initialAnimateBorderRadius = PixelUtil.toPixelFromDIP(value)
     }
 
-    // --- Transition config setters ---
+    // --- Transitions config (single ReadableMap) ---
 
-    @ReactProp(name = "transitionType")
-    fun setTransitionType(view: EaseView, value: String?) {
-        view.transitionType = value ?: "timing"
-    }
-
-    @ReactProp(name = "transitionDuration", defaultInt = 300)
-    fun setTransitionDuration(view: EaseView, value: Int) {
-        view.transitionDuration = value
-    }
-
-    @ReactProp(name = "transitionEasingBezier")
-    fun setTransitionEasingBezier(view: EaseView, value: ReadableArray?) {
-        if (value != null && value.size() == 4) {
-            view.transitionEasingBezier = floatArrayOf(
-                value.getDouble(0).toFloat(),
-                value.getDouble(1).toFloat(),
-                value.getDouble(2).toFloat(),
-                value.getDouble(3).toFloat()
-            )
-        } else {
-            // Fallback: easeInOut
-            view.transitionEasingBezier = floatArrayOf(0.42f, 0f, 0.58f, 1.0f)
-        }
-    }
-
-    @ReactProp(name = "transitionDamping", defaultFloat = 15f)
-    fun setTransitionDamping(view: EaseView, value: Float) {
-        view.transitionDamping = value
-    }
-
-    @ReactProp(name = "transitionStiffness", defaultFloat = 120f)
-    fun setTransitionStiffness(view: EaseView, value: Float) {
-        view.transitionStiffness = value
-    }
-
-    @ReactProp(name = "transitionMass", defaultFloat = 1f)
-    fun setTransitionMass(view: EaseView, value: Float) {
-        view.transitionMass = value
-    }
-
-    @ReactProp(name = "transitionLoop")
-    fun setTransitionLoop(view: EaseView, value: String?) {
-        view.transitionLoop = value ?: "none"
-    }
-
-    @ReactProp(name = "transitionDelay", defaultInt = 0)
-    fun setTransitionDelay(view: EaseView, value: Int) {
-        view.transitionDelay = value.toLong()
+    @ReactProp(name = "transitions")
+    fun setTransitions(view: EaseView, value: ReadableMap?) {
+        view.setTransitionsFromMap(value)
     }
 
     // --- Border radius ---

package/ios/EaseView.mm

@@ -58,6 +58,92 @@ static const int kMaskAnyTransform = kMaskTranslateX | kMaskTranslateY |
                                      kMaskScaleX | kMaskScaleY | kMaskRotate |
                                      kMaskRotateX | kMaskRotateY;
 
+// Per-property transition config resolved from the transitions struct
+struct EaseTransitionConfig {
+  std::string type;
+  int duration;
+  float bezier[4];
+  float damping;
+  float stiffness;
+  float mass;
+  std::string loop;
+  int delay;
+};
+
+// Convert from a codegen-generated transition config struct to our local
+// EaseTransitionConfig
+template <typename T>
+static EaseTransitionConfig transitionConfigFromStruct(const T &src) {
+  EaseTransitionConfig config;
+  config.type = src.type;
+  config.duration = src.duration;
+  const auto &b = src.easingBezier;
+  if (b.size() == 4) {
+    config.bezier[0] = b[0];
+    config.bezier[1] = b[1];
+    config.bezier[2] = b[2];
+    config.bezier[3] = b[3];
+  } else {
+    config.bezier[0] = 0.42f;
+    config.bezier[1] = 0.0f;
+    config.bezier[2] = 0.58f;
+    config.bezier[3] = 1.0f;
+  }
+  config.damping = src.damping;
+  config.stiffness = src.stiffness;
+  config.mass = src.mass;
+  config.loop = src.loop;
+  config.delay = src.delay;
+  return config;
+}
+
+// Check if a category config was explicitly set (non-empty type means JS sent
+// it)
+template <typename T> static bool hasConfig(const T &cfg) {
+  return !cfg.type.empty();
+}
+
+static EaseTransitionConfig
+transitionConfigForProperty(const std::string &name,
+                            const EaseViewProps &props) {
+  const auto &t = props.transitions;
+
+  // Map property name to category, check if category override exists
+  if (name == "opacity" && hasConfig(t.opacity)) {
+    return transitionConfigFromStruct(t.opacity);
+  } else if ((name == "translateX" || name == "translateY" ||
+              name == "scaleX" || name == "scaleY" || name == "rotate" ||
+              name == "rotateX" || name == "rotateY") &&
+             hasConfig(t.transform)) {
+    return transitionConfigFromStruct(t.transform);
+  } else if (name == "borderRadius" && hasConfig(t.borderRadius)) {
+    return transitionConfigFromStruct(t.borderRadius);
+  } else if (name == "backgroundColor" && hasConfig(t.backgroundColor)) {
+    return transitionConfigFromStruct(t.backgroundColor);
+  }
+  // Fallback to defaultConfig
+  return transitionConfigFromStruct(t.defaultConfig);
+}
+
+// Find lowest property name with a set mask bit among transform properties
+static std::string lowestTransformPropertyName(int mask) {
+  if (mask & kMaskTranslateX)
+    return "translateX";
+  if (mask & kMaskTranslateY)
+    return "translateY";
+  if (mask & kMaskScaleX)
+    return "scaleX";
+  if (mask & kMaskScaleY)
+    return "scaleY";
+  if (mask & kMaskRotate)
+    return "rotate";
+  if (mask & kMaskRotateX)
+    return "rotateX";
+  if (mask & kMaskRotateY)
+    return "rotateY";
+  return "translateX"; // fallback
+}
+
 @implementation EaseView {
   BOOL _isFirstMount;
   NSInteger _animationBatchId;
@@ -139,16 +225,16 @@ static const int kMaskAnyTransform = kMaskTranslateX | kMaskTranslateY |
 - (CAAnimation *)createAnimationForKeyPath:(NSString *)keyPath
                                  fromValue:(NSValue *)fromValue
                                    toValue:(NSValue *)toValue
-                                     props:(const EaseViewProps &)props
+                                    config:(EaseTransitionConfig)config
                                       loop:(BOOL)loop {
-  if (props.transitionType == EaseViewTransitionType::Spring) {
+  if (config.type == "spring") {
     CASpringAnimation *spring =
         [CASpringAnimation animationWithKeyPath:keyPath];
     spring.fromValue = fromValue;
     spring.toValue = toValue;
-    spring.damping = props.transitionDamping;
-    spring.stiffness = props.transitionStiffness;
-    spring.mass = props.transitionMass;
+    spring.damping = config.damping;
+    spring.stiffness = config.stiffness;
+    spring.mass = config.mass;
     spring.initialVelocity = 0;
     spring.duration = spring.settlingDuration;
     return spring;
@@ -156,23 +242,14 @@ static const int kMaskAnyTransform = kMaskTranslateX | kMaskTranslateY |
     CABasicAnimation *timing = [CABasicAnimation animationWithKeyPath:keyPath];
     timing.fromValue = fromValue;
     timing.toValue = toValue;
-    timing.duration = props.transitionDuration / 1000.0;
-    {
-      const auto &b = props.transitionEasingBezier;
-      if (b.size() == 4) {
-        timing.timingFunction = [CAMediaTimingFunction
-            functionWithControlPoints:(float)b[0]:(float)b[1]:(float)b[2
-        ]:(float)b[3]];
-      } else {
-        // Fallback: easeInOut
-        timing.timingFunction =
-            [CAMediaTimingFunction functionWithControlPoints:0.42:0.0:0.58:1.0];
-      }
-    }
+    timing.duration = config.duration / 1000.0;
+    timing.timingFunction = [CAMediaTimingFunction
+        functionWithControlPoints:config.bezier[0]:config.bezier[1
+    ]:config.bezier[2]:config.bezier[3]];
     if (loop) {
-      if (props.transitionLoop == EaseViewTransitionLoop::Repeat) {
+      if (config.loop == "repeat") {
         timing.repeatCount = HUGE_VALF;
-      } else if (props.transitionLoop == EaseViewTransitionLoop::Reverse) {
+      } else if (config.loop == "reverse") {
         timing.repeatCount = HUGE_VALF;
         timing.autoreverses = YES;
       }
@@ -185,18 +262,17 @@ static const int kMaskAnyTransform = kMaskTranslateX | kMaskTranslateY |
                     animationKey:(NSString *)animationKey
                        fromValue:(NSValue *)fromValue
                          toValue:(NSValue *)toValue
-                           props:(const EaseViewProps &)props
+                          config:(EaseTransitionConfig)config
                             loop:(BOOL)loop {
   _pendingAnimationCount++;
 
   CAAnimation *animation = [self createAnimationForKeyPath:keyPath
                                                  fromValue:fromValue
                                                    toValue:toValue
-                                                     props:props
+                                                    config:config
                                                       loop:loop];
-  if (props.transitionDelay > 0) {
-    animation.beginTime =
-        CACurrentMediaTime() + (props.transitionDelay / 1000.0);
+  if (config.delay > 0) {
+    animation.beginTime = CACurrentMediaTime() + (config.delay / 1000.0);
     animation.fillMode = kCAFillModeBackwards;
   }
   [animation setValue:@(_animationBatchId) forKey:@"easeBatchId"];
@@ -229,6 +305,10 @@ static const int kMaskAnyTransform = kMaskTranslateX | kMaskTranslateY |
   const auto &newViewProps =
       *std::static_pointer_cast<const EaseViewProps>(props);
 
+  // oldProps can be null. Fall back to props so the diff is a no-op.
+  const auto &oldViewProps = *std::static_pointer_cast<const EaseViewProps>(
+      oldProps ? oldProps : props);
+
   [super updateProps:props oldProps:oldProps];
 
   [CATransaction begin];
@@ -303,40 +383,77 @@ static const int kMaskAnyTransform = kMaskTranslateX | kMaskTranslateY |
                 newViewProps.initialAnimateBackgroundColor)
                 .CGColor;
 
-      // Animate from initial to target
+      // Animate from initial to target (skip if config is 'none')
       if (hasInitialOpacity) {
+        EaseTransitionConfig opacityConfig =
+            transitionConfigForProperty("opacity", newViewProps);
         self.layer.opacity = newViewProps.animateOpacity;
-        [self applyAnimationForKeyPath:@"opacity"
-                          animationKey:kAnimKeyOpacity
-                             fromValue:@(newViewProps.initialAnimateOpacity)
-                               toValue:@(newViewProps.animateOpacity)
-                                 props:newViewProps
-                                  loop:YES];
+        if (opacityConfig.type != "none") {
+          [self applyAnimationForKeyPath:@"opacity"
+                            animationKey:kAnimKeyOpacity
+                               fromValue:@(newViewProps.initialAnimateOpacity)
+                                 toValue:@(newViewProps.animateOpacity)
+                                  config:opacityConfig
+                                    loop:YES];
+        }
       }
       if (hasInitialTransform) {
+        // Build mask of which transform sub-properties actually changed
+        int changedInitTransform = 0;
+        if (newViewProps.initialAnimateTranslateX !=
+            newViewProps.animateTranslateX)
+          changedInitTransform |= kMaskTranslateX;
+        if (newViewProps.initialAnimateTranslateY !=
+            newViewProps.animateTranslateY)
+          changedInitTransform |= kMaskTranslateY;
+        if (newViewProps.initialAnimateScaleX != newViewProps.animateScaleX)
+          changedInitTransform |= kMaskScaleX;
+        if (newViewProps.initialAnimateScaleY != newViewProps.animateScaleY)
+          changedInitTransform |= kMaskScaleY;
+        if (newViewProps.initialAnimateRotate != newViewProps.animateRotate)
+          changedInitTransform |= kMaskRotate;
+        if (newViewProps.initialAnimateRotateX != newViewProps.animateRotateX)
+          changedInitTransform |= kMaskRotateX;
+        if (newViewProps.initialAnimateRotateY != newViewProps.animateRotateY)
+          changedInitTransform |= kMaskRotateY;
+        std::string transformName =
+            lowestTransformPropertyName(changedInitTransform);
+        EaseTransitionConfig transformConfig =
+            transitionConfigForProperty(transformName, newViewProps);
         self.layer.transform = targetT;
-        [self applyAnimationForKeyPath:@"transform"
+        if (transformConfig.type != "none") {
+          [self
+              applyAnimationForKeyPath:@"transform"
                           animationKey:kAnimKeyTransform
                              fromValue:[NSValue valueWithCATransform3D:initialT]
                                toValue:[NSValue valueWithCATransform3D:targetT]
-                                 props:newViewProps
+                                config:transformConfig
                                   loop:YES];
+        }
       }
       if (hasInitialBorderRadius) {
+        EaseTransitionConfig brConfig =
+            transitionConfigForProperty("borderRadius", newViewProps);
         self.layer.cornerRadius = newViewProps.animateBorderRadius;
-        [self
-            applyAnimationForKeyPath:@"cornerRadius"
-                        animationKey:kAnimKeyCornerRadius
-                           fromValue:@(newViewProps.initialAnimateBorderRadius)
-                             toValue:@(newViewProps.animateBorderRadius)
-                               props:newViewProps
-                                loop:YES];
+        if (brConfig.type != "none") {
+          [self applyAnimationForKeyPath:@"cornerRadius"
+                            animationKey:kAnimKeyCornerRadius
+                               fromValue:@(newViewProps
+                                               .initialAnimateBorderRadius)
+                                 toValue:@(newViewProps.animateBorderRadius)
+                                  config:brConfig
+                                    loop:YES];
+        }
       }
       if (hasInitialBackgroundColor) {
+        EaseTransitionConfig bgConfig =
+            transitionConfigForProperty("backgroundColor", newViewProps);
         self.layer.backgroundColor =
             RCTUIColorFromSharedColor(newViewProps.animateBackgroundColor)
                 .CGColor;
-        [self applyAnimationForKeyPath:@"backgroundColor"
+        if (bgConfig.type != "none") {
+          [self
+              applyAnimationForKeyPath:@"backgroundColor"
                           animationKey:kAnimKeyBackgroundColor
                              fromValue:(__bridge id)RCTUIColorFromSharedColor(
                                            newViewProps
@@ -345,8 +462,19 @@ static const int kMaskAnyTransform = kMaskTranslateX | kMaskTranslateY |
                                toValue:(__bridge id)RCTUIColorFromSharedColor(
                                            newViewProps.animateBackgroundColor)
                                            .CGColor
-                                 props:newViewProps
+                                config:bgConfig
                                   loop:YES];
+        }
+      }
+
+      // If all per-property configs were 'none', no animations were queued.
+      // Fire onTransitionEnd immediately to match the scalar 'none' contract.
+      if (_pendingAnimationCount == 0 && _eventEmitter) {
+        auto emitter =
+            std::static_pointer_cast<const EaseViewEventEmitter>(_eventEmitter);
+        emitter->onTransitionEnd(EaseViewEventEmitter::OnTransitionEnd{
+            .finished = true,
+        });
       }
     } else {
       // No initial animation — set target values directly
@@ -363,8 +491,16 @@ static const int kMaskAnyTransform = kMaskTranslateX | kMaskTranslateY |
             RCTUIColorFromSharedColor(newViewProps.animateBackgroundColor)
                 .CGColor;
     }
-  } else if (newViewProps.transitionType == EaseViewTransitionType::None) {
-    // No transition — set values immediately
+  } else if (newViewProps.transitions.defaultConfig.type == "none" &&
+             (!hasConfig(newViewProps.transitions.transform) ||
+              newViewProps.transitions.transform.type == "none") &&
+             (!hasConfig(newViewProps.transitions.opacity) ||
+              newViewProps.transitions.opacity.type == "none") &&
+             (!hasConfig(newViewProps.transitions.borderRadius) ||
+              newViewProps.transitions.borderRadius.type == "none") &&
+             (!hasConfig(newViewProps.transitions.backgroundColor) ||
+              newViewProps.transitions.backgroundColor.type == "none")) {
+    // All transitions are 'none' — set values immediately
     [self.layer removeAllAnimations];
     if (mask & kMaskOpacity)
       self.layer.opacity = newViewProps.animateOpacity;
@@ -387,19 +523,27 @@ static const int kMaskAnyTransform = kMaskTranslateX | kMaskTranslateY |
     }
   } else {
     // Subsequent updates: animate changed properties
-    const auto &oldViewProps =
-        *std::static_pointer_cast<const EaseViewProps>(oldProps);
+    BOOL anyPropertyChanged = NO;
 
     if ((mask & kMaskOpacity) &&
         oldViewProps.animateOpacity != newViewProps.animateOpacity) {
-      self.layer.opacity = newViewProps.animateOpacity;
-      [self
-          applyAnimationForKeyPath:@"opacity"
-                      animationKey:kAnimKeyOpacity
-                         fromValue:[self presentationValueForKeyPath:@"opacity"]
-                           toValue:@(newViewProps.animateOpacity)
-                             props:newViewProps
-                              loop:NO];
+      anyPropertyChanged = YES;
+      EaseTransitionConfig opacityConfig =
+          transitionConfigForProperty("opacity", newViewProps);
+      if (opacityConfig.type == "none") {
+        self.layer.opacity = newViewProps.animateOpacity;
+        [self.layer removeAnimationForKey:kAnimKeyOpacity];
+      } else {
+        self.layer.opacity = newViewProps.animateOpacity;
+        [self
+            applyAnimationForKeyPath:@"opacity"
+                        animationKey:kAnimKeyOpacity
+                           fromValue:[self
+                                         presentationValueForKeyPath:@"opacity"]
+                             toValue:@(newViewProps.animateOpacity)
+                              config:opacityConfig
+                                loop:NO];
+      }
     }
 
     // Check if ANY transform-related property changed
@@ -414,46 +558,98 @@ static const int kMaskAnyTransform = kMaskTranslateX | kMaskTranslateY |
           oldViewProps.animateRotateY != newViewProps.animateRotateY;
 
       if (anyTransformChanged) {
-        CATransform3D fromT = [self presentationTransform];
-        CATransform3D toT = [self targetTransformFromProps:newViewProps];
-        self.layer.transform = toT;
-        [self applyAnimationForKeyPath:@"transform"
-                          animationKey:kAnimKeyTransform
-                             fromValue:[NSValue valueWithCATransform3D:fromT]
-                               toValue:[NSValue valueWithCATransform3D:toT]
-                                 props:newViewProps
-                                  loop:NO];
+        anyPropertyChanged = YES;
+        // Determine which transform sub-properties changed for config selection
+        int changedTransformMask = 0;
+        if (oldViewProps.animateTranslateX != newViewProps.animateTranslateX)
+          changedTransformMask |= kMaskTranslateX;
+        if (oldViewProps.animateTranslateY != newViewProps.animateTranslateY)
+          changedTransformMask |= kMaskTranslateY;
+        if (oldViewProps.animateScaleX != newViewProps.animateScaleX)
+          changedTransformMask |= kMaskScaleX;
+        if (oldViewProps.animateScaleY != newViewProps.animateScaleY)
+          changedTransformMask |= kMaskScaleY;
+        if (oldViewProps.animateRotate != newViewProps.animateRotate)
+          changedTransformMask |= kMaskRotate;
+        if (oldViewProps.animateRotateX != newViewProps.animateRotateX)
+          changedTransformMask |= kMaskRotateX;
+        if (oldViewProps.animateRotateY != newViewProps.animateRotateY)
+          changedTransformMask |= kMaskRotateY;
+
+        std::string transformName =
+            lowestTransformPropertyName(changedTransformMask);
+        EaseTransitionConfig transformConfig =
+            transitionConfigForProperty(transformName, newViewProps);
+
+        if (transformConfig.type == "none") {
+          self.layer.transform = [self targetTransformFromProps:newViewProps];
+          [self.layer removeAnimationForKey:kAnimKeyTransform];
+        } else {
+          CATransform3D fromT = [self presentationTransform];
+          CATransform3D toT = [self targetTransformFromProps:newViewProps];
+          self.layer.transform = toT;
+          [self applyAnimationForKeyPath:@"transform"
+                            animationKey:kAnimKeyTransform
+                               fromValue:[NSValue valueWithCATransform3D:fromT]
+                                 toValue:[NSValue valueWithCATransform3D:toT]
+                                  config:transformConfig
+                                    loop:NO];
+        }
       }
     }
 
     if ((mask & kMaskBorderRadius) &&
         oldViewProps.animateBorderRadius != newViewProps.animateBorderRadius) {
+      anyPropertyChanged = YES;
+      EaseTransitionConfig brConfig =
+          transitionConfigForProperty("borderRadius", newViewProps);
       self.layer.cornerRadius = newViewProps.animateBorderRadius;
       self.layer.masksToBounds = newViewProps.animateBorderRadius > 0;
-      [self applyAnimationForKeyPath:@"cornerRadius"
-                        animationKey:kAnimKeyCornerRadius
-                           fromValue:[self presentationValueForKeyPath:
-                                               @"cornerRadius"]
-                             toValue:@(newViewProps.animateBorderRadius)
-                               props:newViewProps
-                                loop:NO];
+      if (brConfig.type == "none") {
+        [self.layer removeAnimationForKey:kAnimKeyCornerRadius];
+      } else {
+        [self applyAnimationForKeyPath:@"cornerRadius"
+                          animationKey:kAnimKeyCornerRadius
+                             fromValue:[self presentationValueForKeyPath:
+                                                 @"cornerRadius"]
+                               toValue:@(newViewProps.animateBorderRadius)
+                                config:brConfig
+                                  loop:NO];
+      }
     }
 
     if ((mask & kMaskBackgroundColor) &&
         oldViewProps.animateBackgroundColor !=
             newViewProps.animateBackgroundColor) {
-      CGColorRef fromColor = (__bridge CGColorRef)
-          [self presentationValueForKeyPath:@"backgroundColor"];
+      anyPropertyChanged = YES;
+      EaseTransitionConfig bgConfig =
+          transitionConfigForProperty("backgroundColor", newViewProps);
       CGColorRef toColor =
           RCTUIColorFromSharedColor(newViewProps.animateBackgroundColor)
               .CGColor;
       self.layer.backgroundColor = toColor;
-      [self applyAnimationForKeyPath:@"backgroundColor"
-                        animationKey:kAnimKeyBackgroundColor
-                           fromValue:(__bridge id)fromColor
-                             toValue:(__bridge id)toColor
-                               props:newViewProps
-                                loop:NO];
+      if (bgConfig.type == "none") {
+        [self.layer removeAnimationForKey:kAnimKeyBackgroundColor];
+      } else {
+        CGColorRef fromColor = (__bridge CGColorRef)
+            [self presentationValueForKeyPath:@"backgroundColor"];
+        [self applyAnimationForKeyPath:@"backgroundColor"
+                          animationKey:kAnimKeyBackgroundColor
+                             fromValue:(__bridge id)fromColor
+                               toValue:(__bridge id)toColor
+                                config:bgConfig
+                                  loop:NO];
+      }
+    }
+
+    // If all changed properties resolved to 'none', no animations were queued.
+    // Fire onTransitionEnd immediately.
+    if (anyPropertyChanged && _pendingAnimationCount == 0 && _eventEmitter) {
+      auto emitter =
+          std::static_pointer_cast<const EaseViewEventEmitter>(_eventEmitter);
+      emitter->onTransitionEnd(EaseViewEventEmitter::OnTransitionEnd{
+          .finished = true,
+      });
     }
   }
 

package/lib/module/EaseView.js

@@ -52,6 +52,88 @@ const EASING_PRESETS = {
   easeOut: [0, 0, 0.58, 1],
   easeInOut: [0.42, 0, 0.58, 1]
 };
+
+/** Returns true if the transition is a SingleTransition (has a `type` field). */
+function isSingleTransition(t) {
+  return 'type' in t;
+}
+/** Default config: timing 300ms easeInOut. */
+const DEFAULT_CONFIG = {
+  type: 'timing',
+  duration: 300,
+  easingBezier: [0.42, 0, 0.58, 1],
+  damping: 15,
+  stiffness: 120,
+  mass: 1,
+  loop: 'none',
+  delay: 0
+};
+
+/** Resolve a SingleTransition into a native config object. */
+function resolveSingleConfig(config) {
+  const type = config.type;
+  const duration = config.type === 'timing' ? config.duration ?? 300 : 300;
+  const rawEasing = config.type === 'timing' ? config.easing ?? 'easeInOut' : 'easeInOut';
+  if (__DEV__) {
+    if (Array.isArray(rawEasing)) {
+      if (rawEasing.length !== 4) {
+        console.warn('react-native-ease: Custom easing must be a [x1, y1, x2, y2] tuple (got length ' + rawEasing.length + ').');
+      }
+      if (rawEasing[0] < 0 || rawEasing[0] > 1 || rawEasing[2] < 0 || rawEasing[2] > 1) {
+        console.warn('react-native-ease: Easing x-values (x1, x2) must be between 0 and 1.');
+      }
+    }
+  }
+  const easingBezier = Array.isArray(rawEasing) ? rawEasing : EASING_PRESETS[rawEasing];
+  const damping = config.type === 'spring' ? config.damping ?? 15 : 15;
+  const stiffness = config.type === 'spring' ? config.stiffness ?? 120 : 120;
+  const mass = config.type === 'spring' ? config.mass ?? 1 : 1;
+  const loop = config.type === 'timing' ? config.loop ?? 'none' : 'none';
+  const delay = config.type === 'timing' || config.type === 'spring' ? config.delay ?? 0 : 0;
+  return {
+    type,
+    duration,
+    easingBezier,
+    damping,
+    stiffness,
+    mass,
+    loop,
+    delay
+  };
+}
+
+/** Category keys that map to optional NativeTransitions fields. */
+const CATEGORY_KEYS = ['transform', 'opacity', 'borderRadius', 'backgroundColor'];
+
+/** Resolve the transition prop into a NativeTransitions struct. */
+function resolveTransitions(transition) {
+  // No transition: timing default for all properties
+  if (transition == null) {
+    return {
+      defaultConfig: DEFAULT_CONFIG
+    };
+  }
+
+  // Single transition: set as defaultConfig only
+  if (isSingleTransition(transition)) {
+    return {
+      defaultConfig: resolveSingleConfig(transition)
+    };
+  }
+
+  // TransitionMap: resolve defaultConfig + only specified category keys
+  const defaultConfig = transition.default ? resolveSingleConfig(transition.default) : DEFAULT_CONFIG;
+  const result = {
+    defaultConfig
+  };
+  for (const key of CATEGORY_KEYS) {
+    const specific = transition[key];
+    if (specific != null) {
+      result[key] = resolveSingleConfig(specific);
+    }
+  }
+  return result;
+}
 export function EaseView({
   animate,
   initialAnimate,
@@ -135,26 +217,8 @@ export function EaseView({
     }
   }
 
-  // Resolve transition config
-  const transitionType = transition?.type ?? 'timing';
-  const transitionDuration = transition?.type === 'timing' ? transition.duration ?? 300 : 300;
-  const rawEasing = transition?.type === 'timing' ? transition.easing ?? 'easeInOut' : 'easeInOut';
-  if (__DEV__) {
-    if (Array.isArray(rawEasing)) {
-      if (rawEasing.length !== 4) {
-        console.warn('react-native-ease: Custom easing must be a [x1, y1, x2, y2] tuple (got length ' + rawEasing.length + ').');
-      }
-      if (rawEasing[0] < 0 || rawEasing[0] > 1 || rawEasing[2] < 0 || rawEasing[2] > 1) {
-        console.warn('react-native-ease: Easing x-values (x1, x2) must be between 0 and 1.');
-      }
-    }
-  }
-  const bezier = Array.isArray(rawEasing) ? rawEasing : EASING_PRESETS[rawEasing];
-  const transitionDamping = transition?.type === 'spring' ? transition.damping ?? 15 : 15;
-  const transitionStiffness = transition?.type === 'spring' ? transition.stiffness ?? 120 : 120;
-  const transitionMass = transition?.type === 'spring' ? transition.mass ?? 1 : 1;
-  const transitionLoop = transition?.type === 'timing' ? transition.loop ?? 'none' : 'none';
-  const transitionDelay = transition?.type === 'timing' || transition?.type === 'spring' ? transition.delay ?? 0 : 0;
+  // Resolve transition config into a fully-populated struct
+  const transitions = resolveTransitions(transition);
   const handleTransitionEnd = onTransitionEnd ? event => onTransitionEnd(event.nativeEvent) : undefined;
   return /*#__PURE__*/_jsx(NativeEaseView, {
     style: cleanStyle,
@@ -180,14 +244,7 @@ export function EaseView({
     initialAnimateRotateY: resolvedInitial.rotateY,
     initialAnimateBorderRadius: resolvedInitial.borderRadius,
     initialAnimateBackgroundColor: initialBgColor,
-    transitionType: transitionType,
-    transitionDuration: transitionDuration,
-    transitionEasingBezier: bezier,
-    transitionDamping: transitionDamping,
-    transitionStiffness: transitionStiffness,
-    transitionMass: transitionMass,
-    transitionLoop: transitionLoop,
-    transitionDelay: transitionDelay,
+    transitions: transitions,
     useHardwareLayer: useHardwareLayer,
     transformOriginX: transformOrigin?.x ?? 0.5,
     transformOriginY: transformOrigin?.y ?? 0.5,