@amazon-devices/react-native-screens 2.0.1758683737 → 3.0.9000000000

package/common/cpp/react/renderer/components/rnscreens/utils/RectUtil.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <react/renderer/graphics/Float.h>
+#include <react/renderer/graphics/Size.h>
+#include <cmath>
+#include <concepts>
+
+namespace rnscreens {
+
+namespace react = facebook::react;
+
+template <typename T>
+  requires std::is_floating_point_v<T>
+inline constexpr bool equalWithRespectToEps(const T a, const T b, const T eps) {
+  return std::abs(a - b) <= eps;
+}
+
+/**
+ * Compares given two frame sizes with respect to the epsilon.
+ *
+ * @param first first frame size
+ * @param second second frame size
+ * @param eps comparison precision, defaults to 0.01, which should ensure that
+ * precision of comparison is under 1px
+ * @return whether the frame dimensions are the same with respect to given
+ * epsilon
+ */
+inline constexpr bool checkFrameSizesEqualWithEps(
+    const react::Size &first,
+    const react::Size &second,
+    const react::Float eps = 0.01) {
+  return equalWithRespectToEps(first.width, second.width, eps) &&
+      equalWithRespectToEps(first.height, second.height, eps);
+}
+
+} // namespace rnscreens

package/cpp/RNSScreenRemovalListener.cpp

@@ -0,0 +1,25 @@
+#include "RNSScreenRemovalListener.h"
+#include <react/renderer/mounting/ShadowViewMutation.h>
+using namespace facebook::react;
+
+std::optional<MountingTransaction> RNSScreenRemovalListener::pullTransaction(
+    SurfaceId surfaceId,
+    MountingTransaction::Number transactionNumber,
+    const TransactionTelemetry &telemetry,
+    ShadowViewMutationList mutations) const {
+  for (const ShadowViewMutation &mutation : mutations) {
+    if (mutation.type == ShadowViewMutation::Type::Remove &&
+        mutation.oldChildShadowView.componentName != nullptr &&
+        strcmp(mutation.parentShadowView.componentName, "RNSScreenStack") ==
+            0) {
+      listenerFunction_(mutation.oldChildShadowView.tag);
+    }
+  }
+
+  return MountingTransaction{
+      surfaceId, transactionNumber, std::move(mutations), telemetry};
+}
+
+bool RNSScreenRemovalListener::shouldOverridePullTransaction() const {
+  return true;
+}

package/cpp/RNSScreenRemovalListener.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
+#include <react/renderer/mounting/MountingOverrideDelegate.h>
+#include <react/renderer/mounting/ShadowView.h>
+
+using namespace facebook::react;
+
+struct RNSScreenRemovalListener : public MountingOverrideDelegate {
+  std::function<void(int)> listenerFunction_;
+  RNSScreenRemovalListener(std::function<void(int)> &&listenerFunction_)
+      : listenerFunction_(std::move(listenerFunction_)) {}
+
+  bool shouldOverridePullTransaction() const override;
+  std::optional<MountingTransaction> pullTransaction(
+      SurfaceId surfaceId,
+      MountingTransaction::Number number,
+      const TransactionTelemetry &telemetry,
+      ShadowViewMutationList mutations) const override;
+};

package/cpp/RNScreensTurboModule.cpp

