@react-native-ohos/react-native-reanimated 4.0.1 → 4.0.2-beta.1

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/operations/OperationsStyleInterpolator.h

@@ -1,100 +1,100 @@
-#pragma once
-
-#include <reanimated/CSS/interpolation/PropertyInterpolator.h>
-#include <reanimated/CSS/interpolation/operations/StyleOperation.h>
-#include <reanimated/CSS/interpolation/operations/StyleOperationInterpolator.h>
-
-#include <memory>
-#include <optional>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-namespace reanimated::css {
-
-struct StyleOperationsKeyframe {
-  const double fromOffset;
-  const double toOffset;
-  // If the value is nullopt, we would have to read it from the view style
-  // (in all other cases, both vectors will have the same number of elements of
-  // corresponding types - elements from the same index will form interpolation
-  // pairs)
-  const std::optional<StyleOperations> fromOperations;
-  const std::optional<StyleOperations> toOperations;
-  // Keyframe is discrete when the fromOperations and toOperations aren't compatible
-  const bool isDiscrete;
-};
-
-class OperationsStyleInterpolator : public PropertyInterpolator {
- public:
-  OperationsStyleInterpolator(
-      const PropertyPath &propertyPath,
-      const std::shared_ptr<StyleOperationInterpolators> &interpolators,
-      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository,
-      const folly::dynamic &defaultStyleValueDynamic);
-
-  folly::dynamic getStyleValue(const std::shared_ptr<const ShadowNode> &shadowNode) const override;
-  folly::dynamic getResetStyle(const std::shared_ptr<const ShadowNode> &shadowNode) const override;
-  folly::dynamic getFirstKeyframeValue() const override;
-  folly::dynamic getLastKeyframeValue() const override;
-  bool equalsReversingAdjustedStartValue(const folly::dynamic &propertyValue) const override;
-
-  folly::dynamic interpolate(
-      const std::shared_ptr<const ShadowNode> &shadowNode,
-      const std::shared_ptr<KeyframeProgressProvider> &progressProvider,
-      const double fallbackInterpolateThreshold) const override;
-
-  void updateKeyframes(jsi::Runtime &rt, const jsi::Value &keyframes) override;
-  void updateKeyframesFromStyleChange(
-      const folly::dynamic &oldStyleValue,
-      const folly::dynamic &newStyleValue,
-      const folly::dynamic &lastUpdateValue) override;
-
- protected:
-  const std::shared_ptr<StyleOperationInterpolators> interpolators_;
-
-  virtual std::shared_ptr<StyleOperation> createStyleOperation(jsi::Runtime &rt, const jsi::Value &value) const = 0;
-  virtual std::shared_ptr<StyleOperation> createStyleOperation(const folly::dynamic &value) const = 0;
-  virtual std::optional<std::pair<StyleOperations, StyleOperations>> createInterpolationPair(
-      const StyleOperations &fromOperations,
-      const StyleOperations &toOperations) const = 0;
-
- private:
-  const folly::dynamic defaultStyleValueDynamic_;
-
-  std::vector<std::shared_ptr<StyleOperationsKeyframe>> keyframes_;
-  std::optional<StyleOperations> reversingAdjustedStartValue_;
-
-  std::optional<StyleOperations> parseStyleOperations(jsi::Runtime &rt, const jsi::Value &values) const;
-  std::optional<StyleOperations> parseStyleOperations(const folly::dynamic &values) const;
-  std::shared_ptr<StyleOperationsKeyframe> createStyleOperationsKeyframe(
-      double fromOffset,
-      double toOffset,
-      const std::optional<StyleOperations> &fromOperationsOptional,
-      const std::optional<StyleOperations> &toOperationsOptional) const;
-  size_t getIndexOfCurrentKeyframe(const std::shared_ptr<KeyframeProgressProvider> &progressProvider) const;
-  StyleOperations getFallbackValue(const std::shared_ptr<const ShadowNode> &shadowNode) const;
-  folly::dynamic interpolateOperations(
-      const std::shared_ptr<const ShadowNode> &shadowNode,
-      double keyframeProgress,
-      const StyleOperations &fromOperations,
-      const StyleOperations &toOperations,
-      double fallbackInterpolateThreshold) const;
-  static folly::dynamic convertOperationsToDynamic(const StyleOperations &operations);
-  StyleOperationsInterpolationContext createUpdateContext(
-      const std::shared_ptr<const ShadowNode> &shadowNode,
-      double fallbackInterpolateThreshold) const;
-};
-
-template <typename TOperation>
-class OperationsStyleInterpolatorBase : public OperationsStyleInterpolator {
- public:
-  using OperationsStyleInterpolator::OperationsStyleInterpolator;
-
- protected:
-  std::shared_ptr<StyleOperation> createStyleOperation(jsi::Runtime &rt, const jsi::Value &value) const override;
-  std::shared_ptr<StyleOperation> createStyleOperation(const folly::dynamic &value) const override;
-  std::shared_ptr<TOperation> getDefaultOperationOfType(size_t type) const;
-};
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/interpolation/PropertyInterpolator.h>
+#include <reanimated/CSS/interpolation/operations/StyleOperation.h>
+#include <reanimated/CSS/interpolation/operations/StyleOperationInterpolator.h>
+
+#include <memory>
+#include <optional>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace reanimated::css {
+
+struct StyleOperationsKeyframe {
+  const double fromOffset;
+  const double toOffset;
+  // If the value is nullopt, we would have to read it from the view style
+  // (in all other cases, both vectors will have the same number of elements of
+  // corresponding types - elements from the same index will form interpolation
+  // pairs)
+  const std::optional<StyleOperations> fromOperations;
+  const std::optional<StyleOperations> toOperations;
+  // Keyframe is discrete when the fromOperations and toOperations aren't compatible
+  const bool isDiscrete;
+};
+
+class OperationsStyleInterpolator : public PropertyInterpolator {
+ public:
+  OperationsStyleInterpolator(
+      const PropertyPath &propertyPath,
+      const std::shared_ptr<StyleOperationInterpolators> &interpolators,
+      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository,
+      const folly::dynamic &defaultStyleValueDynamic);
+
+  folly::dynamic getStyleValue(const std::shared_ptr<const ShadowNode> &shadowNode) const override;
+  folly::dynamic getResetStyle(const std::shared_ptr<const ShadowNode> &shadowNode) const override;
+  folly::dynamic getFirstKeyframeValue() const override;
+  folly::dynamic getLastKeyframeValue() const override;
+  bool equalsReversingAdjustedStartValue(const folly::dynamic &propertyValue) const override;
+
+  folly::dynamic interpolate(
+      const std::shared_ptr<const ShadowNode> &shadowNode,
+      const std::shared_ptr<KeyframeProgressProvider> &progressProvider,
+      const double fallbackInterpolateThreshold) const override;
+
+  void updateKeyframes(jsi::Runtime &rt, const jsi::Value &keyframes) override;
+  void updateKeyframesFromStyleChange(
+      const folly::dynamic &oldStyleValue,
+      const folly::dynamic &newStyleValue,
+      const folly::dynamic &lastUpdateValue) override;
+
+ protected:
+  const std::shared_ptr<StyleOperationInterpolators> interpolators_;
+
+  virtual std::shared_ptr<StyleOperation> createStyleOperation(jsi::Runtime &rt, const jsi::Value &value) const = 0;
+  virtual std::shared_ptr<StyleOperation> createStyleOperation(const folly::dynamic &value) const = 0;
+  virtual std::optional<std::pair<StyleOperations, StyleOperations>> createInterpolationPair(
+      const StyleOperations &fromOperations,
+      const StyleOperations &toOperations) const = 0;
+
+ private:
+  const folly::dynamic defaultStyleValueDynamic_;
+
+  std::vector<std::shared_ptr<StyleOperationsKeyframe>> keyframes_;
+  std::optional<StyleOperations> reversingAdjustedStartValue_;
+
+  std::optional<StyleOperations> parseStyleOperations(jsi::Runtime &rt, const jsi::Value &values) const;
+  std::optional<StyleOperations> parseStyleOperations(const folly::dynamic &values) const;
+  std::shared_ptr<StyleOperationsKeyframe> createStyleOperationsKeyframe(
+      double fromOffset,
+      double toOffset,
+      const std::optional<StyleOperations> &fromOperationsOptional,
+      const std::optional<StyleOperations> &toOperationsOptional) const;
+  size_t getIndexOfCurrentKeyframe(const std::shared_ptr<KeyframeProgressProvider> &progressProvider) const;
+  StyleOperations getFallbackValue(const std::shared_ptr<const ShadowNode> &shadowNode) const;
+  folly::dynamic interpolateOperations(
+      const std::shared_ptr<const ShadowNode> &shadowNode,
+      double keyframeProgress,
+      const StyleOperations &fromOperations,
+      const StyleOperations &toOperations,
+      double fallbackInterpolateThreshold) const;
+  static folly::dynamic convertOperationsToDynamic(const StyleOperations &operations);
+  StyleOperationsInterpolationContext createUpdateContext(
+      const std::shared_ptr<const ShadowNode> &shadowNode,
+      double fallbackInterpolateThreshold) const;
+};
+
+template <typename TOperation>
+class OperationsStyleInterpolatorBase : public OperationsStyleInterpolator {
+ public:
+  using OperationsStyleInterpolator::OperationsStyleInterpolator;
+
+ protected:
+  std::shared_ptr<StyleOperation> createStyleOperation(jsi::Runtime &rt, const jsi::Value &value) const override;
+  std::shared_ptr<StyleOperation> createStyleOperation(const folly::dynamic &value) const override;
+  std::shared_ptr<TOperation> getDefaultOperationOfType(size_t type) const;
+};
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/operations/StyleOperation.cpp

