react-native-smooth-clip-view 0.3.0 → 0.4.1

package/ios/SmoothClipTurboModule.cpp

@@ -10,6 +10,10 @@
 namespace facebook::react {
 namespace {
 
+constexpr size_t kPresentationStride = 21;
+constexpr size_t kSnapshotStride = kPresentationStride + 1;
+constexpr size_t kMotionEntryStride = kPresentationStride * 2 + 2;
+
 constexpr double kMaxSafeJavaScriptInteger = 9007199254740991.0;
 
 bool validDriverId(double value) {
@@ -23,24 +27,11 @@ bool finiteGeometry(const smoothclip::Geometry &geometry) {
       std::isfinite(geometry.radius);
 }
 
-bool finitePresentation(const smoothclip::Presentation &presentation) {
-  return finiteGeometry(presentation.clip) &&
-      std::isfinite(presentation.contentTranslateX) &&
-      std::isfinite(presentation.contentTranslateY);
-}
-
 bool validCurveCode(int32_t curveCode) {
   return curveCode == static_cast<int32_t>(smoothclip::ClipCurve::Circular) ||
       curveCode == static_cast<int32_t>(smoothclip::ClipCurve::Continuous);
 }
 
-bool validSuspensionPolicy(int32_t value) {
-  return value == static_cast<int32_t>(
-                      smoothclip::GroupSuspensionPolicy::Pause) ||
-      value == static_cast<int32_t>(
-                   smoothclip::GroupSuspensionPolicy::Finish);
-}
-
 bool numberAt(
     jsi::Runtime &runtime,
     const jsi::Array &array,
@@ -53,7 +44,7 @@ bool numberAt(
   return std::isfinite(result);
 }
 
-smoothclip::Presentation presentationV2(
+smoothclip::Presentation makePresentation(
     double x,
     double y,
     double width,
@@ -65,7 +56,16 @@ smoothclip::Presentation presentationV2(
     int32_t curveCode,
     double contentTranslateX,
     double contentTranslateY,
-    double contentScale) {
+    double contentScale,
+    bool shadowEnabled = false,
+    double shadowRed = 0,
+    double shadowGreen = 0,
+    double shadowBlue = 0,
+    double shadowAlpha = 1,
+    double shadowOffsetX = 0,
+    double shadowOffsetY = 0,
+    double shadowBlurRadius = 0,
+    double shadowSpreadDistance = 0) {
   const bool uniform = topLeftRadius == topRightRadius &&
       topLeftRadius == bottomRightRadius &&
       topLeftRadius == bottomLeftRadius;
@@ -76,10 +76,16 @@ smoothclip::Presentation presentationV2(
   geometry.bottomRightRadius = bottomRightRadius;
   geometry.bottomLeftRadius = bottomLeftRadius;
   geometry.curve = static_cast<smoothclip::ClipCurve>(curveCode);
-  return {geometry, contentTranslateX, contentTranslateY, contentScale};
+  return {
+      geometry,
+      contentTranslateX,
+      contentTranslateY,
+      contentScale,
+      {shadowEnabled, shadowRed, shadowGreen, shadowBlue, shadowAlpha,
+       shadowOffsetX, shadowOffsetY, shadowBlurRadius, shadowSpreadDistance}};
 }
 
-bool finitePresentationV2(const smoothclip::Presentation &presentation) {
+bool finitePresentation(const smoothclip::Presentation &presentation) {
   const smoothclip::Geometry &geometry = presentation.clip;
   return finiteGeometry(geometry) &&
       std::isfinite(geometry.topLeftRadius) &&
@@ -90,23 +96,37 @@ bool finitePresentationV2(const smoothclip::Presentation &presentation) {
       std::isfinite(presentation.contentTranslateX) &&
       std::isfinite(presentation.contentTranslateY) &&
       std::isfinite(presentation.contentScale) &&
-      presentation.contentScale > 0;
-}
-
-bool presentationV2At(
+      presentation.contentScale > 0 &&
+      std::isfinite(presentation.shadow.red) &&
+      std::isfinite(presentation.shadow.green) &&
+      std::isfinite(presentation.shadow.blue) &&
+      std::isfinite(presentation.shadow.alpha) &&
+      std::isfinite(presentation.shadow.offsetX) &&
+      std::isfinite(presentation.shadow.offsetY) &&
+      std::isfinite(presentation.shadow.blurRadius) &&
+      std::isfinite(presentation.shadow.spreadDistance) &&
+      presentation.shadow.red >= 0 && presentation.shadow.red <= 1 &&
+      presentation.shadow.green >= 0 && presentation.shadow.green <= 1 &&
+      presentation.shadow.blue >= 0 && presentation.shadow.blue <= 1 &&
+      presentation.shadow.alpha >= 0 && presentation.shadow.alpha <= 1 &&
+      presentation.shadow.blurRadius >= 0;
+}
+
+bool presentationAt(
     jsi::Runtime &runtime,
     const jsi::Array &array,
     size_t offset,
     smoothclip::Presentation &result) {
-  double values[12];
-  for (size_t index = 0; index < 12; index += 1) {
+  double values[kPresentationStride];
+  for (size_t index = 0; index < kPresentationStride; index += 1) {
     if (!numberAt(runtime, array, offset + index, values[index])) {
       return false;
     }
   }
   const int32_t curveCode = static_cast<int32_t>(values[8]);
-  if (values[8] != curveCode || !validCurveCode(curveCode)) return false;
-  result = presentationV2(
+  if (values[8] != curveCode || !validCurveCode(curveCode) ||
+      (values[12] != 0 && values[12] != 1)) return false;
+  result = makePresentation(
       values[0],
       values[1],
       values[2],
@@ -118,11 +138,14 @@ bool presentationV2At(
       curveCode,
       values[9],
       values[10],
-      values[11]);
-  return finitePresentationV2(result);
+      values[11],
+      values[12] == 1,
+      values[13], values[14], values[15], values[16],
+      values[17], values[18], values[19], values[20]);
+  return finitePresentation(result);
 }
 
-void writePresentationV2(
+void writePresentation(
     jsi::Runtime &runtime,
     jsi::Array &result,
     size_t offset,
@@ -149,22 +172,64 @@ void writePresentationV2(
   result.setValueAtIndex(runtime, offset + 9, presentation.contentTranslateX);
   result.setValueAtIndex(runtime, offset + 10, presentation.contentTranslateY);
   result.setValueAtIndex(runtime, offset + 11, presentation.contentScale);
-}
-
-jsi::Array snapshotArrayV2(
+  result.setValueAtIndex(runtime, offset + 12, presentation.shadow.enabled ? 1.0 : 0.0);
+  result.setValueAtIndex(runtime, offset + 13, presentation.shadow.red);
+  result.setValueAtIndex(runtime, offset + 14, presentation.shadow.green);
+  result.setValueAtIndex(runtime, offset + 15, presentation.shadow.blue);
+  result.setValueAtIndex(runtime, offset + 16, presentation.shadow.alpha);
+  result.setValueAtIndex(runtime, offset + 17, presentation.shadow.offsetX);
+  result.setValueAtIndex(runtime, offset + 18, presentation.shadow.offsetY);
+  result.setValueAtIndex(runtime, offset + 19, presentation.shadow.blurRadius);
+  result.setValueAtIndex(runtime, offset + 20, presentation.shadow.spreadDistance);
+}
+
+jsi::Array snapshotArray(
     jsi::Runtime &runtime,
     const std::vector<smoothclip::DriverSnapshot> &snapshots) {
-  jsi::Array result(runtime, snapshots.size() * 13);
+  jsi::Array result(runtime, snapshots.size() * kSnapshotStride);
   for (size_t index = 0; index < snapshots.size(); index += 1) {
-    const size_t offset = index * 13;
+    const size_t offset = index * kSnapshotStride;
     result.setValueAtIndex(
         runtime, offset, snapshots[index].ready ? 1.0 : 0.0);
-    writePresentationV2(
+    writePresentation(
         runtime, result, offset + 1, snapshots[index].presentation);
   }
   return result;
 }
 
+std::vector<double> snapshotValues(
+    const std::vector<smoothclip::DriverSnapshot> &snapshots) {
+  std::vector<double> result;
+  result.reserve(snapshots.size() * kSnapshotStride);
+  for (const smoothclip::DriverSnapshot &snapshot : snapshots) {
+    const smoothclip::Presentation &presentation = snapshot.presentation;
+    result.push_back(snapshot.ready ? 1.0 : 0.0);
+    result.push_back(presentation.clip.x);
+    result.push_back(presentation.clip.y);
+    result.push_back(presentation.clip.width);
+    result.push_back(presentation.clip.height);
+    result.push_back(presentation.clip.topLeftRadius);
+    result.push_back(presentation.clip.topRightRadius);
+    result.push_back(presentation.clip.bottomRightRadius);
+    result.push_back(presentation.clip.bottomLeftRadius);
+    result.push_back(
+        presentation.clip.curve == smoothclip::ClipCurve::Continuous ? 1.0 : 0.0);
+    result.push_back(presentation.contentTranslateX);
+    result.push_back(presentation.contentTranslateY);
+    result.push_back(presentation.contentScale);
+    result.push_back(presentation.shadow.enabled ? 1.0 : 0.0);
+    result.push_back(presentation.shadow.red);
+    result.push_back(presentation.shadow.green);
+    result.push_back(presentation.shadow.blue);
+    result.push_back(presentation.shadow.alpha);
+    result.push_back(presentation.shadow.offsetX);
+    result.push_back(presentation.shadow.offsetY);
+    result.push_back(presentation.shadow.blurRadius);
+    result.push_back(presentation.shadow.spreadDistance);
+  }
+  return result;
+}
+
 bool driverIdsAt(
     jsi::Runtime &runtime,
     const jsi::Array &array,
@@ -186,7 +251,7 @@ bool fixedGroupEntriesAt(
     jsi::Runtime &runtime,
     const jsi::Array &array,
     std::vector<smoothclip::GroupMotionEntry> &result) {
-  constexpr size_t stride = 26;
+  constexpr size_t stride = kMotionEntryStride;
   const size_t count = array.size(runtime);
   if (count == 0 || count % stride != 0) return false;
   result.clear();
@@ -200,8 +265,9 @@ bool fixedGroupEntriesAt(
         !validDriverId(rawDriverId) ||
         !numberAt(runtime, array, offset + 1, rawHasFrom) ||
         (rawHasFrom != 0 && rawHasFrom != 1) ||
-        !presentationV2At(runtime, array, offset + 2, from) ||
-        !presentationV2At(runtime, array, offset + 14, target)) {
+        !presentationAt(runtime, array, offset + 2, from) ||
+        !presentationAt(
+            runtime, array, offset + 2 + kPresentationStride, target)) {
       return false;
     }
     result.push_back({
@@ -209,102 +275,20 @@ bool fixedGroupEntriesAt(
         rawHasFrom == 1,
         from,
         target,
-        {},
     });
   }
   return true;
 }
 
-bool keyframeGroupEntriesAt(
-    jsi::Runtime &runtime,
-    const jsi::Array &array,
-    std::vector<smoothclip::GroupMotionEntry> &result) {
-  const size_t count = array.size(runtime);
-  if (count == 0) return false;
-  result.clear();
-  size_t cursor = 0;
-  while (cursor < count) {
-    constexpr size_t prefix = 27;
-    if (count - cursor < prefix) return false;
-    double rawDriverId = 0;
-    double rawHasFrom = 0;
-    double rawFrameCount = 0;
-    smoothclip::Presentation from;
-    smoothclip::Presentation target;
-    if (!numberAt(runtime, array, cursor, rawDriverId) ||
-        !validDriverId(rawDriverId) ||
-        !numberAt(runtime, array, cursor + 1, rawHasFrom) ||
-        (rawHasFrom != 0 && rawHasFrom != 1) ||
-        !presentationV2At(runtime, array, cursor + 2, from) ||
-        !presentationV2At(runtime, array, cursor + 14, target) ||
-        !numberAt(runtime, array, cursor + 26, rawFrameCount) ||
-        rawFrameCount < 2 || std::floor(rawFrameCount) != rawFrameCount) {
-      return false;
-    }
-    const size_t frameCount = static_cast<size_t>(rawFrameCount);
-    if (frameCount > (count - cursor - prefix) / 13) return false;
-    std::vector<smoothclip::Keyframe> keyframes;
-    keyframes.reserve(frameCount);
-    double previousOffset = -1;
-    const size_t framesOffset = cursor + prefix;
-    for (size_t frameIndex = 0; frameIndex < frameCount; frameIndex += 1) {
-      const size_t frameOffset = framesOffset + frameIndex * 13;
-      double offset = 0;
-      smoothclip::Presentation presentation;
-      if (!numberAt(runtime, array, frameOffset, offset) || offset < 0 ||
-          offset > 1 || offset <= previousOffset ||
-          !presentationV2At(
-              runtime, array, frameOffset + 1, presentation)) {
-        return false;
-      }
-      previousOffset = offset;
-      keyframes.push_back({offset, presentation});
-    }
-    if (keyframes.front().offset != 0 || keyframes.back().offset != 1) {
-      return false;
-    }
-    result.push_back({
-        static_cast<uint64_t>(rawDriverId),
-        rawHasFrom == 1,
-        from,
-        target,
-        std::move(keyframes),
-    });
-    cursor = framesOffset + frameCount * 13;
-  }
-  return !result.empty();
-}
-
 jsi::Array presentationArray(
     jsi::Runtime &runtime,
     smoothclip::Presentation presentation,
     bool includeHandled = false,
     bool handled = true) {
   const size_t offset = includeHandled ? 1 : 0;
-  jsi::Array result(runtime, offset + 7);
-  // JS checks `values[0] !== 1`, so the handled flag must be a number: a jsi
-  // bool would make every comparison fail and leave the driver stuck in
-  // native ownership after cancelAnimation.
-  if (includeHandled) result.setValueAtIndex(runtime, 0, handled ? 1.0 : 0.0);
-  result.setValueAtIndex(runtime, offset, presentation.clip.x);
-  result.setValueAtIndex(runtime, offset + 1, presentation.clip.y);
-  result.setValueAtIndex(runtime, offset + 2, presentation.clip.width);
-  result.setValueAtIndex(runtime, offset + 3, presentation.clip.height);
-  result.setValueAtIndex(runtime, offset + 4, presentation.clip.radius);
-  result.setValueAtIndex(runtime, offset + 5, presentation.contentTranslateX);
-  result.setValueAtIndex(runtime, offset + 6, presentation.contentTranslateY);
-  return result;
-}
-
-jsi::Array presentationArrayV2(
-    jsi::Runtime &runtime,
-    smoothclip::Presentation presentation,
-    bool includeHandled = false,
-    bool handled = true) {
-  const size_t offset = includeHandled ? 1 : 0;
-  jsi::Array result(runtime, offset + 12);
+  jsi::Array result(runtime, offset + kPresentationStride);
   if (includeHandled) result.setValueAtIndex(runtime, 0, handled ? 1.0 : 0.0);
-  writePresentationV2(runtime, result, offset, presentation);
+  writePresentation(runtime, result, offset, presentation);
   return result;
 }
 
@@ -315,28 +299,29 @@ SmoothClipTurboModule::SmoothClipTurboModule(
     : NativeSmoothClipModuleCxxSpec(std::move(jsInvoker)) {
   smoothclip::setCompletionCallback(
       this,
-      [this](uint64_t driverId, int32_t animationId, bool finished) {
+      [this](
+          uint64_t driverId,
+          int32_t animationId,
+          int32_t completionTag,
+          bool finished) {
         emitOnClipAnimationComplete(SmoothClipAnimationCompletion{
-            static_cast<double>(driverId), animationId, finished});
+            static_cast<double>(driverId), animationId, completionTag, finished});
       });
   smoothclip::setGroupCompletionCallback(
       this,
       [this](
           uint64_t controllerId,
           int32_t groupId,
+          int32_t completionTag,
           bool finished,
-          std::vector<uint64_t> driverIds) {
-        std::vector<double> jsDriverIds;
-        jsDriverIds.reserve(driverIds.size());
-        for (const uint64_t driverId : driverIds) {
-          jsDriverIds.push_back(static_cast<double>(driverId));
-        }
+          std::vector<smoothclip::DriverSnapshot> snapshots) {
         emitOnClipGroupAnimationComplete(
             SmoothClipGroupAnimationCompletion{
                 static_cast<double>(controllerId),
                 groupId,
+                completionTag,
                 finished,
-                std::move(jsDriverIds),
+                snapshotValues(snapshots),
             });
       });
 }
@@ -346,40 +331,36 @@ SmoothClipTurboModule::~SmoothClipTurboModule() {
   smoothclip::clearGroupCompletionCallback(this);
 }
 
-int32_t SmoothClipTurboModule::getPresentationProtocolVersion(jsi::Runtime &) {
-  return 2;
-}
-
 bool SmoothClipTurboModule::supportsAutonomousComplexPathAnimation(
     jsi::Runtime &) {
   return false;
 }
 
-jsi::Array SmoothClipTurboModule::beginGroupInteractionV2(
+jsi::Array SmoothClipTurboModule::beginGroupInteraction(
     jsi::Runtime &runtime,
     jsi::Array driverIds) {
   std::vector<uint64_t> parsed;
   if (!driverIdsAt(runtime, driverIds, parsed)) {
     return jsi::Array(runtime, 0);
   }
-  return snapshotArrayV2(
+  return snapshotArray(
       runtime, smoothclip::beginGroupInteraction(parsed));
 }
 
-jsi::Array SmoothClipTurboModule::snapshotGroupV2(
+jsi::Array SmoothClipTurboModule::snapshotGroup(
     jsi::Runtime &runtime,
     jsi::Array driverIds) {
   std::vector<uint64_t> parsed;
   if (!driverIdsAt(runtime, driverIds, parsed)) {
     return jsi::Array(runtime, 0);
   }
-  return snapshotArrayV2(runtime, smoothclip::snapshotGroup(parsed));
+  return snapshotArray(runtime, smoothclip::snapshotGroup(parsed));
 }
 
-bool SmoothClipTurboModule::setClipPresentationBatchV2(
+bool SmoothClipTurboModule::setClipPresentationBatch(
     jsi::Runtime &runtime,
     jsi::Array entries) {
-  constexpr size_t stride = 13;
+  constexpr size_t stride = kSnapshotStride;
   const size_t count = entries.size(runtime);
   if (count % stride != 0) return false;
   std::vector<smoothclip::BatchEntry> parsed;
@@ -389,7 +370,7 @@ bool SmoothClipTurboModule::setClipPresentationBatchV2(
     smoothclip::Presentation presentation;
     if (!numberAt(runtime, entries, offset, driverId) ||
         !validDriverId(driverId) ||
-        !presentationV2At(runtime, entries, offset + 1, presentation)) {
+        !presentationAt(runtime, entries, offset + 1, presentation)) {
       return false;
     }
     parsed.push_back(
@@ -398,7 +379,7 @@ bool SmoothClipTurboModule::setClipPresentationBatchV2(
   return smoothclip::setPresentationBatch(parsed);
 }
 
-int32_t SmoothClipTurboModule::animateTimingGroupV2(
+int32_t SmoothClipTurboModule::animateTimingGroup(
     jsi::Runtime &runtime,
     double controllerId,
     jsi::Array entries,
@@ -408,14 +389,15 @@ int32_t SmoothClipTurboModule::animateTimingGroupV2(
     double controlPoint2X,
     double controlPoint2Y,
     int32_t reduceMotion,
-    int32_t suspensionPolicy) {
+    int32_t completionTag,
+    double startTimestamp) {
+  (void)startTimestamp;
   std::vector<smoothclip::GroupMotionEntry> parsed;
   if (!validDriverId(controllerId) ||
       !fixedGroupEntriesAt(runtime, entries, parsed) ||
       !std::isfinite(durationMs) || !std::isfinite(controlPoint1X) ||
       !std::isfinite(controlPoint1Y) || !std::isfinite(controlPoint2X) ||
-      !std::isfinite(controlPoint2Y) ||
-      !validSuspensionPolicy(suspensionPolicy)) {
+      !std::isfinite(controlPoint2Y)) {
     return 0;
   }
   return smoothclip::animateTimingGroup(
@@ -427,27 +409,29 @@ int32_t SmoothClipTurboModule::animateTimingGroupV2(
        controlPoint2X,
        controlPoint2Y,
        reduceMotion},
-      static_cast<smoothclip::GroupSuspensionPolicy>(suspensionPolicy));
+      completionTag);
 }
 
-int32_t SmoothClipTurboModule::animateSpringGroupV2(
+int32_t SmoothClipTurboModule::animateSpringGroup(
     jsi::Runtime &runtime,
     double controllerId,
     jsi::Array entries,
     double mass,
     double stiffness,
     double damping,
-    double initialVelocity,
-    bool inheritVelocity,
+    double velocity,
+    double energyThreshold,
     int32_t reduceMotion,
-    int32_t suspensionPolicy) {
+    int32_t completionTag,
+    double startTimestamp) {
+  (void)startTimestamp;
   std::vector<smoothclip::GroupMotionEntry> parsed;
   if (!validDriverId(controllerId) ||
       !fixedGroupEntriesAt(runtime, entries, parsed) ||
       !std::isfinite(mass) || !std::isfinite(stiffness) ||
-      !std::isfinite(damping) || !std::isfinite(initialVelocity) ||
-      mass <= 0 || stiffness <= 0 || damping < 0 ||
-      !validSuspensionPolicy(suspensionPolicy)) {
+      !std::isfinite(damping) || !std::isfinite(velocity) ||
+      !std::isfinite(energyThreshold) || mass <= 0 || stiffness <= 0 ||
+      damping < 0 || energyThreshold <= 0) {
     return 0;
   }
   return smoothclip::animateSpringGroup(
@@ -456,35 +440,14 @@ int32_t SmoothClipTurboModule::animateSpringGroupV2(
       {mass,
        stiffness,
        damping,
-       initialVelocity,
-       inheritVelocity,
-       reduceMotion},
-      static_cast<smoothclip::GroupSuspensionPolicy>(suspensionPolicy));
+       velocity,
+       false,
+       reduceMotion,
+       energyThreshold},
+      completionTag);
 }
 
-int32_t SmoothClipTurboModule::animateKeyframesGroupV2(
-    jsi::Runtime &runtime,
-    double controllerId,
-    jsi::Array entries,
-    double durationMs,
-    int32_t reduceMotion,
-    int32_t suspensionPolicy) {
-  std::vector<smoothclip::GroupMotionEntry> parsed;
-  if (!validDriverId(controllerId) ||
-      !keyframeGroupEntriesAt(runtime, entries, parsed) ||
-      !std::isfinite(durationMs) ||
-      !validSuspensionPolicy(suspensionPolicy)) {
-    return 0;
-  }
-  return smoothclip::animateKeyframesGroup(
-      static_cast<uint64_t>(controllerId),
-      std::move(parsed),
-      durationMs,
-      reduceMotion,
-      static_cast<smoothclip::GroupSuspensionPolicy>(suspensionPolicy));
-}
-
-jsi::Array SmoothClipTurboModule::cancelAnimationGroupV2(
+jsi::Array SmoothClipTurboModule::cancelAnimationGroup(
     jsi::Runtime &runtime,
     int32_t groupId,
     int32_t behavior) {
@@ -495,14 +458,30 @@ jsi::Array SmoothClipTurboModule::cancelAnimationGroupV2(
                        smoothclip::GroupCancelBehavior::Finish))) {
     return jsi::Array(runtime, 0);
   }
-  return snapshotArrayV2(
+  return snapshotArray(
       runtime,
       smoothclip::cancelAnimationGroup(
           groupId,
           static_cast<smoothclip::GroupCancelBehavior>(behavior)));
 }
 
-void SmoothClipTurboModule::setClipPresentationV2(
+void SmoothClipTurboModule::setClipPresentation(
+    jsi::Runtime &runtime,
+    double driverId,
+    jsi::Array values,
+    bool takeOwnership,
+    bool overridePendingAnimation) {
+  smoothclip::Presentation presentation{};
+  if (values.size(runtime) == kPresentationStride &&
+      validDriverId(driverId) &&
+      presentationAt(runtime, values, 0, presentation)) {
+    smoothclip::setPresentation(
+        static_cast<uint64_t>(driverId), presentation, takeOwnership,
+        overridePendingAnimation);
+  }
+}
+
+void SmoothClipTurboModule::setClipFrameScalars(
     jsi::Runtime &,
     double driverId,
     double x,
@@ -517,289 +496,112 @@ void SmoothClipTurboModule::setClipPresentationV2(
     double contentTranslateX,
     double contentTranslateY,
     double contentScale,
-    bool takeOwnership,
-    bool overridePendingAnimation) {
-  const smoothclip::Presentation presentation = presentationV2(
+    bool shadowEnabled,
+    double shadowRed,
+    double shadowGreen,
+    double shadowBlue,
+    double shadowAlpha,
+    double shadowOffsetX,
+    double shadowOffsetY,
+    double shadowBlurRadius,
+    double shadowSpreadDistance) {
+  const smoothclip::Presentation presentation = makePresentation(
       x, y, width, height, topLeftRadius, topRightRadius,
       bottomRightRadius, bottomLeftRadius, curveCode,
-      contentTranslateX, contentTranslateY, contentScale);
-  if (validDriverId(driverId) && finitePresentationV2(presentation)) {
-    smoothclip::setPresentation(
-        static_cast<uint64_t>(driverId), presentation, takeOwnership,
-        overridePendingAnimation);
-  }
+      contentTranslateX, contentTranslateY, contentScale,
+      shadowEnabled, shadowRed, shadowGreen, shadowBlue, shadowAlpha,
+      shadowOffsetX, shadowOffsetY, shadowBlurRadius, shadowSpreadDistance);
+  if (!validDriverId(driverId) || !finitePresentation(presentation)) return;
+  smoothclip::setPresentation(
+      static_cast<uint64_t>(driverId), presentation, true, false, true);
 }
 
-jsi::Array SmoothClipTurboModule::beginInteractionV2(
+jsi::Array SmoothClipTurboModule::beginInteraction(
     jsi::Runtime &runtime,
     double driverId) {
   if (!validDriverId(driverId)) {
-    return presentationArrayV2(
-        runtime, presentationV2(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1));
+    return presentationArray(
+        runtime, makePresentation(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1));
   }
-  return presentationArrayV2(
+  return presentationArray(
       runtime,
       smoothclip::beginInteraction(static_cast<uint64_t>(driverId)));
 }
 
-jsi::Array SmoothClipTurboModule::snapshotCurrentV2(
+jsi::Array SmoothClipTurboModule::snapshotCurrent(
     jsi::Runtime &runtime,
     double driverId) {
   if (!validDriverId(driverId)) {
-    return presentationArrayV2(
-        runtime, presentationV2(NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN,
+    return presentationArray(
+        runtime, makePresentation(NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN,
                                 0, NAN, NAN, NAN));
   }
-  return presentationArrayV2(
-      runtime,
-      smoothclip::snapshotCurrent(static_cast<uint64_t>(driverId)));
-}
-
-void SmoothClipTurboModule::setClipPresentation(
-    jsi::Runtime &,
-    double driverId,
-    double x,
-    double y,
-    double width,
-    double height,
-    double radius,
-    double contentTranslateX,
-    double contentTranslateY,
-    bool takeOwnership,
-    bool overridePendingAnimation) {
-  const smoothclip::Presentation presentation{
-      {x, y, width, height, radius}, contentTranslateX, contentTranslateY};
-  if (validDriverId(driverId) && finitePresentation(presentation)) {
-    smoothclip::setPresentation(
-        static_cast<uint64_t>(driverId), presentation, takeOwnership,
-        overridePendingAnimation);
-  }
-}
-
-jsi::Array SmoothClipTurboModule::beginInteraction(
-    jsi::Runtime &runtime,
-    double driverId) {
-  if (!validDriverId(driverId)) {
-    return presentationArray(runtime, {{0, 0, 0, 0, 0}, 0, 0});
-  }
   return presentationArray(
       runtime,
-      smoothclip::beginInteraction(static_cast<uint64_t>(driverId)));
+      smoothclip::snapshotCurrent(static_cast<uint64_t>(driverId)));
 }
 
 int32_t SmoothClipTurboModule::animateTiming(
-    jsi::Runtime &,
-    double driverId,
-    bool hasInteractiveStart,
-    double startX,
-    double startY,
-    double startWidth,
-    double startHeight,
-    double startRadius,
-    double startContentTranslateX,
-    double startContentTranslateY,
-    double x,
-    double y,
-    double width,
-    double height,
-    double radius,
-    double contentTranslateX,
-    double contentTranslateY,
-    double durationMs,
-    double controlPoint1X,
-    double controlPoint1Y,
-    double controlPoint2X,
-    double controlPoint2Y,
-    int32_t reduceMotion) {
-  const smoothclip::Presentation startPresentation{
-      {startX, startY, startWidth, startHeight, startRadius},
-      startContentTranslateX,
-      startContentTranslateY};
-  const smoothclip::Presentation presentation{
-      {x, y, width, height, radius}, contentTranslateX, contentTranslateY};
-  const smoothclip::TimingAnimation animation{
-      durationMs,
-      controlPoint1X,
-      controlPoint1Y,
-      controlPoint2X,
-      controlPoint2Y,
-      reduceMotion};
-  if (!validDriverId(driverId) ||
-      !finitePresentation(startPresentation) ||
-      !finitePresentation(presentation) ||
-      !std::isfinite(durationMs) || !std::isfinite(controlPoint1X) ||
-      !std::isfinite(controlPoint1Y) || !std::isfinite(controlPoint2X) ||
-      !std::isfinite(controlPoint2Y)) return 0;
-
-  return smoothclip::animateTiming(
-      static_cast<uint64_t>(driverId),
-      {hasInteractiveStart, startPresentation},
-      presentation,
-      animation,
-      smoothclip::AnimationValidationMode::LegacyV1);
-}
-
-int32_t SmoothClipTurboModule::animateTimingV2(
-    jsi::Runtime &,
+    jsi::Runtime &runtime,
     double driverId,
-    bool hasInteractiveStart,
-    double startX,
-    double startY,
-    double startWidth,
-    double startHeight,
-    double startTopLeftRadius,
-    double startTopRightRadius,
-    double startBottomRightRadius,
-    double startBottomLeftRadius,
-    int32_t startCurveCode,
-    double startContentTranslateX,
-    double startContentTranslateY,
-    double startContentScale,
-    double x,
-    double y,
-    double width,
-    double height,
-    double topLeftRadius,
-    double topRightRadius,
-    double bottomRightRadius,
-    double bottomLeftRadius,
-    int32_t curveCode,
-    double contentTranslateX,
-    double contentTranslateY,
-    double contentScale,
+    jsi::Array start,
+    jsi::Array target,
     double durationMs,
     double controlPoint1X,
     double controlPoint1Y,
     double controlPoint2X,
     double controlPoint2Y,
-    int32_t reduceMotion) {
-  const smoothclip::Presentation startPresentation = presentationV2(
-      startX, startY, startWidth, startHeight,
-      startTopLeftRadius, startTopRightRadius,
-      startBottomRightRadius, startBottomLeftRadius, startCurveCode,
-      startContentTranslateX, startContentTranslateY, startContentScale);
-  const smoothclip::Presentation presentation = presentationV2(
-      x, y, width, height, topLeftRadius, topRightRadius,
-      bottomRightRadius, bottomLeftRadius, curveCode,
-      contentTranslateX, contentTranslateY, contentScale);
+    int32_t reduceMotion,
+    int32_t completionTag) {
+  const bool hasInteractiveStart = start.size(runtime) != 0;
+  smoothclip::Presentation startPresentation{};
+  smoothclip::Presentation presentation{};
   const smoothclip::TimingAnimation animation{
       durationMs, controlPoint1X, controlPoint1Y,
       controlPoint2X, controlPoint2Y, reduceMotion};
   if (!validDriverId(driverId) ||
-      !finitePresentationV2(startPresentation) ||
-      !finitePresentationV2(presentation) ||
+      (hasInteractiveStart &&
+       (start.size(runtime) != kPresentationStride ||
+        !presentationAt(runtime, start, 0, startPresentation))) ||
+      target.size(runtime) != kPresentationStride ||
+      !presentationAt(runtime, target, 0, presentation) ||
       !std::isfinite(durationMs) || !std::isfinite(controlPoint1X) ||
       !std::isfinite(controlPoint1Y) || !std::isfinite(controlPoint2X) ||
       !std::isfinite(controlPoint2Y)) {
     return 0;
   }
   return smoothclip::animateTiming(
-      static_cast<uint64_t>(driverId),
-      {hasInteractiveStart, startPresentation},
-      presentation,
-      animation);
-}
-
-int32_t SmoothClipTurboModule::animateSpring(
-    jsi::Runtime &,
-    double driverId,
-    bool hasInteractiveStart,
-    double startX,
-    double startY,
-    double startWidth,
-    double startHeight,
-    double startRadius,
-    double startContentTranslateX,
-    double startContentTranslateY,
-    double x,
-    double y,
-    double width,
-    double height,
-    double radius,
-    double contentTranslateX,
-    double contentTranslateY,
-    double mass,
-    double stiffness,
-    double damping,
-    double initialVelocity,
-    bool inheritVelocity,
-    int32_t reduceMotion) {
-  const smoothclip::Presentation startPresentation{
-      {startX, startY, startWidth, startHeight, startRadius},
-      startContentTranslateX,
-      startContentTranslateY};
-  const smoothclip::Presentation presentation{
-      {x, y, width, height, radius}, contentTranslateX, contentTranslateY};
-  const smoothclip::SpringAnimation animation{
-      mass,
-      stiffness,
-      damping,
-      initialVelocity,
-      inheritVelocity,
-      reduceMotion};
-  if (!validDriverId(driverId) ||
-      !finitePresentation(startPresentation) ||
-      !finitePresentation(presentation) ||
-      !std::isfinite(mass) || !std::isfinite(stiffness) ||
-      !std::isfinite(damping) || !std::isfinite(initialVelocity)) return 0;
-
-  return smoothclip::animateSpring(
       static_cast<uint64_t>(driverId),
       {hasInteractiveStart, startPresentation},
       presentation,
       animation,
-      smoothclip::AnimationValidationMode::LegacyV1);
+      completionTag);
 }
 
-int32_t SmoothClipTurboModule::animateSpringV2(
-    jsi::Runtime &,
+int32_t SmoothClipTurboModule::animateSpring(
+    jsi::Runtime &runtime,
     double driverId,
-    bool hasInteractiveStart,
-    double startX,
-    double startY,
-    double startWidth,
-    double startHeight,
-    double startTopLeftRadius,
-    double startTopRightRadius,
-    double startBottomRightRadius,
-    double startBottomLeftRadius,
-    int32_t startCurveCode,
-    double startContentTranslateX,
-    double startContentTranslateY,
-    double startContentScale,
-    double x,
-    double y,
-    double width,
-    double height,
-    double topLeftRadius,
-    double topRightRadius,
-    double bottomRightRadius,
-    double bottomLeftRadius,
-    int32_t curveCode,
-    double contentTranslateX,
-    double contentTranslateY,
-    double contentScale,
+    jsi::Array start,
+    jsi::Array target,
     double mass,
     double stiffness,
     double damping,
     double initialVelocity,
     bool inheritVelocity,
-    int32_t reduceMotion) {
-  const smoothclip::Presentation startPresentation = presentationV2(
-      startX, startY, startWidth, startHeight,
-      startTopLeftRadius, startTopRightRadius,
-      startBottomRightRadius, startBottomLeftRadius, startCurveCode,
-      startContentTranslateX, startContentTranslateY, startContentScale);
-  const smoothclip::Presentation presentation = presentationV2(
-      x, y, width, height, topLeftRadius, topRightRadius,
-      bottomRightRadius, bottomLeftRadius, curveCode,
-      contentTranslateX, contentTranslateY, contentScale);
+    int32_t reduceMotion,
+    int32_t completionTag) {
+  const bool hasInteractiveStart = start.size(runtime) != 0;
+  smoothclip::Presentation startPresentation{};
+  smoothclip::Presentation presentation{};
   const smoothclip::SpringAnimation animation{
       mass, stiffness, damping, initialVelocity,
       inheritVelocity, reduceMotion};
   if (!validDriverId(driverId) ||
-      !finitePresentationV2(startPresentation) ||
-      !finitePresentationV2(presentation) ||
+      (hasInteractiveStart &&
+       (start.size(runtime) != kPresentationStride ||
+        !presentationAt(runtime, start, 0, startPresentation))) ||
+      target.size(runtime) != kPresentationStride ||
+      !presentationAt(runtime, target, 0, presentation) ||
       !std::isfinite(mass) || !std::isfinite(stiffness) ||
       !std::isfinite(damping) || !std::isfinite(initialVelocity) ||
       mass <= 0 || stiffness <= 0 || damping < 0) {
@@ -809,293 +611,8 @@ int32_t SmoothClipTurboModule::animateSpringV2(
       static_cast<uint64_t>(driverId),
       {hasInteractiveStart, startPresentation},
       presentation,
-      animation);
-}
-
-int32_t SmoothClipTurboModule::animateKeyframes(
-    jsi::Runtime &runtime,
-    double driverId,
-    bool hasInteractiveStart,
-    double startX,
-    double startY,
-    double startWidth,
-    double startHeight,
-    double startRadius,
-    double startContentTranslateX,
-    double startContentTranslateY,
-    double x,
-    double y,
-    double width,
-    double height,
-    double radius,
-    double contentTranslateX,
-    double contentTranslateY,
-    double durationMs,
-    jsi::Array frames,
-    int32_t reduceMotion) {
-  const smoothclip::Presentation startPresentation{
-      {startX, startY, startWidth, startHeight, startRadius},
-      startContentTranslateX,
-      startContentTranslateY};
-  const smoothclip::Presentation presentation{
-      {x, y, width, height, radius}, contentTranslateX, contentTranslateY};
-  if (!validDriverId(driverId) ||
-      !finitePresentation(startPresentation) ||
-      !finitePresentation(presentation) || !std::isfinite(durationMs) ||
-      frames.size(runtime) < 16 || frames.size(runtime) % 8 != 0) {
-    return 0;
-  }
-
-  std::vector<smoothclip::Keyframe> keyframes;
-  keyframes.reserve(frames.size(runtime) / 8);
-  double previousOffset = -1;
-  for (size_t index = 0; index < frames.size(runtime); index += 8) {
-    const double offset = frames.getValueAtIndex(runtime, index).asNumber();
-    smoothclip::Presentation frame{
-        {frames.getValueAtIndex(runtime, index + 1).asNumber(),
-         frames.getValueAtIndex(runtime, index + 2).asNumber(),
-         frames.getValueAtIndex(runtime, index + 3).asNumber(),
-         frames.getValueAtIndex(runtime, index + 4).asNumber(),
-         frames.getValueAtIndex(runtime, index + 5).asNumber()},
-        frames.getValueAtIndex(runtime, index + 6).asNumber(),
-        frames.getValueAtIndex(runtime, index + 7).asNumber()};
-    if (!std::isfinite(offset) || offset < 0 || offset > 1 ||
-        offset <= previousOffset || !finitePresentation(frame)) return 0;
-    previousOffset = offset;
-    keyframes.push_back({offset, frame});
-  }
-  if (keyframes.front().offset != 0 || keyframes.back().offset != 1) return 0;
-  return smoothclip::animateKeyframes(
-      static_cast<uint64_t>(driverId),
-      {hasInteractiveStart, startPresentation},
-      presentation,
-      durationMs,
-      std::move(keyframes),
-      reduceMotion,
-      smoothclip::AnimationValidationMode::LegacyV1);
-}
-
-int32_t SmoothClipTurboModule::animateKeyframesV2(
-    jsi::Runtime &runtime,
-    double driverId,
-    bool hasInteractiveStart,
-    double startX,
-    double startY,
-    double startWidth,
-    double startHeight,
-    double startTopLeftRadius,
-    double startTopRightRadius,
-    double startBottomRightRadius,
-    double startBottomLeftRadius,
-    int32_t startCurveCode,
-    double startContentTranslateX,
-    double startContentTranslateY,
-    double startContentScale,
-    double x,
-    double y,
-    double width,
-    double height,
-    double topLeftRadius,
-    double topRightRadius,
-    double bottomRightRadius,
-    double bottomLeftRadius,
-    int32_t curveCode,
-    double contentTranslateX,
-    double contentTranslateY,
-    double contentScale,
-    double durationMs,
-    jsi::Array frames,
-    int32_t reduceMotion) {
-  const smoothclip::Presentation startPresentation = presentationV2(
-      startX, startY, startWidth, startHeight,
-      startTopLeftRadius, startTopRightRadius,
-      startBottomRightRadius, startBottomLeftRadius, startCurveCode,
-      startContentTranslateX, startContentTranslateY, startContentScale);
-  const smoothclip::Presentation presentation = presentationV2(
-      x, y, width, height, topLeftRadius, topRightRadius,
-      bottomRightRadius, bottomLeftRadius, curveCode,
-      contentTranslateX, contentTranslateY, contentScale);
-  const size_t frameValueCount = frames.size(runtime);
-  if (!validDriverId(driverId) ||
-      !finitePresentationV2(startPresentation) ||
-      !finitePresentationV2(presentation) || !std::isfinite(durationMs) ||
-      frameValueCount < 26 || frameValueCount % 13 != 0) {
-    return 0;
-  }
-
-  std::vector<smoothclip::Keyframe> keyframes;
-  keyframes.reserve(frameValueCount / 13);
-  double previousOffset = -1;
-  for (size_t index = 0; index < frameValueCount; index += 13) {
-    const double offset = frames.getValueAtIndex(runtime, index).asNumber();
-    const double rawFrameCurveCode =
-        frames.getValueAtIndex(runtime, index + 9).asNumber();
-    const int32_t frameCurveCode =
-        static_cast<int32_t>(rawFrameCurveCode);
-    const smoothclip::Presentation frame = presentationV2(
-        frames.getValueAtIndex(runtime, index + 1).asNumber(),
-        frames.getValueAtIndex(runtime, index + 2).asNumber(),
-        frames.getValueAtIndex(runtime, index + 3).asNumber(),
-        frames.getValueAtIndex(runtime, index + 4).asNumber(),
-        frames.getValueAtIndex(runtime, index + 5).asNumber(),
-        frames.getValueAtIndex(runtime, index + 6).asNumber(),
-        frames.getValueAtIndex(runtime, index + 7).asNumber(),
-        frames.getValueAtIndex(runtime, index + 8).asNumber(),
-        frameCurveCode,
-        frames.getValueAtIndex(runtime, index + 10).asNumber(),
-        frames.getValueAtIndex(runtime, index + 11).asNumber(),
-        frames.getValueAtIndex(runtime, index + 12).asNumber());
-    if (!std::isfinite(rawFrameCurveCode) ||
-        rawFrameCurveCode != frameCurveCode ||
-        !std::isfinite(offset) || offset < 0 || offset > 1 ||
-        offset <= previousOffset || !finitePresentationV2(frame)) {
-      return 0;
-    }
-    previousOffset = offset;
-    keyframes.push_back({offset, frame});
-  }
-  if (keyframes.front().offset != 0 || keyframes.back().offset != 1) return 0;
-  return smoothclip::animateKeyframes(
-      static_cast<uint64_t>(driverId),
-      {hasInteractiveStart, startPresentation},
-      presentation,
-      durationMs,
-      std::move(keyframes),
-      reduceMotion);
-}
-
-int32_t SmoothClipTurboModule::animateTimingFromV2(
-    jsi::Runtime &runtime,
-    double driverId,
-    double startX,
-    double startY,
-    double startWidth,
-    double startHeight,
-    double startTopLeftRadius,
-    double startTopRightRadius,
-    double startBottomRightRadius,
-    double startBottomLeftRadius,
-    int32_t startCurveCode,
-    double startContentTranslateX,
-    double startContentTranslateY,
-    double startContentScale,
-    double x,
-    double y,
-    double width,
-    double height,
-    double topLeftRadius,
-    double topRightRadius,
-    double bottomRightRadius,
-    double bottomLeftRadius,
-    int32_t curveCode,
-    double contentTranslateX,
-    double contentTranslateY,
-    double contentScale,
-    double durationMs,
-    double controlPoint1X,
-    double controlPoint1Y,
-    double controlPoint2X,
-    double controlPoint2Y,
-    int32_t reduceMotion) {
-  return animateTimingV2(
-      runtime, driverId, true,
-      startX, startY, startWidth, startHeight,
-      startTopLeftRadius, startTopRightRadius,
-      startBottomRightRadius, startBottomLeftRadius, startCurveCode,
-      startContentTranslateX, startContentTranslateY, startContentScale,
-      x, y, width, height,
-      topLeftRadius, topRightRadius, bottomRightRadius, bottomLeftRadius,
-      curveCode, contentTranslateX, contentTranslateY, contentScale,
-      durationMs, controlPoint1X, controlPoint1Y,
-      controlPoint2X, controlPoint2Y, reduceMotion);
-}
-
-int32_t SmoothClipTurboModule::animateSpringFromV2(
-    jsi::Runtime &runtime,
-    double driverId,
-    double startX,
-    double startY,
-    double startWidth,
-    double startHeight,
-    double startTopLeftRadius,
-    double startTopRightRadius,
-    double startBottomRightRadius,
-    double startBottomLeftRadius,
-    int32_t startCurveCode,
-    double startContentTranslateX,
-    double startContentTranslateY,
-    double startContentScale,
-    double x,
-    double y,
-    double width,
-    double height,
-    double topLeftRadius,
-    double topRightRadius,
-    double bottomRightRadius,
-    double bottomLeftRadius,
-    int32_t curveCode,
-    double contentTranslateX,
-    double contentTranslateY,
-    double contentScale,
-    double mass,
-    double stiffness,
-    double damping,
-    double initialVelocity,
-    bool inheritVelocity,
-    int32_t reduceMotion) {
-  return animateSpringV2(
-      runtime, driverId, true,
-      startX, startY, startWidth, startHeight,
-      startTopLeftRadius, startTopRightRadius,
-      startBottomRightRadius, startBottomLeftRadius, startCurveCode,
-      startContentTranslateX, startContentTranslateY, startContentScale,
-      x, y, width, height,
-      topLeftRadius, topRightRadius, bottomRightRadius, bottomLeftRadius,
-      curveCode, contentTranslateX, contentTranslateY, contentScale,
-      mass, stiffness, damping, initialVelocity, inheritVelocity,
-      reduceMotion);
-}
-
-int32_t SmoothClipTurboModule::animateKeyframesFromV2(
-    jsi::Runtime &runtime,
-    double driverId,
-    double startX,
-    double startY,
-    double startWidth,
-    double startHeight,
-    double startTopLeftRadius,
-    double startTopRightRadius,
-    double startBottomRightRadius,
-    double startBottomLeftRadius,
-    int32_t startCurveCode,
-    double startContentTranslateX,
-    double startContentTranslateY,
-    double startContentScale,
-    double x,
-    double y,
-    double width,
-    double height,
-    double topLeftRadius,
-    double topRightRadius,
-    double bottomRightRadius,
-    double bottomLeftRadius,
-    int32_t curveCode,
-    double contentTranslateX,
-    double contentTranslateY,
-    double contentScale,
-    double durationMs,
-    jsi::Array frames,
-    int32_t reduceMotion) {
-  return animateKeyframesV2(
-      runtime, driverId, true,
-      startX, startY, startWidth, startHeight,
-      startTopLeftRadius, startTopRightRadius,
-      startBottomRightRadius, startBottomLeftRadius, startCurveCode,
-      startContentTranslateX, startContentTranslateY, startContentScale,
-      x, y, width, height,
-      topLeftRadius, topRightRadius, bottomRightRadius, bottomLeftRadius,
-      curveCode, contentTranslateX, contentTranslateY, contentScale,
-      durationMs, std::move(frames), reduceMotion);
+      animation,
+      completionTag);
 }
 
 int32_t SmoothClipTurboModule::rejectAnimation(
@@ -1112,29 +629,14 @@ jsi::Array SmoothClipTurboModule::cancelAnimation(
     int32_t behavior) {
   if (!validDriverId(driverId)) {
     return presentationArray(
-        runtime, {{0, 0, 0, 0, 0}, 0, 0}, true, false);
-  }
-  const smoothclip::CancelResult result = smoothclip::cancelAnimation(
-      static_cast<uint64_t>(driverId), animationId, behavior == 1);
-  return presentationArray(
-      runtime, result.presentation, true, result.handled);
-}
-
-jsi::Array SmoothClipTurboModule::cancelAnimationV2(
-    jsi::Runtime &runtime,
-    double driverId,
-    int32_t animationId,
-    int32_t behavior) {
-  if (!validDriverId(driverId)) {
-    return presentationArrayV2(
         runtime,
-        presentationV2(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1),
+        makePresentation(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1),
         true,
         false);
   }
   const smoothclip::CancelResult result = smoothclip::cancelAnimation(
       static_cast<uint64_t>(driverId), animationId, behavior == 1);
-  return presentationArrayV2(
+  return presentationArray(
       runtime, result.presentation, true, result.handled);
 }