@@ -0,0 +1,115 @@
+#include "RNScreensTurboModule.h"
+
+using namespace facebook;
+
+namespace RNScreens {
+
+const char RNScreensTurboModule::MODULE_NAME[] = "RNScreensTurboModule";
+
+std::function<std::array<int, 2>(int)> RNScreensTurboModule::startTransition_;
+std::function<void(int, double)> RNScreensTurboModule::updateTransition_;
+std::function<void(int, bool)> RNScreensTurboModule::finishTransition_;
+std::function<void(int)> RNScreensTurboModule::disableSwipeBackForTopScreen_;
+
+RNScreensTurboModule::RNScreensTurboModule(
+    std::function<std::array<int, 2>(int)> startTransition,
+    std::function<void(int, double)> updateTransition,
+    std::function<void(int, bool)> finishTransition,
+    std::function<void(int)> disableSwipeBackForTopScreen) {
+  startTransition_ = startTransition;
+  updateTransition_ = updateTransition;
+  finishTransition_ = finishTransition;
+  disableSwipeBackForTopScreen_ = disableSwipeBackForTopScreen;
+}
+
+RNScreensTurboModule::~RNScreensTurboModule(){};
+
+jsi::Value RNScreensTurboModule::get(
+    jsi::Runtime &rt,
+    const jsi::PropNameID &name) {
+  if (name.utf8(rt) == "startTransition") {
+    return jsi::Function::createFromHostFunction(rt, name, 1, startTransition);
+  } else if (name.utf8(rt) == "updateTransition") {
+    return jsi::Function::createFromHostFunction(rt, name, 2, updateTransition);
+  } else if (name.utf8(rt) == "finishTransition") {
+    return jsi::Function::createFromHostFunction(rt, name, 2, finishTransition);
+  } else if (name.utf8(rt) == "disableSwipeBackForTopScreen") {
+    return jsi::Function::createFromHostFunction(
+        rt, name, 1, disableSwipeBackForTopScreen);
+  }
+  return jsi::Value::undefined();
+}
+
+void RNScreensTurboModule::set(
+    jsi::Runtime &,
+    const jsi::PropNameID &,
+    const jsi::Value &){};
+
+std::vector<jsi::PropNameID> RNScreensTurboModule::getPropertyNames(
+    jsi::Runtime &rt) {
+  std::vector<jsi::PropNameID> properties;
+  properties.push_back(jsi::PropNameID::forUtf8(rt, "startTransition"));
+  properties.push_back(jsi::PropNameID::forUtf8(rt, "updateTransition"));
+  properties.push_back(jsi::PropNameID::forUtf8(rt, "finishTransition"));
+  properties.push_back(
+      jsi::PropNameID::forUtf8(rt, "disableSwipeBackForTopScreen"));
+  return properties;
+}
+
+JSI_HOST_FUNCTION(RNScreensTurboModule::startTransition) {
+  if (count < 1) {
+    throw jsi::JSError(
+        rt, "[RNScreens] `startTransition` method requires 1 argument.");
+  }
+  int stackTag = arguments[0].asNumber();
+  auto screenTags = startTransition_(stackTag);
+  jsi::Object screenTagsObject(rt);
+  jsi::Value topScreenTag, belowTopScreenTag, canStartTransition;
+  if (screenTags[0] > -1) {
+    topScreenTag = jsi::Value(screenTags[0]);
+    belowTopScreenTag = jsi::Value(screenTags[1]);
+    canStartTransition = jsi::Value(true);
+  } else {
+    topScreenTag = jsi::Value(-1);
+    belowTopScreenTag = jsi::Value(-1);
+    canStartTransition = jsi::Value(false);
+  }
+  screenTagsObject.setProperty(rt, "topScreenTag", topScreenTag);
+  screenTagsObject.setProperty(rt, "belowTopScreenTag", belowTopScreenTag);
+  screenTagsObject.setProperty(rt, "canStartTransition", canStartTransition);
+  return screenTagsObject;
+}
+
+JSI_HOST_FUNCTION(RNScreensTurboModule::updateTransition) {
+  if (count < 2) {
+    throw jsi::JSError(
+        rt, "[RNScreens] `updateTransition` requires 2 arguments.");
+  }
+  int stackTag = arguments[0].asNumber();
+  double progress = arguments[1].asNumber();
+  updateTransition_(stackTag, progress);
+  return jsi::Value::undefined();
+}
+
+JSI_HOST_FUNCTION(RNScreensTurboModule::finishTransition) {
+  if (count < 2) {
+    throw jsi::JSError(
+        rt, "[RNScreens] `finishTransition` requires 2 arguments.");
+  }
+  int stackTag = arguments[0].asNumber();
+  bool canceled = arguments[1].getBool();
+  finishTransition_(stackTag, canceled);
+  return jsi::Value::undefined();
+}
+
+JSI_HOST_FUNCTION(RNScreensTurboModule::disableSwipeBackForTopScreen) {
+  if (count < 1) {
+    throw jsi::JSError(
+        rt, "[RNScreens] `startTransition` method requires 1 argument.");
+  }
+  int stackTag = arguments[0].asNumber();
+  disableSwipeBackForTopScreen_(stackTag);
+  return jsi::Value::undefined();
+}
+
+} // namespace RNScreens