@@ -1,19 +1,19 @@
-#include <reanimated/CSS/interpolation/operations/StyleOperation.h>
-
-namespace reanimated::css {
-
-StyleOperation::StyleOperation(uint8_t type) : type(type) {}
-
-bool StyleOperation::operator==(const StyleOperation &other) const {
-  return type == other.type && areValuesEqual(other);
-}
-
-folly::dynamic StyleOperation::toDynamic() const {
-  return folly::dynamic::object(getOperationName(), valueToDynamic());
-}
-
-bool StyleOperation::shouldResolve() const {
-  return false;
-}
-
-} // namespace reanimated::css
+#include <reanimated/CSS/interpolation/operations/StyleOperation.h>
+
+namespace reanimated::css {
+
+StyleOperation::StyleOperation(uint8_t type) : type(type) {}
+
+bool StyleOperation::operator==(const StyleOperation &other) const {
+  return type == other.type && areValuesEqual(other);
+}
+
+folly::dynamic StyleOperation::toDynamic() const {
+  return folly::dynamic::object(getOperationName(), valueToDynamic());
+}
+
+bool StyleOperation::shouldResolve() const {
+  return false;
+}
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/operations/StyleOperation.h

@@ -1,94 +1,94 @@
-#pragma once
-
-#include <reanimated/CSS/common/values/CSSValue.h>
-
-#include <folly/dynamic.h>
-#include <jsi/jsi.h>
-#include <memory>
-#include <string>
-#include <type_traits>
-#include <vector>
-
-namespace reanimated::css {
-
-using namespace facebook;
-
-//template <typename TOperation>
-//concept ResolvableOp = requires(TOperation operation) {
-//  { operation.value } -> std::convertible_to<typename std::remove_reference_t<decltype(operation.value)>>;
-//  requires Resolvable<std::remove_reference_t<decltype(operation.value)>>;
-//}; // NOLINT(readability/braces)
-
-//template<typename TOperation>
-//struct IsResolvableOpHelper {
-//private:
-//    template<typename T>
-//    static auto test(int) -> decltype(
-//        std::declval<T>().value,
-//        std::declval<typename std::remove_reference_t<decltype(std::declval<T>().value)>>(),
-//        std::declval<Resolvable<typename std::remove_reference_t<decltype(std::declval<T>().value)>>>(),
-//        std::true_type{}
-//    );
-//
-//    template<typename T>
-//    static std::false_type test(...);
-//
-//public:
-//    using type = decltype(test<TOperation>(0));
-//};
-//
-//template<typename TOperation>
-//constexpr bool ResolvableOp = IsResolvableOpHelper<TOperation>::type::value;
-
-
-template <typename T>
-using value_type_t = decltype(std::declval<T>().value);
-
-template <typename T>
-using remove_ref_value_type_t = std::remove_reference_t<value_type_t<T>>;
-
-template <typename T, typename = void>
-struct has_value_member : std::false_type {};
-
-template <typename T>
-struct has_value_member<T, std::void_t<decltype(std::declval<T>().value)>> : std::true_type {};
-
-template <typename T, typename = void>
-struct is_resolvable_op_impl : std::false_type {};
-
-template <typename T>
-struct is_resolvable_op_impl<
-    T,
-    std::enable_if_t<
-        has_value_member<T>::value &&
-        std::is_convertible<value_type_t<T>, remove_ref_value_type_t<T>>::value &&
-        Resolvable<remove_ref_value_type_t<T>>>> : std::true_type {};
-
-
-template <typename TOperation>
-struct is_resolvable_op : reanimated::css::is_resolvable_op_impl<TOperation> {};
-
-template <typename TOperation>
-constexpr bool ResolvableOp = is_resolvable_op<TOperation>::value;
-
-//is_resolvable_op_v
-struct StyleOperation {
-  uint8_t type;
-
-  explicit StyleOperation(uint8_t type);
-  virtual ~StyleOperation() = default;
-
-  bool operator==(const StyleOperation &other) const;
-  folly::dynamic toDynamic() const;
-
-  virtual std::string getOperationName() const = 0;
-  virtual bool shouldResolve() const;
-
- protected:
-  virtual folly::dynamic valueToDynamic() const = 0;
-  virtual bool areValuesEqual(const StyleOperation &other) const = 0;
-};
-
-using StyleOperations = std::vector<std::shared_ptr<StyleOperation>>;
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSValue.h>
+
+#include <folly/dynamic.h>
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+namespace reanimated::css {
+
+using namespace facebook;
+
+//template <typename TOperation>
+//concept ResolvableOp = requires(TOperation operation) {
+//  { operation.value } -> std::convertible_to<typename std::remove_reference_t<decltype(operation.value)>>;
+//  requires Resolvable<std::remove_reference_t<decltype(operation.value)>>;
+//}; // NOLINT(readability/braces)
+
+//template<typename TOperation>
+//struct IsResolvableOpHelper {
+//private:
+//    template<typename T>
+//    static auto test(int) -> decltype(
+//        std::declval<T>().value,
+//        std::declval<typename std::remove_reference_t<decltype(std::declval<T>().value)>>(),
+//        std::declval<Resolvable<typename std::remove_reference_t<decltype(std::declval<T>().value)>>>(),
+//        std::true_type{}
+//    );
+//
+//    template<typename T>
+//    static std::false_type test(...);
+//
+//public:
+//    using type = decltype(test<TOperation>(0));
+//};
+//
+//template<typename TOperation>
+//constexpr bool ResolvableOp = IsResolvableOpHelper<TOperation>::type::value;
+
+
+template <typename T>
+using value_type_t = decltype(std::declval<T>().value);
+
+template <typename T>
+using remove_ref_value_type_t = std::remove_reference_t<value_type_t<T>>;
+
+template <typename T, typename = void>
+struct has_value_member : std::false_type {};
+
+template <typename T>
+struct has_value_member<T, std::void_t<decltype(std::declval<T>().value)>> : std::true_type {};
+
+template <typename T, typename = void>
+struct is_resolvable_op_impl : std::false_type {};
+
+template <typename T>
+struct is_resolvable_op_impl<
+    T,
+    std::enable_if_t<
+        has_value_member<T>::value &&
+        std::is_convertible<value_type_t<T>, remove_ref_value_type_t<T>>::value &&
+        Resolvable<remove_ref_value_type_t<T>>>> : std::true_type {};
+
+
+template <typename TOperation>
+struct is_resolvable_op : reanimated::css::is_resolvable_op_impl<TOperation> {};
+
+template <typename TOperation>
+constexpr bool ResolvableOp = is_resolvable_op<TOperation>::value;
+
+//is_resolvable_op_v
+struct StyleOperation {
+  uint8_t type;
+
+  explicit StyleOperation(uint8_t type);
+  virtual ~StyleOperation() = default;
+
+  bool operator==(const StyleOperation &other) const;
+  folly::dynamic toDynamic() const;
+
+  virtual std::string getOperationName() const = 0;
+  virtual bool shouldResolve() const;
+
+ protected:
+  virtual folly::dynamic valueToDynamic() const = 0;
+  virtual bool areValuesEqual(const StyleOperation &other) const = 0;
+};
+
+using StyleOperations = std::vector<std::shared_ptr<StyleOperation>>;
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/operations/StyleOperationInterpolator.cpp

@@ -1,18 +1,18 @@
-#include <reanimated/CSS/interpolation/operations/StyleOperationInterpolator.h>
-
-namespace reanimated::css {
-
-StyleOperationInterpolator::StyleOperationInterpolator(const std::shared_ptr<StyleOperation> &defaultOperation)
-    : defaultOperation_(defaultOperation) {}
-
-std::shared_ptr<StyleOperation> StyleOperationInterpolator::getDefaultOperation() const {
-  return defaultOperation_;
-}
-
-std::shared_ptr<StyleOperation> StyleOperationInterpolator::resolveOperation(
-    const std::shared_ptr<StyleOperation> &operation,
-    const StyleOperationsInterpolationContext &context) const {
-  return operation;
-}
-
-} // namespace reanimated::css
+#include <reanimated/CSS/interpolation/operations/StyleOperationInterpolator.h>
+
+namespace reanimated::css {
+
+StyleOperationInterpolator::StyleOperationInterpolator(const std::shared_ptr<StyleOperation> &defaultOperation)
+    : defaultOperation_(defaultOperation) {}
+
+std::shared_ptr<StyleOperation> StyleOperationInterpolator::getDefaultOperation() const {
+  return defaultOperation_;
+}
+
+std::shared_ptr<StyleOperation> StyleOperationInterpolator::resolveOperation(
+    const std::shared_ptr<StyleOperation> &operation,
+    const StyleOperationsInterpolationContext &context) const {
+  return operation;
+}
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/operations/StyleOperationInterpolator.h

@@ -1,43 +1,43 @@
-#pragma once
-
-#include <reanimated/CSS/interpolation/configs.h>
-#include <reanimated/CSS/interpolation/operations/StyleOperation.h>
-#include <reanimated/CSS/misc/ViewStylesRepository.h>
-
-#include <memory>
-#include <unordered_map>
-
-namespace reanimated::css {
-
-class StyleOperationInterpolator {
- public:
-  using Interpolators = std::unordered_map<size_t, std::shared_ptr<StyleOperationInterpolator>>;
-
-  struct UpdateContext {
-    const std::shared_ptr<const ShadowNode> &node;
-    const std::shared_ptr<ViewStylesRepository> &viewStylesRepository;
-    const std::shared_ptr<Interpolators> &interpolators;
-    const double fallbackInterpolateThreshold;
-  };
-
-  explicit StyleOperationInterpolator(const std::shared_ptr<StyleOperation> &defaultOperation);
-  virtual ~StyleOperationInterpolator() = default;
-
-  std::shared_ptr<StyleOperation> getDefaultOperation() const;
-  virtual std::unique_ptr<StyleOperation> interpolate(
-      double progress,
-      const std::shared_ptr<StyleOperation> &from,
-      const std::shared_ptr<StyleOperation> &to,
-      const UpdateContext &context) const = 0;
-  virtual std::shared_ptr<StyleOperation> resolveOperation(
-      const std::shared_ptr<StyleOperation> &operation,
-      const UpdateContext &context) const;
-
- private:
-  const std::shared_ptr<StyleOperation> defaultOperation_;
-};
-
-using StyleOperationInterpolators = StyleOperationInterpolator::Interpolators;
-using StyleOperationsInterpolationContext = StyleOperationInterpolator::UpdateContext;
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/interpolation/configs.h>
+#include <reanimated/CSS/interpolation/operations/StyleOperation.h>
+#include <reanimated/CSS/misc/ViewStylesRepository.h>
+
+#include <memory>
+#include <unordered_map>
+
+namespace reanimated::css {
+
+class StyleOperationInterpolator {
+ public:
+  using Interpolators = std::unordered_map<size_t, std::shared_ptr<StyleOperationInterpolator>>;
+
+  struct UpdateContext {
+    const std::shared_ptr<const ShadowNode> &node;
+    const std::shared_ptr<ViewStylesRepository> &viewStylesRepository;
+    const std::shared_ptr<Interpolators> &interpolators;
+    const double fallbackInterpolateThreshold;
+  };
+
+  explicit StyleOperationInterpolator(const std::shared_ptr<StyleOperation> &defaultOperation);
+  virtual ~StyleOperationInterpolator() = default;
+
+  std::shared_ptr<StyleOperation> getDefaultOperation() const;
+  virtual std::unique_ptr<StyleOperation> interpolate(
+      double progress,
+      const std::shared_ptr<StyleOperation> &from,
+      const std::shared_ptr<StyleOperation> &to,
+      const UpdateContext &context) const = 0;
+  virtual std::shared_ptr<StyleOperation> resolveOperation(
+      const std::shared_ptr<StyleOperation> &operation,
+      const UpdateContext &context) const;
+
+ private:
+  const std::shared_ptr<StyleOperation> defaultOperation_;
+};
+
+using StyleOperationInterpolators = StyleOperationInterpolator::Interpolators;
+using StyleOperationsInterpolationContext = StyleOperationInterpolator::UpdateContext;
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/styles/AnimationStyleInterpolator.h

@@ -1,26 +1,26 @@
-#pragma once
-
-#include <reanimated/CSS/InterpolatorRegistry.h>
-#include <reanimated/CSS/interpolation/groups/RecordPropertiesInterpolator.h>
-
-#include <memory>
-#include <string>
-
-namespace reanimated::css {
-
-// We can just re-use the logic from the RecordPropertiesInterpolator class as
-// interpolating multiple properties from the view style during animation is the
-// same as interpolating record properties
-class AnimationStyleInterpolator : public RecordPropertiesInterpolator {
- public:
-  explicit AnimationStyleInterpolator(
-      jsi::Runtime &rt,
-      const jsi::Value &keyframes,
-      const std::string &componentName,
-      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository)
-      : RecordPropertiesInterpolator(getComponentInterpolators(componentName), {}, viewStylesRepository) {
-    updateKeyframes(rt, keyframes);
-  }
-};
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/InterpolatorRegistry.h>
+#include <reanimated/CSS/interpolation/groups/RecordPropertiesInterpolator.h>
+
+#include <memory>
+#include <string>
+
+namespace reanimated::css {
+
+// We can just re-use the logic from the RecordPropertiesInterpolator class as
+// interpolating multiple properties from the view style during animation is the
+// same as interpolating record properties
+class AnimationStyleInterpolator : public RecordPropertiesInterpolator {
+ public:
+  explicit AnimationStyleInterpolator(
+      jsi::Runtime &rt,
+      const jsi::Value &keyframes,
+      const std::string &componentName,
+      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository)
+      : RecordPropertiesInterpolator(getComponentInterpolators(componentName), {}, viewStylesRepository) {
+    updateKeyframes(rt, keyframes);
+  }
+};
+
+} // namespace reanimated::css