@react-native-ohos/react-native-reanimated 3.18.1-rc.6 → 4.0.0-rc.1

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/updates/UpdatesRegistry.h

@@ -0,0 +1,71 @@
+#pragma once
+
+#include <reanimated/Fabric/ShadowTreeCloner.h>
+
+#include <react/renderer/core/ShadowNode.h>
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+namespace reanimated {
+
+using namespace facebook;
+using namespace react;
+
+using UpdatesBatch = std::vector<std::pair<std::shared_ptr<const ShadowNode>, folly::dynamic>>;
+using RegistryMap = std::unordered_map<Tag, std::pair<std::shared_ptr<const ShadowNode>, folly::dynamic>>;
+
+#ifdef ANDROID
+struct PropsToRevert {
+  std::shared_ptr<const ShadowNode> shadowNode;
+  std::unordered_set<std::string> props;
+};
+
+using PropsToRevertMap = std::unordered_map<Tag, PropsToRevert>;
+#endif
+
+class UpdatesRegistry {
+ public:
+  virtual ~UpdatesRegistry() {}
+
+  std::lock_guard<std::mutex> lock() const;
+
+  virtual bool isEmpty() const;
+  folly::dynamic get(Tag tag) const;
+  virtual void remove(Tag tag) = 0;
+
+#ifdef ANDROID
+  bool hasPropsToRevert() const;
+  void collectPropsToRevert(PropsToRevertMap &propsToRevertMap);
+#endif
+
+  void flushUpdates(UpdatesBatch &updatesBatch);
+  void collectProps(PropsMap &propsMap);
+
+ protected:
+  mutable std::mutex mutex_;
+  RegistryMap updatesRegistry_;
+
+  void addUpdatesToBatch(const std::shared_ptr<const ShadowNode> &shadowNode, const folly::dynamic &props);
+  folly::dynamic getUpdatesFromRegistry(const Tag tag) const;
+  void setInUpdatesRegistry(const std::shared_ptr<const ShadowNode> &shadowNode, const folly::dynamic &props);
+  void removeFromUpdatesRegistry(Tag tag);
+
+ private:
+  UpdatesBatch updatesBatch_;
+
+  void flushUpdatesToRegistry(const UpdatesBatch &updatesBatch);
+
+#ifdef ANDROID
+  PropsToRevertMap propsToRevertMap_;
+
+  void updatePropsToRevert(Tag tag, const folly::dynamic *newProps = nullptr);
+#endif
+};
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/updates/UpdatesRegistryManager.cpp

@@ -0,0 +1,161 @@
+#include <reanimated/Fabric/updates/UpdatesRegistryManager.h>
+#include <reanimated/Tools/FeatureFlags.h>
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+namespace reanimated {
+
+UpdatesRegistryManager::UpdatesRegistryManager(const std::shared_ptr<StaticPropsRegistry> &staticPropsRegistry)
+    : staticPropsRegistry_(staticPropsRegistry) {}
+
+std::lock_guard<std::mutex> UpdatesRegistryManager::lock() const {
+  return std::lock_guard<std::mutex>{mutex_};
+}
+
+void UpdatesRegistryManager::addRegistry(const std::shared_ptr<UpdatesRegistry> &registry) {
+  if (!registry) {
+    throw std::invalid_argument("[Reanimated] Registry cannot be null");
+  }
+  registries_.push_back(registry);
+}
+
+void UpdatesRegistryManager::pauseReanimatedCommits() {
+  if constexpr (!StaticFeatureFlags::getFlag("DISABLE_COMMIT_PAUSING_MECHANISM")) {
+    isPaused_ = true;
+  }
+}
+
+bool UpdatesRegistryManager::shouldReanimatedSkipCommit() {
+  return isPaused_;
+}
+
+void UpdatesRegistryManager::unpauseReanimatedCommits() {
+  isPaused_ = false;
+}
+
+void UpdatesRegistryManager::pleaseCommitAfterPause() {
+  shouldCommitAfterPause_ = true;
+}
+
+void UpdatesRegistryManager::cancelCommitAfterPause() {
+  shouldCommitAfterPause_ = false;
+}
+
+bool UpdatesRegistryManager::shouldCommitAfterPause() {
+  return shouldCommitAfterPause_.exchange(false);
+}
+
+void UpdatesRegistryManager::markNodeAsRemovable(const std::shared_ptr<const ShadowNode> &shadowNode) {
+  removableShadowNodes_[shadowNode->getTag()] = shadowNode;
+}
+
+void UpdatesRegistryManager::unmarkNodeAsRemovable(Tag viewTag) {
+  removableShadowNodes_.erase(viewTag);
+}
+
+void UpdatesRegistryManager::handleNodeRemovals(const RootShadowNode &rootShadowNode) {
+  RemovableShadowNodes remainingShadowNodes;
+
+  for (const auto &[tag, shadowNode] : removableShadowNodes_) {
+    if (!shadowNode) {
+      continue;
+    }
+
+    if (shadowNode->getFamily().getAncestors(rootShadowNode).empty()) {
+      for (auto &registry : registries_) {
+        registry->remove(tag);
+      }
+      staticPropsRegistry_->remove(tag);
+    } else {
+      remainingShadowNodes.emplace(tag, shadowNode);
+    }
+  }
+
+  removableShadowNodes_ = std::move(remainingShadowNodes);
+}
+
+PropsMap UpdatesRegistryManager::collectProps() {
+  PropsMap propsMap;
+  for (auto &registry : registries_) {
+    registry->collectProps(propsMap);
+  }
+  return propsMap;
+}
+
+#ifdef ANDROID
+
+bool UpdatesRegistryManager::hasPropsToRevert() {
+  for (auto &registry : registries_) {
+    if (registry->hasPropsToRevert()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void UpdatesRegistryManager::addToPropsMap(
+    PropsMap &propsMap,
+    const std::shared_ptr<const ShadowNode> &shadowNode,
+    const folly::dynamic &props) {
+  auto &family = shadowNode->getFamily();
+  auto it = propsMap.find(&family);
+
+  if (it == propsMap.cend()) {
+    auto propsVector = std::vector<RawProps>{};
+    propsVector.emplace_back(props);
+    propsMap.emplace(&family, propsVector);
+  } else {
+    it->second.emplace_back(props);
+  }
+}
+
+void UpdatesRegistryManager::collectPropsToRevertBySurface(std::unordered_map<SurfaceId, PropsMap> &propsMapBySurface) {
+  for (const auto &registry : registries_) {
+    registry->collectPropsToRevert(propsToRevertMap_);
+  }
+
+  for (const auto &[tag, pair] : propsToRevertMap_) {
+    const auto &[shadowNode, props] = pair;
+    const auto &staticStyle = staticPropsRegistry_->get(tag);
+    folly::dynamic filteredStyle = folly::dynamic::object;
+
+    for (const auto &propName : props) {
+      if (!staticStyle.isNull() && staticStyle.count(propName) > 0) {
+        filteredStyle[propName] = staticStyle[propName];
+        continue;
+      }
+
+      const auto &componentName = shadowNode->getComponentName();
+      const auto &interpolators = getComponentInterpolators(componentName);
+      const auto &it = interpolators.find(propName);
+
+      if (it != interpolators.end()) {
+        filteredStyle[propName] = it->second->getDefaultValue().toDynamic();
+        continue;
+      }
+
+      filteredStyle[propName] = nullptr;
+    }
+
+    const auto &surfaceId = shadowNode->getSurfaceId();
+    auto &propsMap = propsMapBySurface[surfaceId];
+
+    addToPropsMap(propsMap, shadowNode, filteredStyle);
+  }
+}
+
+void UpdatesRegistryManager::clearPropsToRevert(const SurfaceId surfaceId) {
+  for (auto it = propsToRevertMap_.begin(); it != propsToRevertMap_.end();) {
+    if (it->second.shadowNode->getSurfaceId() == surfaceId) {
+      it = propsToRevertMap_.erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
+#endif
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/updates/UpdatesRegistryManager.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <reanimated/CSS/InterpolatorRegistry.h>
+#include <reanimated/CSS/registries/StaticPropsRegistry.h>
+
+#include <reanimated/Fabric/ShadowTreeCloner.h>
+#include <reanimated/Fabric/updates/UpdatesRegistry.h>
+
+#include <memory>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace reanimated {
+
+using namespace css;
+
+class UpdatesRegistryManager {
+ public:
+  explicit UpdatesRegistryManager(const std::shared_ptr<StaticPropsRegistry> &staticPropsRegistry);
+
+  std::lock_guard<std::mutex> lock() const;
+
+  // TODO - ensure that other sublibraries can easily hook into this registry
+  // manager (e.g. add priority to registries)
+  void addRegistry(const std::shared_ptr<UpdatesRegistry> &registry);
+
+  void pauseReanimatedCommits();
+  bool shouldReanimatedSkipCommit();
+  void unpauseReanimatedCommits();
+
+  void pleaseCommitAfterPause();
+  bool shouldCommitAfterPause();
+  void cancelCommitAfterPause();
+
+  void markNodeAsRemovable(const std::shared_ptr<const ShadowNode> &shadowNode);
+  void unmarkNodeAsRemovable(Tag viewTag);
+  void handleNodeRemovals(const RootShadowNode &rootShadowNode);
+  PropsMap collectProps();
+
+#ifdef ANDROID
+  bool hasPropsToRevert();
+  void collectPropsToRevertBySurface(std::unordered_map<SurfaceId, PropsMap> &propsMapBySurface);
+  void clearPropsToRevert(SurfaceId surfaceId);
+#endif
+
+ private:
+  using RemovableShadowNodes = std::unordered_map<Tag, std::shared_ptr<const ShadowNode>>;
+
+  mutable std::mutex mutex_;
+  std::atomic<bool> isPaused_;
+  std::atomic<bool> shouldCommitAfterPause_;
+  RemovableShadowNodes removableShadowNodes_;
+  std::vector<std::shared_ptr<UpdatesRegistry>> registries_;
+  const std::shared_ptr<StaticPropsRegistry> staticPropsRegistry_;
+
+#ifdef ANDROID
+  PropsToRevertMap propsToRevertMap_;
+
+  static void
+  addToPropsMap(PropsMap &propsMap, const std::shared_ptr<const ShadowNode> &shadowNode, const folly::dynamic &props);
+#endif
+};
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationType.h

@@ -1,9 +1,11 @@
 #pragma once
 
-typedef enum LayoutAnimationType {
+#include <cstdint>
+
+typedef enum class LayoutAnimationType : std::uint8_t {
   ENTERING = 1,
   EXITING = 2,
   LAYOUT = 3,
   SHARED_ELEMENT_TRANSITION = 4,
-  SHARED_ELEMENT_TRANSITION_PROGRESS = 5,
+  SHARED_ELEMENT_TRANSITION_NATIVE_ID = 5,
 } LayoutAnimationType;

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsManager.cpp

@@ -1,102 +1,59 @@
 #include <reanimated/LayoutAnimations/LayoutAnimationsManager.h>
-#include <reanimated/Tools/CollectionUtils.h>
 
-#ifndef NDEBUG
+#include <memory>
+#include <unordered_map>
 #include <utility>
-#endif
+#include <vector>
 
 namespace reanimated {
 
-void LayoutAnimationsManager::configureAnimationBatch(
-    const std::vector<LayoutAnimationConfig> &layoutAnimationsBatch) {
+void LayoutAnimationsManager::configureAnimationBatch(const std::vector<LayoutAnimationConfig> &layoutAnimationsBatch) {
   auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
-  std::vector<LayoutAnimationConfig> sharedTransitionConfigs;
-  for (auto layoutAnimationConfig : layoutAnimationsBatch) {
-    const auto &[tag, type, config, sharedTransitionTag] =
-        layoutAnimationConfig;
-    if (type == SHARED_ELEMENT_TRANSITION ||
-        type == SHARED_ELEMENT_TRANSITION_PROGRESS) {
-      clearSharedTransitionConfig(tag);
-      sharedTransitionConfigs.push_back(std::move(layoutAnimationConfig));
-    } else {
-#ifdef RCT_NEW_ARCH_ENABLED
-      if (type == ENTERING) {
-        enteringAnimationsForNativeID_[tag] = config;
-        continue;
-      }
-#endif
+  for (const auto &layoutAnimationConfig : layoutAnimationsBatch) {
+    const auto &[tag, type, config, sharedTag] = layoutAnimationConfig;
+
+    if (type == LayoutAnimationType::ENTERING) {
+      enteringAnimationsForNativeID_[tag] = config;
+      continue;
+    }
+    if (type == LayoutAnimationType::SHARED_ELEMENT_TRANSITION_NATIVE_ID) {
+      sharedTransitionsForNativeID_[tag] = config;
+      sharedTransitionManager_->nativeIDToName_[tag] = sharedTag;
+      continue;
+    }
+    if (type == LayoutAnimationType::SHARED_ELEMENT_TRANSITION) {
       if (config == nullptr) {
-        getConfigsForType(type).erase(tag);
+        // TODO (future): if the view was transitioned (e.g. so we are on the second screen)
+        // and we remove the config, we should also bring back the view (probably using tagsToRestore_)
+        sharedTransitions_.erase(tag);
+        sharedTransitionManager_->tagToName_.erase(tag);
       } else {
-        getConfigsForType(type)[tag] = config;
+        sharedTransitions_[tag] = config;
+        sharedTransitionManager_->tagToName_[tag] = sharedTag;
       }
-    }
-  }
-  for (const auto &[tag, type, config, sharedTransitionTag] :
-       sharedTransitionConfigs) {
-    if (config == nullptr) {
       continue;
     }
-    sharedTransitionGroups_[sharedTransitionTag].push_back(tag);
-    viewTagToSharedTag_[tag] = sharedTransitionTag;
-    getConfigsForType(SHARED_ELEMENT_TRANSITION)[tag] = config;
-    if (type == SHARED_ELEMENT_TRANSITION) {
-      ignoreProgressAnimationForTag_.insert(tag);
+    if (config == nullptr) {
+      getConfigsForType(type).erase(tag);
+    } else {
+      getConfigsForType(type)[tag] = config;
     }
   }
 }
 
-void LayoutAnimationsManager::setShouldAnimateExiting(
-    const int tag,
-    const bool value) {
+void LayoutAnimationsManager::setShouldAnimateExiting(const int tag, const bool value) {
   auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
   shouldAnimateExitingForTag_[tag] = value;
 }
 
-bool LayoutAnimationsManager::shouldAnimateExiting(
-    const int tag,
-    const bool shouldAnimate) {
-  auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
-  return collection::contains(shouldAnimateExitingForTag_, tag)
-      ? shouldAnimateExitingForTag_[tag]
-      : shouldAnimate;
-}
-
-bool LayoutAnimationsManager::hasLayoutAnimation(
-    const int tag,
-    const LayoutAnimationType type) {
+bool LayoutAnimationsManager::shouldAnimateExiting(const int tag, const bool shouldAnimate) {
   auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
-  if (type == SHARED_ELEMENT_TRANSITION_PROGRESS) {
-    auto end = ignoreProgressAnimationForTag_.end();
-    return ignoreProgressAnimationForTag_.find(tag) == end;
-  }
-  return collection::contains(getConfigsForType(type), tag);
+  return shouldAnimateExitingForTag_.contains(tag) ? shouldAnimateExitingForTag_[tag] : shouldAnimate;
 }
 
-void LayoutAnimationsManager::clearSharedTransitionConfig(const int tag) {
+bool LayoutAnimationsManager::hasLayoutAnimation(const int tag, const LayoutAnimationType type) {
   auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
-#ifndef NDEBUG
-  const auto &pair = viewsScreenSharedTagMap_[tag];
-  screenSharedTagSet_.erase(pair);
-  viewsScreenSharedTagMap_.erase(tag);
-#endif // NDEBUG
-
-  sharedTransitionAnimations_.erase(tag);
-  auto const &groupName = viewTagToSharedTag_[tag];
-  if (groupName.empty()) {
-    viewTagToSharedTag_.erase(tag);
-    return;
-  }
-  auto &group = sharedTransitionGroups_[groupName];
-  auto position = std::find(group.begin(), group.end(), tag);
-  if (position != group.end()) {
-    group.erase(position);
-  }
-  if (group.size() == 0) {
-    sharedTransitionGroups_.erase(groupName);
-  }
-  viewTagToSharedTag_.erase(tag);
-  ignoreProgressAnimationForTag_.erase(tag);
+  return getConfigsForType(type).contains(tag);
 }
 
 void LayoutAnimationsManager::clearLayoutAnimationConfig(const int tag) {
@@ -105,7 +62,6 @@ void LayoutAnimationsManager::clearLayoutAnimationConfig(const int tag) {
   exitingAnimations_.erase(tag);
   layoutAnimations_.erase(tag);
   shouldAnimateExitingForTag_.erase(tag);
-  clearSharedTransitionConfig(tag);
 }
 
 void LayoutAnimationsManager::startLayoutAnimation(
@@ -113,119 +69,68 @@ void LayoutAnimationsManager::startLayoutAnimation(
     const int tag,
     const LayoutAnimationType type,
     const jsi::Object &values) {
-  std::shared_ptr<Shareable> config, viewShareable;
+  std::shared_ptr<Serializable> config;
   {
     auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
-    if (!collection::contains(getConfigsForType(type), tag)) {
+    if (!getConfigsForType(type).contains(tag)) {
       return;
     }
     config = getConfigsForType(type)[tag];
   }
   // TODO: cache the following!!
   jsi::Value layoutAnimationRepositoryAsValue =
-      rt.global()
-          .getPropertyAsObject(rt, "global")
-          .getProperty(rt, "LayoutAnimationsManager");
+      rt.global().getPropertyAsObject(rt, "global").getProperty(rt, "LayoutAnimationsManager");
   jsi::Function startAnimationForTag =
-      layoutAnimationRepositoryAsValue.getObject(rt).getPropertyAsFunction(
-          rt, "start");
-  startAnimationForTag.call(
-      rt,
-      jsi::Value(tag),
-      jsi::Value(static_cast<int>(type)),
-      values,
-      config->toJSValue(rt));
+      layoutAnimationRepositoryAsValue.getObject(rt).getPropertyAsFunction(rt, "start");
+  startAnimationForTag.call(rt, jsi::Value(tag), jsi::Value(static_cast<int>(type)), values, config->toJSValue(rt));
 }
 
-void LayoutAnimationsManager::cancelLayoutAnimation(
-    jsi::Runtime &rt,
-    const int tag) const {
+void LayoutAnimationsManager::cancelLayoutAnimation(jsi::Runtime &rt, const int tag) const {
   jsi::Value layoutAnimationRepositoryAsValue =
-      rt.global()
-          .getPropertyAsObject(rt, "global")
-          .getProperty(rt, "LayoutAnimationsManager");
+      rt.global().getPropertyAsObject(rt, "global").getProperty(rt, "LayoutAnimationsManager");
   jsi::Function cancelLayoutAnimation =
-      layoutAnimationRepositoryAsValue.getObject(rt).getPropertyAsFunction(
-          rt, "stop");
+      layoutAnimationRepositoryAsValue.getObject(rt).getPropertyAsFunction(rt, "stop");
   cancelLayoutAnimation.call(rt, jsi::Value(tag));
 }
 
-/*
-  The top screen on the stack triggers the animation, so we need to find
-  the sibling view registered in the past. This method finds view
-  registered in the same transition group (with the same transition tag)
-  which has been added to that group directly before the one that we
-  provide as an argument.
-*/
-int LayoutAnimationsManager::findPrecedingViewTagForTransition(const int tag) {
-  auto const &groupName = viewTagToSharedTag_[tag];
-  auto const &group = sharedTransitionGroups_[groupName];
-  auto position = std::find(group.begin(), group.end(), tag);
-  if (position != group.end() && position != group.begin()) {
-    return *std::prev(position);
-  }
-  return -1;
-}
-
-const std::vector<int> &LayoutAnimationsManager::getSharedGroup(
-    const int viewTag) {
-  const auto &groupSharedTag = viewTagToSharedTag_[viewTag];
-  return sharedTransitionGroups_[groupSharedTag];
-}
-
-#ifdef RCT_NEW_ARCH_ENABLED
-void LayoutAnimationsManager::transferConfigFromNativeID(
-    const int nativeId,
-    const int tag) {
+void LayoutAnimationsManager::transferConfigFromNativeID(const int nativeId, const int tag) {
   auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
-  auto config = enteringAnimationsForNativeID_[nativeId];
+  const auto config = enteringAnimationsForNativeID_[nativeId];
   if (config) {
     enteringAnimations_.insert_or_assign(tag, config);
   }
   enteringAnimationsForNativeID_.erase(nativeId);
+
+  const auto sharedTransitionConfig = sharedTransitionsForNativeID_[nativeId];
+  if (sharedTransitionConfig) {
+    sharedTransitions_.insert_or_assign(tag, sharedTransitionConfig);
+    sharedTransitionManager_->tagToName_[tag] = sharedTransitionManager_->nativeIDToName_[nativeId];
+  }
+  sharedTransitionsForNativeID_.erase(nativeId);
+  sharedTransitionManager_->nativeIDToName_.erase(nativeId);
 }
-#endif
 
-#ifndef NDEBUG
-std::string LayoutAnimationsManager::getScreenSharedTagPairString(
-    const int screenTag,
-    const std::string &sharedTag) const {
-  return std::to_string(screenTag) + ":" + sharedTag;
+void LayoutAnimationsManager::transferSharedConfig(const Tag from, const Tag to) {
+  sharedTransitions_[to] = sharedTransitions_[from];
 }
 
-void LayoutAnimationsManager::checkDuplicateSharedTag(
-    const int viewTag,
-    const int screenTag) {
-  if (!viewTagToSharedTag_.count(viewTag)) {
-    return;
-  }
-  const auto &sharedTag = viewTagToSharedTag_[viewTag];
-  const auto &pair = getScreenSharedTagPairString(screenTag, sharedTag);
-  bool hasDuplicate = screenSharedTagSet_.count(pair);
-  if (hasDuplicate) {
-    jsLogger_->warnOnJS(
-        "[Reanimated] Duplicate shared tag \"" + sharedTag +
-        "\" on the same screen");
-  }
-  viewsScreenSharedTagMap_[viewTag] = pair;
-  screenSharedTagSet_.insert(pair);
+std::shared_ptr<SharedTransitionManager> LayoutAnimationsManager::getSharedTransitionManager() {
+  return sharedTransitionManager_;
 }
-#endif // NDEBUG
 
-std::unordered_map<int, std::shared_ptr<Shareable>> &
-LayoutAnimationsManager::getConfigsForType(const LayoutAnimationType type) {
+std::unordered_map<int, std::shared_ptr<Serializable>> &LayoutAnimationsManager::getConfigsForType(
+    const LayoutAnimationType type) {
   switch (type) {
-    case ENTERING:
+    case LayoutAnimationType::ENTERING:
       return enteringAnimations_;
-    case EXITING:
+    case LayoutAnimationType::EXITING:
       return exitingAnimations_;
-    case LAYOUT:
+    case LayoutAnimationType::LAYOUT:
       return layoutAnimations_;
-    case SHARED_ELEMENT_TRANSITION:
-    case SHARED_ELEMENT_TRANSITION_PROGRESS:
-      return sharedTransitionAnimations_;
+    case LayoutAnimationType::SHARED_ELEMENT_TRANSITION:
+      return sharedTransitions_;
     default:
-      assert(false);
+      throw std::invalid_argument("[Reanimated] Unknown layout animation type");
   }
 }