package/cpp/RNScreensTurboModule.h

@@ -0,0 +1,40 @@
+#include <jsi/jsi.h>
+#include <array>
+
+#define JSI_HOST_FUNCTION(NAME)    \
+  jsi::Value NAME(                 \
+      jsi::Runtime &rt,            \
+      const jsi::Value &thisValue, \
+      const jsi::Value *arguments, \
+      size_t count)
+
+using namespace facebook;
+
+namespace RNScreens {
+
+class RNScreensTurboModule : public jsi::HostObject {
+  static std::function<std::array<int, 2>(int)> startTransition_;
+  static std::function<void(int, double)> updateTransition_;
+  static std::function<void(int, bool)> finishTransition_;
+  static std::function<void(int)> disableSwipeBackForTopScreen_;
+
+ public:
+  static const char MODULE_NAME[];
+
+  RNScreensTurboModule(
+      std::function<std::array<int, 2>(int)> startTransition,
+      std::function<void(int, double)> updateTransition,
+      std::function<void(int, bool)> finishTransition,
+      std::function<void(int)> disableSwipeBackForTopScreen);
+  ~RNScreensTurboModule() override;
+  jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &name) override;
+  void set(jsi::Runtime &, const jsi::PropNameID &, const jsi::Value &)
+      override;
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+  static JSI_HOST_FUNCTION(startTransition);
+  static JSI_HOST_FUNCTION(updateTransition);
+  static JSI_HOST_FUNCTION(finishTransition);
+  static JSI_HOST_FUNCTION(disableSwipeBackForTopScreen);
+};
+
+} // namespace RNScreens

package/gesture-handler/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../lib/commonjs/gesture-handler/index",
+  "module": "../lib/module/gesture-handler/index",
+  "react-native": "../src/gesture-handler/index",
+  "types": "../lib/typescript/gesture-handler/index"
+}

package/ios/RNSConvert.h

@@ -1,11 +1,23 @@
+#import <UIKit/UIKit.h>
 #ifdef RCT_NEW_ARCH_ENABLED
 #import <react/renderer/components/rnscreens/Props.h>
+#endif // RCT_NEW_ARCH_ENABLED
 #import "RNSEnums.h"
 
+#ifdef RCT_NEW_ARCH_ENABLED
 namespace react = facebook::react;
+#endif // RCT_NEW_ARCH_ENABLED
 
 @interface RNSConvert : NSObject
 
+#ifdef RCT_NEW_ARCH_ENABLED
+
++ (UISemanticContentAttribute)UISemanticContentAttributeFromCppEquivalent:
+    (react::RNSScreenStackHeaderConfigDirection)direction;
+
++ (UINavigationItemBackButtonDisplayMode)UINavigationItemBackButtonDisplayModeFromCppEquivalent:
+    (react::RNSScreenStackHeaderConfigBackButtonDisplayMode)backButtonDisplayMode;
+
 + (RNSScreenStackPresentation)RNSScreenStackPresentationFromCppEquivalent:
     (react::RNSScreenStackPresentation)stackPresentation;
 
@@ -19,18 +31,26 @@ namespace react = facebook::react;
 
 + (RNSScreenSwipeDirection)RNSScreenSwipeDirectionFromCppEquivalent:(react::RNSScreenSwipeDirection)swipeDirection;
 
