chore: Return unique_ptr from TransformOperationInterpolator interpolate method (#8342)

## Summary

As the title states, this PR changes the return type of the
`interpolate` method declared on the `TransformOperationInterpolator`
class to the `std::unique_ptr` from `folly::dynamic`. This is necessary
to add support for SVG transforms handling were we have to create a
single matrix from interpolated operation and can't convert transforms
array to `folly::dynamic::array` like we do in plain transforms.

Author: MatiPl01

packages/react-native-reanimated/Common/cpp/reanimated/CSS/interpolation/transforms/TransformOperationInterpolator.cpp

@@ -13,7 +13,13 @@ std::shared_ptr<TransformOperation> TransformInterpolator::resolveOperation(
   return operation;
 }
 
-folly::dynamic
+TransformOperationInterpolator<PerspectiveOperation>::
+    TransformOperationInterpolator(
+        const std::shared_ptr<PerspectiveOperation> &defaultOperation)
+    : TransformOperationInterpolatorBase<PerspectiveOperation>(
+          defaultOperation) {}
+
+std::unique_ptr<TransformOperation>
 TransformOperationInterpolator<PerspectiveOperation>::interpolate(
     double progress,
     const std::shared_ptr<TransformOperation> &from,
@@ -24,16 +30,16 @@ TransformOperationInterpolator<PerspectiveOperation>::interpolate(
   const auto &toValue =
       std::static_pointer_cast<PerspectiveOperation>(to)->value;
 
-  if (fromValue.value == 0)
-    return from->toDynamic();
-  if (toValue.value == 0)
-    return to->toDynamic();
-
-  return PerspectiveOperation(fromValue.interpolate(progress, toValue))
-      .toDynamic();
+  return std::make_unique<PerspectiveOperation>(
+      fromValue.interpolate(progress, toValue));
 }
 
-folly::dynamic TransformOperationInterpolator<MatrixOperation>::interpolate(
+TransformOperationInterpolator<MatrixOperation>::TransformOperationInterpolator(
+    const std::shared_ptr<MatrixOperation> &defaultOperation)
+    : TransformOperationInterpolatorBase<MatrixOperation>(defaultOperation) {}
+
+std::unique_ptr<TransformOperation>
+TransformOperationInterpolator<MatrixOperation>::interpolate(
     double progress,
     const std::shared_ptr<TransformOperation> &from,
     const std::shared_ptr<TransformOperation> &to,
@@ -43,21 +49,18 @@ folly::dynamic TransformOperationInterpolator<MatrixOperation>::interpolate(
   const auto fromMatrix = matrixFromOperation(from, shouldBe3D, context);
   const auto toMatrix = matrixFromOperation(to, shouldBe3D, context);
 
-  folly::dynamic value;
-
   if (shouldBe3D) {
-    value = interpolateMatrix<TransformMatrix3D>(progress, fromMatrix, toMatrix)
-                .toDynamic();
-  } else {
-    // Unfortunately 2D matrices aren't handled properly in RN, so we have to
-    // convert them to 3D
-    // see the issue: https://github.com/facebook/react-native/issues/53639
-    const auto result2D =
-        interpolateMatrix<TransformMatrix2D>(progress, fromMatrix, toMatrix);
-    value = TransformMatrix3D::from2D(result2D).toDynamic();
+    return std::make_unique<MatrixOperation>(
+        interpolateMatrix<TransformMatrix3D>(progress, fromMatrix, toMatrix));
   }
 
-  return folly::dynamic::object(from->getOperationName(), value);
+  const auto result2D =
+      interpolateMatrix<TransformMatrix2D>(progress, fromMatrix, toMatrix);
+
+  // Unfortunately 2D matrices aren't handled properly in RN, so we have to
+  // convert them to 3D
+  // see the issue: https://github.com/facebook/react-native/issues/53639
+  return std::make_unique<MatrixOperation>(TransformMatrix3D::from2D(result2D));
 }
 
 template <typename MatrixType>
@@ -139,21 +142,23 @@ template TransformMatrix3D TransformOperationInterpolator<MatrixOperation>::
         const TransformMatrix::Shared &) const;
 
 // Template implementations
-template <typename OperationType>
-TransformOperationInterpolator<OperationType>::TransformOperationInterpolator(
-    std::shared_ptr<OperationType> defaultOperation)
-    : TransformOperationInterpolatorBase<OperationType>(defaultOperation) {}
+template <typename TOperation>
+TransformOperationInterpolator<TOperation>::TransformOperationInterpolator(
+    const std::shared_ptr<TOperation> &defaultOperation)
+    : TransformOperationInterpolatorBase<TOperation>(defaultOperation) {}
 
-template <typename OperationType>
-folly::dynamic TransformOperationInterpolator<OperationType>::interpolate(
+template <typename TOperation>
+std::unique_ptr<TransformOperation>
+TransformOperationInterpolator<TOperation>::interpolate(
     double progress,
     const std::shared_ptr<TransformOperation> &from,
     const std::shared_ptr<TransformOperation> &to,
     const TransformInterpolationContext &context) const {
-  const auto &fromOp = *std::static_pointer_cast<OperationType>(from);
-  const auto &toOp = *std::static_pointer_cast<OperationType>(to);
-  return OperationType(fromOp.value.interpolate(progress, toOp.value))
-      .toDynamic();
+  const auto &fromOp = *std::static_pointer_cast<TOperation>(from);
+  const auto &toOp = *std::static_pointer_cast<TOperation>(to);
+
+  return std::make_unique<TOperation>(
+      fromOp.value.interpolate(progress, toOp.value));
 }
 
 template <ResolvableTransformOp TOperation>
@@ -164,17 +169,17 @@ TransformOperationInterpolator<TOperation>::TransformOperationInterpolator(
       config_(std::move(config)) {}
 
 template <ResolvableTransformOp TOperation>
-folly::dynamic TransformOperationInterpolator<TOperation>::interpolate(
+std::unique_ptr<TransformOperation>
+TransformOperationInterpolator<TOperation>::interpolate(
     double progress,
     const std::shared_ptr<TransformOperation> &from,
     const std::shared_ptr<TransformOperation> &to,
     const TransformInterpolationContext &context) const {
   const auto &fromOp = *std::static_pointer_cast<TOperation>(from);
   const auto &toOp = *std::static_pointer_cast<TOperation>(to);
-  return TOperation(
-             fromOp.value.interpolate(
-                 progress, toOp.value, getResolvableValueContext(context)))
-      .toDynamic();
+
+  return std::make_unique<TOperation>(fromOp.value.interpolate(
+      progress, toOp.value, getResolvableValueContext(context)));
 }
 
 template <ResolvableTransformOp TOperation>

packages/react-native-reanimated/Common/cpp/reanimated/CSS/interpolation/transforms/TransformOperationInterpolator.h

@@ -33,7 +33,7 @@ class TransformInterpolator {
   virtual ~TransformInterpolator() = default;
 
   virtual std::shared_ptr<TransformOperation> getDefaultOperation() const = 0;
-  virtual folly::dynamic interpolate(
+  virtual std::unique_ptr<TransformOperation> interpolate(
       double progress,
       const std::shared_ptr<TransformOperation> &from,
       const std::shared_ptr<TransformOperation> &to,
@@ -47,30 +47,30 @@ using TransformOperationInterpolators = TransformInterpolator::Interpolators;
 using TransformInterpolationContext = TransformInterpolator::UpdateContext;
 
 // Base class with common functionality
-template <typename OperationType>
+template <typename TOperation>
 class TransformOperationInterpolatorBase : public TransformInterpolator {
  public:
   TransformOperationInterpolatorBase(
-      std::shared_ptr<OperationType> defaultOperation)
+      std::shared_ptr<TOperation> defaultOperation)
       : defaultOperation_(defaultOperation) {}
 
   std::shared_ptr<TransformOperation> getDefaultOperation() const override {
     return defaultOperation_;
   }
 
  protected:
-  std::shared_ptr<OperationType> defaultOperation_;
+  std::shared_ptr<TOperation> defaultOperation_;
 };
 
 // Base implementation for simple operations
-template <typename OperationType>
+template <typename TOperation>
 class TransformOperationInterpolator
-    : public TransformOperationInterpolatorBase<OperationType> {
+    : public TransformOperationInterpolatorBase<TOperation> {
  public:
   TransformOperationInterpolator(
-      std::shared_ptr<OperationType> defaultOperation);
+      const std::shared_ptr<TOperation> &defaultOperation);
 
-  folly::dynamic interpolate(
+  std::unique_ptr<TransformOperation> interpolate(
       double progress,
       const std::shared_ptr<TransformOperation> &from,
       const std::shared_ptr<TransformOperation> &to,
@@ -83,11 +83,9 @@ class TransformOperationInterpolator<PerspectiveOperation>
     : public TransformOperationInterpolatorBase<PerspectiveOperation> {
  public:
   TransformOperationInterpolator(
-      std::shared_ptr<PerspectiveOperation> defaultOperation)
-      : TransformOperationInterpolatorBase<PerspectiveOperation>(
-            defaultOperation) {}
+      const std::shared_ptr<PerspectiveOperation> &defaultOperation);
 
-  folly::dynamic interpolate(
+  std::unique_ptr<TransformOperation> interpolate(
       double progress,
       const std::shared_ptr<TransformOperation> &from,
       const std::shared_ptr<TransformOperation> &to,
@@ -100,10 +98,9 @@ class TransformOperationInterpolator<MatrixOperation>
     : public TransformOperationInterpolatorBase<MatrixOperation> {
  public:
   TransformOperationInterpolator(
-      std::shared_ptr<MatrixOperation> defaultOperation)
-      : TransformOperationInterpolatorBase<MatrixOperation>(defaultOperation) {}
+      const std::shared_ptr<MatrixOperation> &defaultOperation);
 
-  folly::dynamic interpolate(
+  std::unique_ptr<TransformOperation> interpolate(
       double progress,
       const std::shared_ptr<TransformOperation> &from,
       const std::shared_ptr<TransformOperation> &to,
@@ -131,7 +128,7 @@ class TransformOperationInterpolator<TOperation>
       const std::shared_ptr<TOperation> &defaultOperation,
       ResolvableValueInterpolatorConfig config);
 
-  folly::dynamic interpolate(
+  std::unique_ptr<TransformOperation> interpolate(
       double progress,
       const std::shared_ptr<TransformOperation> &from,
       const std::shared_ptr<TransformOperation> &to,

packages/react-native-reanimated/Common/cpp/reanimated/CSS/interpolation/transforms/TransformsStyleInterpolator.cpp

@@ -372,7 +372,7 @@ folly::dynamic TransformsStyleInterpolator::interpolateOperations(
     const double keyframeProgress,
     const TransformOperations &fromOperations,
     const TransformOperations &toOperations) const {
-  auto result = folly::dynamic::array();
+  TransformOperations result;
   result.reserve(fromOperations.size());
 
   const auto transformUpdateContext = TransformInterpolationContext{
@@ -384,15 +384,15 @@ folly::dynamic TransformsStyleInterpolator::interpolateOperations(
 
     // fromOperation and toOperation have the same type
     const auto &interpolator = interpolators_->at(fromOperation->type);
-    result.push_back(interpolator->interpolate(
+    result.emplace_back(interpolator->interpolate(
         keyframeProgress, fromOperation, toOperation, transformUpdateContext));
   }
 
   if (result.empty()) {
     return folly::dynamic();
   }
 
-  return result;
+  return convertOperationsToDynamic(result);
 }
 
 folly::dynamic TransformsStyleInterpolator::convertOperationsToDynamic(