-+ (RNSScreenDetentType)RNSScreenDetentTypeFromAllowedDetents:(react::RNSScreenSheetAllowedDetents)allowedDetents;
-
-+ (RNSScreenDetentType)RNSScreenDetentTypeFromLargestUndimmedDetent:(react::RNSScreenSheetLargestUndimmedDetent)detent;
++ (NSArray<NSNumber *> *)detentFractionsArrayFromVector:(const std::vector<react::Float> &)detents;
 
 + (NSDictionary *)gestureResponseDistanceDictFromCppStruct:
     (const react::RNSScreenGestureResponseDistanceStruct &)gestureResponseDistance;
 
+#if !TARGET_OS_VISION
 + (UITextAutocapitalizationType)UITextAutocapitalizationTypeFromCppEquivalent:
     (react::RNSSearchBarAutoCapitalize)autoCapitalize;
+#endif
 
 + (RNSSearchBarPlacement)RNSScreenSearchBarPlacementFromCppEquivalent:(react::RNSSearchBarPlacement)placement;
 
-@end
++ (NSMutableArray<NSNumber *> *)arrayFromVector:(const std::vector<CGFloat> &)vector;
+
++ (RNSBlurEffectStyle)RNSBlurEffectStyleFromCppEquivalent:(react::RNSScreenStackHeaderConfigBlurEffect)blurEffect;
 
 #endif // RCT_NEW_ARCH_ENABLED
+
+/// This method fails (by assertion) when `blurEffect == RNSBlurEffectStyleNone` which has no counter part in the UIKit
+/// type.
++ (UIBlurEffectStyle)tryConvertRNSBlurEffectStyleToUIBlurEffectStyle:(RNSBlurEffectStyle)blurEffect;
+
+@end

package/ios/RNSConvert.mm

@@ -1,25 +1,59 @@
 #import "RNSConvert.h"
 
-#ifdef RCT_NEW_ARCH_ENABLED
+#ifndef RCT_NEW_ARCH_ENABLED
+#import <React/RCTAssert.h>
+#endif // !RCT_NEW_ARCH_ENABLED
+
 @implementation RNSConvert
 
+#ifdef RCT_NEW_ARCH_ENABLED
++ (UISemanticContentAttribute)UISemanticContentAttributeFromCppEquivalent:
+    (react::RNSScreenStackHeaderConfigDirection)direction
+{
+  switch (direction) {
+    using enum react::RNSScreenStackHeaderConfigDirection;
+
+    case Rtl:
+      return UISemanticContentAttributeForceRightToLeft;
+    case Ltr:
+      return UISemanticContentAttributeForceLeftToRight;
+  }
+}
+
++ (UINavigationItemBackButtonDisplayMode)UINavigationItemBackButtonDisplayModeFromCppEquivalent:
+    (react::RNSScreenStackHeaderConfigBackButtonDisplayMode)backButtonDisplayMode
+{
+  switch (backButtonDisplayMode) {
+    using enum react::RNSScreenStackHeaderConfigBackButtonDisplayMode;
+
+    case Default:
+      return UINavigationItemBackButtonDisplayModeDefault;
+    case Generic:
+      return UINavigationItemBackButtonDisplayModeGeneric;
+    case Minimal:
+      return UINavigationItemBackButtonDisplayModeMinimal;
+  }
+}
+
 + (RNSScreenStackPresentation)RNSScreenStackPresentationFromCppEquivalent:
     (react::RNSScreenStackPresentation)stackPresentation
 {
   switch (stackPresentation) {
-    case react::RNSScreenStackPresentation::Push:
+    using enum react::RNSScreenStackPresentation;
+
+    case Push:
       return RNSScreenStackPresentationPush;
-    case react::RNSScreenStackPresentation::Modal:
+    case Modal:
       return RNSScreenStackPresentationModal;
-    case react::RNSScreenStackPresentation::FullScreenModal:
+    case FullScreenModal:
       return RNSScreenStackPresentationFullScreenModal;
-    case react::RNSScreenStackPresentation::FormSheet:
+    case FormSheet:
       return RNSScreenStackPresentationFormSheet;
-    case react::RNSScreenStackPresentation::ContainedModal:
+    case ContainedModal:
       return RNSScreenStackPresentationContainedModal;
-    case react::RNSScreenStackPresentation::TransparentModal:
+    case TransparentModal:
       return RNSScreenStackPresentationTransparentModal;
-    case react::RNSScreenStackPresentation::ContainedTransparentModal:
+    case ContainedTransparentModal:
       return RNSScreenStackPresentationContainedTransparentModal;
   }
 }
@@ -27,22 +61,27 @@
 + (RNSScreenStackAnimation)RNSScreenStackAnimationFromCppEquivalent:(react::RNSScreenStackAnimation)stackAnimation
 {
   switch (stackAnimation) {
+    using enum react::RNSScreenStackAnimation;
     // these three are intentionally grouped
-    case react::RNSScreenStackAnimation::Slide_from_right:
-    case react::RNSScreenStackAnimation::Slide_from_left:
-    case react::RNSScreenStackAnimation::Default:
+    case Slide_from_right:
+    case Ios_from_right:
+    case Default:
       return RNSScreenStackAnimationDefault;
-    case react::RNSScreenStackAnimation::Flip:
+    // these two are intentionally grouped
+    case Slide_from_left:
+    case Ios_from_left:
+      return RNSScreenStackAnimationSlideFromLeft;
+    case Flip:
       return RNSScreenStackAnimationFlip;
-    case react::RNSScreenStackAnimation::Simple_push:
+    case Simple_push:
       return RNSScreenStackAnimationSimplePush;
-    case react::RNSScreenStackAnimation::None:
+    case None:
       return RNSScreenStackAnimationNone;
-    case react::RNSScreenStackAnimation::Fade:
+    case Fade:
       return RNSScreenStackAnimationFade;
-    case react::RNSScreenStackAnimation::Slide_from_bottom:
+    case Slide_from_bottom:
       return RNSScreenStackAnimationSlideFromBottom;
-    case react::RNSScreenStackAnimation::Fade_from_bottom:
+    case Fade_from_bottom:
       return RNSScreenStackAnimationFadeFromBottom;
   }
 }
@@ -51,17 +90,19 @@
     (react::RNSScreenStackHeaderSubviewType)subviewType
 {
   switch (subviewType) {
-    case react::RNSScreenStackHeaderSubviewType::Left:
+    using enum react::RNSScreenStackHeaderSubviewType;
+
+    case Left:
       return RNSScreenStackHeaderSubviewTypeLeft;
-    case react::RNSScreenStackHeaderSubviewType::Right:
+    case Right:
       return RNSScreenStackHeaderSubviewTypeRight;
-    case react::RNSScreenStackHeaderSubviewType::Title:
+    case Title:
       return RNSScreenStackHeaderSubviewTypeTitle;
-    case react::RNSScreenStackHeaderSubviewType::Center:
+    case Center:
       return RNSScreenStackHeaderSubviewTypeCenter;
-    case react::RNSScreenStackHeaderSubviewType::SearchBar:
+    case SearchBar:
       return RNSScreenStackHeaderSubviewTypeSearchBar;
-    case react::RNSScreenStackHeaderSubviewType::Back:
+    case Back:
       return RNSScreenStackHeaderSubviewTypeBackButton;
   }
 }
@@ -70,9 +111,10 @@
     (react::RNSScreenReplaceAnimation)replaceAnimation
 {
   switch (replaceAnimation) {
-    case react::RNSScreenReplaceAnimation::Pop:
+    using enum react::RNSScreenReplaceAnimation;
+    case Pop:
       return RNSScreenReplaceAnimationPop;
-    case react::RNSScreenReplaceAnimation::Push:
+    case Push:
       return RNSScreenReplaceAnimationPush;
   }
 }
@@ -80,35 +122,21 @@
 + (RNSScreenSwipeDirection)RNSScreenSwipeDirectionFromCppEquivalent:(react::RNSScreenSwipeDirection)swipeDirection
 {
   switch (swipeDirection) {
-    case react::RNSScreenSwipeDirection::Horizontal:
+    using enum react::RNSScreenSwipeDirection;
+    case Horizontal:
       return RNSScreenSwipeDirectionHorizontal;
-    case react::RNSScreenSwipeDirection::Vertical:
+    case Vertical:
       return RNSScreenSwipeDirectionVertical;
   }
 }
 
-+ (RNSScreenDetentType)RNSScreenDetentTypeFromAllowedDetents:(react::RNSScreenSheetAllowedDetents)allowedDetents
-{
-  switch (allowedDetents) {
-    case react::RNSScreenSheetAllowedDetents::All:
-      return RNSScreenDetentTypeAll;
-    case react::RNSScreenSheetAllowedDetents::Large:
-      return RNSScreenDetentTypeLarge;
-    case react::RNSScreenSheetAllowedDetents::Medium:
-      return RNSScreenDetentTypeMedium;
-  }
-}
-
-+ (RNSScreenDetentType)RNSScreenDetentTypeFromLargestUndimmedDetent:(react::RNSScreenSheetLargestUndimmedDetent)detent
++ (NSArray<NSNumber *> *)detentFractionsArrayFromVector:(const std::vector<react::Float> &)detents
 {
-  switch (detent) {
-    case react::RNSScreenSheetLargestUndimmedDetent::All:
-      return RNSScreenDetentTypeAll;
-    case react::RNSScreenSheetLargestUndimmedDetent::Large:
-      return RNSScreenDetentTypeLarge;
-    case react::RNSScreenSheetLargestUndimmedDetent::Medium:
-      return RNSScreenDetentTypeMedium;
+  auto array = [NSMutableArray<NSNumber *> arrayWithCapacity:detents.size()];
+  for (const react::Float value : detents) {
+    [array addObject:[NSNumber numberWithFloat:value]];
   }
+  return array;
 }
 
 + (NSDictionary *)gestureResponseDistanceDictFromCppStruct:
@@ -122,33 +150,130 @@
   };
 }
 
+#if !TARGET_OS_VISION
 + (UITextAutocapitalizationType)UITextAutocapitalizationTypeFromCppEquivalent:
     (react::RNSSearchBarAutoCapitalize)autoCapitalize
 {
   switch (autoCapitalize) {
-    case react::RNSSearchBarAutoCapitalize::Words:
+    using enum react::RNSSearchBarAutoCapitalize;
+    case Words:
       return UITextAutocapitalizationTypeWords;
-    case react::RNSSearchBarAutoCapitalize::Sentences:
+    case Sentences:
       return UITextAutocapitalizationTypeSentences;
-    case react::RNSSearchBarAutoCapitalize::Characters:
+    case Characters:
       return UITextAutocapitalizationTypeAllCharacters;
-    case react::RNSSearchBarAutoCapitalize::None:
+    case None:
       return UITextAutocapitalizationTypeNone;
   }
 }
+#endif
 
 + (RNSSearchBarPlacement)RNSScreenSearchBarPlacementFromCppEquivalent:(react::RNSSearchBarPlacement)placement
 {
   switch (placement) {
-    case react::RNSSearchBarPlacement::Stacked:
+    using enum react::RNSSearchBarPlacement;
+    case Stacked:
       return RNSSearchBarPlacementStacked;
-    case react::RNSSearchBarPlacement::Automatic:
+    case Automatic:
       return RNSSearchBarPlacementAutomatic;
-    case react::RNSSearchBarPlacement::Inline:
+    case Inline:
       return RNSSearchBarPlacementInline;
   }
 }
 
-@end
++ (NSMutableArray<NSNumber *> *)arrayFromVector:(const std::vector<CGFloat> &)vector
+{
+  NSMutableArray *array = [NSMutableArray arrayWithCapacity:vector.size()];
+  for (CGFloat val : vector) {
+    [array addObject:[NSNumber numberWithFloat:val]];
+  }
+  return array;
+}
+
++ (RNSBlurEffectStyle)RNSBlurEffectStyleFromCppEquivalent:(react::RNSScreenStackHeaderConfigBlurEffect)blurEffect
+{
+  using enum react::RNSScreenStackHeaderConfigBlurEffect;
+#if !TARGET_OS_TV && defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_13_0) && \
+    __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_13_0
+  if (@available(iOS 13.0, *)) {
+    switch (blurEffect) {
+      case None:
+        return RNSBlurEffectStyleNone;
+      case ExtraLight:
+        return RNSBlurEffectStyleExtraLight;
+      case Light:
+        return RNSBlurEffectStyleLight;
+      case Dark:
+        return RNSBlurEffectStyleDark;
+      case Regular:
+        return RNSBlurEffectStyleRegular;
+      case Prominent:
+        return RNSBlurEffectStyleProminent;
+      case SystemUltraThinMaterial:
+        return RNSBlurEffectStyleSystemUltraThinMaterial;
+      case SystemThinMaterial:
+        return RNSBlurEffectStyleSystemThinMaterial;
+      case SystemMaterial:
+        return RNSBlurEffectStyleSystemMaterial;
+      case SystemThickMaterial:
+        return RNSBlurEffectStyleSystemThickMaterial;
+      case SystemChromeMaterial:
+        return RNSBlurEffectStyleSystemChromeMaterial;
+      case SystemUltraThinMaterialLight:
+        return RNSBlurEffectStyleSystemUltraThinMaterialLight;
+      case SystemThinMaterialLight:
+        return RNSBlurEffectStyleSystemThinMaterialLight;
+      case SystemMaterialLight:
+        return RNSBlurEffectStyleSystemMaterialLight;
+      case SystemThickMaterialLight:
+        return RNSBlurEffectStyleSystemThickMaterialLight;
+      case SystemChromeMaterialLight:
+        return RNSBlurEffectStyleSystemChromeMaterialLight;
+      case SystemUltraThinMaterialDark:
+        return RNSBlurEffectStyleSystemUltraThinMaterialDark;
+      case SystemThinMaterialDark:
+        return RNSBlurEffectStyleSystemThinMaterialDark;
+      case SystemMaterialDark:
+        return RNSBlurEffectStyleSystemMaterialDark;
+      case SystemThickMaterialDark:
+        return RNSBlurEffectStyleSystemThickMaterialDark;
+      case SystemChromeMaterialDark:
+        return RNSBlurEffectStyleSystemChromeMaterialDark;
+    }
+  }
+#endif
+
+  switch (blurEffect) {
+    case None:
+      return RNSBlurEffectStyleNone;
+    case Light:
+      return RNSBlurEffectStyleLight;
+    case Dark:
+      return RNSBlurEffectStyleDark;
+    case Regular:
+      return RNSBlurEffectStyleRegular;
+    case Prominent:
+      return RNSBlurEffectStyleProminent;
+    case ExtraLight:
+    default:
+      return RNSBlurEffectStyleNone;
+  }
+}
+
+#endif // RCT_NEW_ARCH_ENABLED
 
++ (UIBlurEffectStyle)tryConvertRNSBlurEffectStyleToUIBlurEffectStyle:(RNSBlurEffectStyle)blurEffect
+{
+#ifdef RCT_NEW_ARCH_ENABLED
+  react_native_assert(blurEffect != RNSBlurEffectStyleNone);
+#else
+  RCTAssert(
+      blurEffect != RNSBlurEffectStyleNone, @"RNSBlurEffectStyleNone variant is not convertible to UIBlurEffectStyle");
 #endif // RCT_NEW_ARCH_ENABLED
+
+  // Cast safety: RNSBlurEffectStyle is defined in such way that its values map 1:1 with
+  // UIBlurEffectStyle, except RNSBlurEffectStyleNone which is excluded above.
+  return (UIBlurEffectStyle)blurEffect;
+}
+
+@end