@amazon-devices/react-native-safe-area-context 2.0.1758683737 → 8.0.9000000000

package/ios/RNCSafeAreaContext.h

@@ -0,0 +1,9 @@
+#import <React/RCTBridgeModule.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNCSafeAreaContext : NSObject <RCTBridgeModule>
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/RNCSafeAreaContext.mm

@@ -0,0 +1,85 @@
+#import "RNCSafeAreaContext.h"
+
+#import <React/RCTUtils.h>
+#if TARGET_OS_IPHONE
+#import <UIKit/UIKit.h>
+#elif TARGET_OS_OSX
+#import <AppKit/AppKit.h>
+#endif
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <safeareacontext/safeareacontext.h>
+#endif
+
+#ifdef RCT_NEW_ARCH_ENABLED
+using namespace facebook::react;
+
+@interface RNCSafeAreaContext () <NativeSafeAreaContextSpec>
+@end
+#endif
+
+@implementation RNCSafeAreaContext
+
+RCT_EXPORT_MODULE()
+
++ (BOOL)requiresMainQueueSetup
+{
+  return YES;
+}
+
+- (NSDictionary *)constantsToExport
+{
+  return [self getConstants];
+}
+
+- (NSDictionary *)getConstants
+{
+  __block NSDictionary *constants;
+
+  RCTUnsafeExecuteOnMainQueueSync(^{
+#if TARGET_OS_IPHONE
+    UIWindow *window = RCTKeyWindow();
+#elif TARGET_OS_OSX
+    NSWindow *window = RCTKeyWindow();
+#endif
+    if (window == nil) {
+      constants = @{@"initialWindowMetrics" : [NSNull null]};
+      return;
+    }
+
+#if TARGET_OS_IPHONE
+    UIEdgeInsets safeAreaInsets = window.safeAreaInsets;
+#elif TARGET_OS_OSX
+    NSEdgeInsets safeAreaInsets = NSEdgeInsetsZero;
+#endif
+
+    constants = @{
+      @"initialWindowMetrics" : @{
+        @"insets" : @{
+          @"top" : @(safeAreaInsets.top),
+          @"right" : @(safeAreaInsets.right),
+          @"bottom" : @(safeAreaInsets.bottom),
+          @"left" : @(safeAreaInsets.left),
+        },
+        @"frame" : @{
+          @"x" : @(window.frame.origin.x),
+          @"y" : @(window.frame.origin.y),
+          @"width" : @(window.frame.size.width),
+          @"height" : @(window.frame.size.height),
+        },
+      }
+    };
+  });
+
+  return constants;
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+- (std::shared_ptr<TurboModule>)getTurboModule:(const ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<NativeSafeAreaContextSpecJSI>(params);
+}
+
+#endif
+
+@end

package/ios/{SafeAreaView/RNCSafeAreaProvider.h → RNCSafeAreaProvider.h}

@@ -1,4 +1,8 @@
+#if TARGET_OS_IPHONE
 #import <UIKit/UIKit.h>
+#elif TARGET_OS_OSX
+#import <AppKit/AppKit.h>
+#endif
 
 #import <React/RCTView.h>
 

package/ios/RNCSafeAreaProvider.m

@@ -0,0 +1,102 @@
+#import "RNCSafeAreaProvider.h"
+
+#import <React/RCTBridge.h>
+#import <React/RCTUIManager.h>
+#import "RNCSafeAreaUtils.h"
+
+@implementation RNCSafeAreaProvider {
+  UIEdgeInsets _currentSafeAreaInsets;
+  CGRect _currentFrame;
+  BOOL _initialInsetsSent;
+}
+
+- (instancetype)init
+{
+  if ((self = [super init])) {
+#if !TARGET_OS_TV && !TARGET_OS_OSX
+    [NSNotificationCenter.defaultCenter addObserver:self
+                                           selector:@selector(invalidateSafeAreaInsets)
+                                               name:UIKeyboardDidShowNotification
+                                             object:nil];
+    [NSNotificationCenter.defaultCenter addObserver:self
+                                           selector:@selector(invalidateSafeAreaInsets)
+                                               name:UIKeyboardDidHideNotification
+                                             object:nil];
+    [NSNotificationCenter.defaultCenter addObserver:self
+                                           selector:@selector(invalidateSafeAreaInsets)
+                                               name:UIKeyboardDidChangeFrameNotification
+                                             object:nil];
+    [NSNotificationCenter.defaultCenter addObserver:self
+                                           selector:@selector(invalidateSafeAreaInsets)
+                                               name:UIWindowDidBecomeVisibleNotification
+                                             object:nil];
+#endif
+  }
+  return self;
+}
+
+- (void)safeAreaInsetsDidChange
+{
+  [self invalidateSafeAreaInsets];
+}
+
+- (void)invalidateSafeAreaInsets
+{
+  // This gets called before the view size is set by react-native so
+  // make sure to wait so we don't set wrong insets to JS.
+  if (CGSizeEqualToSize(self.frame.size, CGSizeZero)) {
+    return;
+  }
+
+#if TARGET_OS_IPHONE
+  UIEdgeInsets safeAreaInsets = self.safeAreaInsets;
+#elif TARGET_OS_OSX
+  NSEdgeInsets safeAreaInsets;
+  if (@available(macOS 11.0, *)) {
+    safeAreaInsets = self.safeAreaInsets;
+  } else {
+    safeAreaInsets = NSEdgeInsetsZero;
+  }
+#endif
+  CGRect frame = [self convertRect:self.bounds toView:RNCParentViewController(self).view];
+
+  if (_initialInsetsSent &&
+#if TARGET_OS_IPHONE
+      UIEdgeInsetsEqualToEdgeInsetsWithThreshold(safeAreaInsets, _currentSafeAreaInsets, 1.0 / RCTScreenScale()) &&
+#elif TARGET_OS_OSX
+      NSEdgeInsetsEqualToEdgeInsetsWithThreshold(safeAreaInsets, _currentSafeAreaInsets, 1.0 / RCTScreenScale()) &&
+#endif
+      CGRectEqualToRect(frame, _currentFrame)) {
+    return;
+  }
+
+  _initialInsetsSent = YES;
+  _currentSafeAreaInsets = safeAreaInsets;
+  _currentFrame = frame;
+
+  [NSNotificationCenter.defaultCenter postNotificationName:RNCSafeAreaDidChange object:self userInfo:nil];
+
+  self.onInsetsChange(@{
+    @"insets" : @{
+      @"top" : @(safeAreaInsets.top),
+      @"right" : @(safeAreaInsets.right),
+      @"bottom" : @(safeAreaInsets.bottom),
+      @"left" : @(safeAreaInsets.left),
+    },
+    @"frame" : @{
+      @"x" : @(frame.origin.x),
+      @"y" : @(frame.origin.y),
+      @"width" : @(frame.size.width),
+      @"height" : @(frame.size.height),
+    },
+  });
+}
+
+- (void)layoutSubviews
+{
+  [super layoutSubviews];
+
+  [self invalidateSafeAreaInsets];
+}
+
+@end

package/ios/RNCSafeAreaProviderManager.m

@@ -0,0 +1,20 @@
+#import "RNCSafeAreaProviderManager.h"
+
+#import "RNCSafeAreaProvider.h"
+
+@implementation RNCSafeAreaProviderManager
+
+RCT_EXPORT_MODULE(RNCSafeAreaProvider)
+
+RCT_EXPORT_VIEW_PROPERTY(onInsetsChange, RCTDirectEventBlock)
+
+#if TARGET_OS_IPHONE
+- (UIView *)view
+#elif TARGET_OS_OSX
+- (NSView *)view
+#endif
+{
+  return [RNCSafeAreaProvider new];
+}
+
+@end

package/ios/{SafeAreaView/RNCSafeAreaShadowView.m → RNCSafeAreaShadowView.m}

@@ -3,9 +3,10 @@
 #import <React/RCTAssert.h>
 #include <math.h>
 
+#import "RNCSafeAreaViewEdgeMode.h"
+#import "RNCSafeAreaViewEdges.h"
 #import "RNCSafeAreaViewLocalData.h"
 #import "RNCSafeAreaViewMode.h"
-#import "RNCSafeAreaViewEdges.h"
 
 // From RCTShadowView.m
 typedef NS_ENUM(unsigned int, meta_prop_t) {
@@ -39,7 +40,11 @@ typedef NS_ENUM(unsigned int, meta_prop_t) {
   return self;
 }
 
-- (void)extractEdges:(YGValue[])_metaProps top:(CGFloat *)top right:(CGFloat *)right bottom:(CGFloat *)bottom left:(CGFloat *)left
+- (void)extractEdges:(YGValue[])_metaProps
+                 top:(CGFloat *)top
+               right:(CGFloat *)right
+              bottom:(CGFloat *)bottom
+                left:(CGFloat *)left
 {
   if (_metaProps[META_PROP_ALL].unit == YGUnitPoint) {
     *top = _metaProps[META_PROP_ALL].value;
@@ -61,7 +66,7 @@ typedef NS_ENUM(unsigned int, meta_prop_t) {
   if (_metaProps[META_PROP_TOP].unit == YGUnitPoint) {
     *top = _metaProps[META_PROP_TOP].value;
   }
-    
+
   if (_metaProps[META_PROP_RIGHT].unit == YGUnitPoint) {
     *right = _metaProps[META_PROP_RIGHT].value;
   }
@@ -75,7 +80,8 @@ typedef NS_ENUM(unsigned int, meta_prop_t) {
   }
 }
 
-- (void)resetInsetsForMode:(RNCSafeAreaViewMode)mode {
+- (void)resetInsetsForMode:(RNCSafeAreaViewMode)mode
+{
   if (mode == RNCSafeAreaViewModePadding) {
     super.paddingTop = _paddingMetaProps[META_PROP_TOP];
     super.paddingRight = _paddingMetaProps[META_PROP_RIGHT];
@@ -104,23 +110,32 @@ typedef NS_ENUM(unsigned int, meta_prop_t) {
   CGFloat bottom = 0;
   CGFloat left = 0;
 
-  CGFloat insetTop = (edges & RNCSafeAreaViewEdgesTop) ? insets.top : 0;
-  CGFloat insetRight = (edges & RNCSafeAreaViewEdgesRight) ? insets.right : 0;
-  CGFloat insetBottom = (edges & RNCSafeAreaViewEdgesBottom) ? insets.bottom : 0;
-  CGFloat insetLeft = (edges & RNCSafeAreaViewEdgesLeft) ? insets.left : 0;
-
   if (mode == RNCSafeAreaViewModePadding) {
     [self extractEdges:_paddingMetaProps top:&top right:&right bottom:&bottom left:&left];
-    super.paddingTop = (YGValue){insetTop + top, YGUnitPoint};
-    super.paddingRight = (YGValue){insetRight + right, YGUnitPoint};
-    super.paddingBottom = (YGValue){insetBottom + bottom, YGUnitPoint};
-    super.paddingLeft = (YGValue){insetLeft + left, YGUnitPoint};
+    super.paddingTop = (YGValue){[self getEdgeValue:edges.top insetValue:insets.top edgeValue:top], YGUnitPoint};
+    super.paddingRight =
+        (YGValue){[self getEdgeValue:edges.right insetValue:insets.right edgeValue:right], YGUnitPoint};
+    super.paddingBottom =
+        (YGValue){[self getEdgeValue:edges.bottom insetValue:insets.bottom edgeValue:bottom], YGUnitPoint};
+    super.paddingLeft = (YGValue){[self getEdgeValue:edges.left insetValue:insets.left edgeValue:left], YGUnitPoint};
   } else if (mode == RNCSafeAreaViewModeMargin) {
     [self extractEdges:_marginMetaProps top:&top right:&right bottom:&bottom left:&left];
-    super.marginTop = (YGValue){insetTop + top, YGUnitPoint};
-    super.marginRight = (YGValue){insetRight + right, YGUnitPoint};
-    super.marginBottom = (YGValue){insetBottom + bottom, YGUnitPoint};
-    super.marginLeft = (YGValue){insetLeft + left, YGUnitPoint};
+    super.marginTop = (YGValue){[self getEdgeValue:edges.top insetValue:insets.top edgeValue:top], YGUnitPoint};
+    super.marginRight = (YGValue){[self getEdgeValue:edges.right insetValue:insets.right edgeValue:right], YGUnitPoint};
+    super.marginBottom =
+        (YGValue){[self getEdgeValue:edges.bottom insetValue:insets.bottom edgeValue:bottom], YGUnitPoint};
+    super.marginLeft = (YGValue){[self getEdgeValue:edges.left insetValue:insets.left edgeValue:left], YGUnitPoint};
+  }
+}
+
+- (CGFloat)getEdgeValue:(RNCSafeAreaViewEdgeMode)edgeMode insetValue:(CGFloat)insetValue edgeValue:(CGFloat)edgeValue
+{
+  if (edgeMode == RNCSafeAreaViewEdgeModeOff) {
+    return edgeValue;
+  } else if (edgeMode == RNCSafeAreaViewEdgeModeMaximum) {
+    return MAX(insetValue, edgeValue);
+  } else {
+    return insetValue + edgeValue;
   }
 }
 
@@ -136,38 +151,37 @@ typedef NS_ENUM(unsigned int, meta_prop_t) {
 - (void)setLocalData:(RNCSafeAreaViewLocalData *)localData
 {
   RCTAssert(
-    [localData isKindOfClass:[RNCSafeAreaViewLocalData class]],
-    @"Local data object for `RCTRNCSafeAreaShadowView` must be `RCTRNCSafeAreaViewLocalData` instance."
-  );
+      [localData isKindOfClass:[RNCSafeAreaViewLocalData class]],
+      @"Local data object for `RCTRNCSafeAreaShadowView` must be `RCTRNCSafeAreaViewLocalData` instance.");
 
   if (_localData != nil && _localData.mode != localData.mode) {
     [self resetInsetsForMode:_localData.mode];
   }
-  
+
   _localData = localData;
   _needsUpdate = false;
   [self updateInsets];
-  
+
   if (_localData.mode == RNCSafeAreaViewModePadding) {
-    [super didSetProps:@[@"paddingTop", @"paddingRight", @"paddingBottom", @"paddingLeft"]];
+    [super didSetProps:@[ @"paddingTop", @"paddingRight", @"paddingBottom", @"paddingLeft" ]];
   } else {
-    [super didSetProps:@[@"marginTop", @"marginRight", @"marginBottom", @"marginLeft"]];
+    [super didSetProps:@[ @"marginTop", @"marginRight", @"marginBottom", @"marginLeft" ]];
   }
 }
 
 #define SHADOW_VIEW_MARGIN_PADDING_PROP(edge, metaProp) \
-- (void)setPadding##edge:(YGValue)value                 \
-{                                                       \
-  [super setPadding##edge:value];                       \
-  _needsUpdate = true;                                  \
-  _paddingMetaProps[META_PROP_##metaProp] = value;      \
-}                                                       \
-- (void)setMargin##edge:(YGValue)value                  \
-{                                                       \
-  [super setMargin##edge:value];                        \
-  _needsUpdate = true;                                  \
-  _marginMetaProps[META_PROP_##metaProp] = value;       \
-}
+  -(void)setPadding##edge : (YGValue)value              \
+  {                                                     \
+    [super setPadding##edge:value];                     \
+    _needsUpdate = true;                                \
+    _paddingMetaProps[META_PROP_##metaProp] = value;    \
+  }                                                     \
+  -(void)setMargin##edge : (YGValue)value               \
+  {                                                     \
+    [super setMargin##edge:value];                      \
+    _needsUpdate = true;                                \
+    _marginMetaProps[META_PROP_##metaProp] = value;     \
+  }
 
 SHADOW_VIEW_MARGIN_PADDING_PROP(, ALL);
 SHADOW_VIEW_MARGIN_PADDING_PROP(Vertical, VERTICAL);

package/ios/RNCSafeAreaUtils.h

@@ -0,0 +1,22 @@
+#import <React/RCTDefines.h>
+#import <React/RCTView.h>
+#if TARGET_OS_IPHONE
+#import <UIKit/UIKit.h>
+#elif TARGET_OS_OSX
+#import <AppKit/AppKit.h>
+#endif
+
+extern NSString *const RNCSafeAreaDidChange;
+
+RCT_EXTERN BOOL
+#if TARGET_OS_IPHONE
+UIEdgeInsetsEqualToEdgeInsetsWithThreshold(UIEdgeInsets insets1, UIEdgeInsets insets2, CGFloat threshold);
+#elif TARGET_OS_OSX
+NSEdgeInsetsEqualToEdgeInsetsWithThreshold(NSEdgeInsets insets1, NSEdgeInsets insets2, CGFloat threshold);
+#endif
+
+#if TARGET_OS_IPHONE
+RCT_EXTERN UIViewController *RNCParentViewController(UIView *view);
+#elif TARGET_OS_OSX
+RCT_EXTERN NSViewController *RNCParentViewController(NSView *view);
+#endif

package/ios/RNCSafeAreaUtils.m

@@ -0,0 +1,41 @@
+#import "RNCSafeAreaUtils.h"
+
+#import <React/RCTUIManager.h>
+
+NSString *const RNCSafeAreaDidChange = @"RNCSafeAreaDidChange";
+
+#if TARGET_OS_IPHONE
+BOOL UIEdgeInsetsEqualToEdgeInsetsWithThreshold(UIEdgeInsets insets1, UIEdgeInsets insets2, CGFloat threshold)
+#elif TARGET_OS_OSX
+BOOL NSEdgeInsetsEqualToEdgeInsetsWithThreshold(NSEdgeInsets insets1, NSEdgeInsets insets2, CGFloat threshold)
+#endif
+{
+  return ABS(insets1.left - insets2.left) <= threshold && ABS(insets1.right - insets2.right) <= threshold &&
+      ABS(insets1.top - insets2.top) <= threshold && ABS(insets1.bottom - insets2.bottom) <= threshold;
+}
+
+#if TARGET_OS_IPHONE
+UIViewController *RNCParentViewController(UIView *view)
+{
+  UIResponder *responder = view.nextResponder;
+  while (responder != nil) {
+    if ([responder isKindOfClass:[UIViewController class]]) {
+      return (UIViewController *)responder;
+    }
+    responder = responder.nextResponder;
+  }
+  return nil;
+}
+#elif TARGET_OS_OSX
+NSViewController *RNCParentViewController(NSView *view)
+{
+  NSResponder *responder = view.nextResponder;
+  while (responder != nil) {
+    if ([responder isKindOfClass:[NSViewController class]]) {
+      return (NSViewController *)responder;
+    }
+    responder = responder.nextResponder;
+  }
+  return nil;
+}
+#endif

package/ios/{SafeAreaView/RNCSafeAreaView.h → RNCSafeAreaView.h}

@@ -1,15 +1,19 @@
-#import <UIKit/UIKit.h>
-#import <React/RCTView.h>
 #import <React/RCTBridge.h>
+#import <React/RCTView.h>
+#if TARGET_OS_IPHONE
+#import <UIKit/UIKit.h>
+#elif TARGET_OS_OSX
+#import <AppKit/AppKit.h>
+#endif
 
-#import "RNCSafeAreaViewMode.h"
 #import "RNCSafeAreaViewEdges.h"
+#import "RNCSafeAreaViewMode.h"
 
 NS_ASSUME_NONNULL_BEGIN
 
 @class RNCSafeAreaView;
 
-@interface RNCSafeAreaView: RCTView
+@interface RNCSafeAreaView : RCTView
 
 - (instancetype)initWithBridge:(RCTBridge *)bridge;
 

package/ios/RNCSafeAreaView.m

@@ -0,0 +1,168 @@
+#import "RNCSafeAreaView.h"
+
+#import <React/RCTBridge.h>
+#import <React/RCTUIManager.h>
+
+#import "RNCSafeAreaProvider.h"
+#import "RNCSafeAreaUtils.h"
+#import "RNCSafeAreaViewEdges.h"
+#import "RNCSafeAreaViewLocalData.h"
+#import "RNCSafeAreaViewMode.h"
+
+@implementation RNCSafeAreaView {
+  __weak RCTBridge *_bridge;
+#if TARGET_OS_IPHONE
+  UIEdgeInsets _currentSafeAreaInsets;
+#elif TARGET_OS_OSX
+  NSEdgeInsets _currentSafeAreaInsets;
+#endif
+  RNCSafeAreaViewMode _mode;
+  RNCSafeAreaViewEdges _edges;
+  __weak RNCSafeAreaProvider *_Nullable _providerView;
+}
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+{
+  if (self = [super initWithFrame:CGRectZero]) {
+    _bridge = bridge;
+    // Defaults
+    _mode = RNCSafeAreaViewModePadding;
+    _edges = RNCSafeAreaViewEdgesMake(
+        RNCSafeAreaViewEdgeModeOff, RNCSafeAreaViewEdgeModeOff, RNCSafeAreaViewEdgeModeOff, RNCSafeAreaViewEdgeModeOff);
+  }
+
+  return self;
+}
+
+RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : (NSCoder *)decoder)
+RCT_NOT_IMPLEMENTED(-(instancetype)initWithFrame : (CGRect)frame)
+
+- (NSString *)description
+{
+  NSString *superDescription = [super description];
+
+  // Cutting the last `>` character.
+  if (superDescription.length > 0 && [superDescription characterAtIndex:superDescription.length - 1] == '>') {
+    superDescription = [superDescription substringToIndex:superDescription.length - 1];
+  }
+
+#if TARGET_OS_IPHONE
+  NSString *providerViewSafeAreaInsetsString = NSStringFromUIEdgeInsets(_providerView.safeAreaInsets);
+  NSString *currentSafeAreaInsetsString = NSStringFromUIEdgeInsets(_currentSafeAreaInsets);
+#elif TARGET_OS_OSX
+  NSString *providerViewSafeAreaInsetsString;
+  NSString *currentSafeAreaInsetsString;
+  if (@available(macOS 11.0, *)) {
+    providerViewSafeAreaInsetsString = [NSString stringWithFormat:@"{%f,%f,%f,%f}",
+                                                                  _providerView.safeAreaInsets.top,
+                                                                  _providerView.safeAreaInsets.left,
+                                                                  _providerView.safeAreaInsets.bottom,
+                                                                  _providerView.safeAreaInsets.right];
+    currentSafeAreaInsetsString = [NSString stringWithFormat:@"{%f,%f,%f,%f}",
+                                                             _currentSafeAreaInsets.top,
+                                                             _currentSafeAreaInsets.left,
+                                                             _currentSafeAreaInsets.bottom,
+                                                             _currentSafeAreaInsets.right];
+  } else {
+    providerViewSafeAreaInsetsString = @"{0.0,0.0,0.0,0.0}";
+    currentSafeAreaInsetsString = @"{0.0,0.0,0.0,0.0}";
+  }
+#endif
+
+  return [NSString stringWithFormat:@"%@; RNCSafeAreaInsets = %@; appliedRNCSafeAreaInsets = %@>",
+                                    superDescription,
+                                    providerViewSafeAreaInsetsString,
+                                    currentSafeAreaInsetsString];
+}
+
+- (void)didMoveToWindow
+{
+#if TARGET_OS_IPHONE
+  UIView *previousProviderView = _providerView;
+#elif TARGET_OS_OSX
+  NSView *previousProviderView = _providerView;
+#endif
+  _providerView = [self findNearestProvider];
+
+  [self invalidateSafeAreaInsets];
+
+  if (previousProviderView != _providerView) {
+    if (previousProviderView != nil) {
+      [NSNotificationCenter.defaultCenter removeObserver:self name:RNCSafeAreaDidChange object:previousProviderView];
+    }
+
+    if (_providerView != nil) {
+      [NSNotificationCenter.defaultCenter addObserver:self
+                                             selector:@selector(safeAreaProviderInsetsDidChange:)
+                                                 name:RNCSafeAreaDidChange
+                                               object:_providerView];
+    }
+  }
+}
+
+- (void)safeAreaProviderInsetsDidChange:(NSNotification *)notification
+{
+  [self invalidateSafeAreaInsets];
+}
+
+- (void)invalidateSafeAreaInsets
+{
+  if (_providerView == nil) {
+    return;
+  }
+#if TARGET_OS_IPHONE
+  UIEdgeInsets safeAreaInsets = _providerView.safeAreaInsets;
+  if (UIEdgeInsetsEqualToEdgeInsetsWithThreshold(safeAreaInsets, _currentSafeAreaInsets, 1.0 / RCTScreenScale())) {
+    return;
+  }
+#elif TARGET_OS_OSX
+  NSEdgeInsets safeAreaInsets = _providerView.safeAreaInsets;
+  if (NSEdgeInsetsEqualToEdgeInsetsWithThreshold(safeAreaInsets, _currentSafeAreaInsets, 1.0 / RCTScreenScale())) {
+    return;
+  }
+#endif
+
+  _currentSafeAreaInsets = safeAreaInsets;
+  [self updateLocalData];
+}
+
+- (nullable RNCSafeAreaProvider *)findNearestProvider
+{
+#if TARGET_OS_IPHONE
+  UIView *current = self.reactSuperview;
+#elif TARGET_OS_OSX
+  NSView *current = self.reactSuperview;
+#endif
+  while (current != nil) {
+    if ([current isKindOfClass:RNCSafeAreaProvider.class]) {
+      return (RNCSafeAreaProvider *)current;
+    }
+    current = current.reactSuperview;
+  }
+  return nil;
+}
+
+- (void)updateLocalData
+{
+  if (_providerView == nil) {
+    return;
+  }
+  RNCSafeAreaViewLocalData *localData = [[RNCSafeAreaViewLocalData alloc] initWithInsets:_currentSafeAreaInsets
+                                                                                    mode:_mode
+                                                                                   edges:_edges];
+  [_bridge.uiManager setLocalData:localData forView:self];
+}
+
+- (void)setMode:(RNCSafeAreaViewMode)mode
+{
+  _mode = mode;
+  [self updateLocalData];
+}
+
+- (void)setEdges:(RNCSafeAreaViewEdges)edges
+{
+  _edges = edges;
+  [self updateLocalData];
+}
+
+@end

package/ios/RNCSafeAreaViewEdgeMode.h

@@ -0,0 +1,12 @@
+#import <Foundation/Foundation.h>
+#import <React/RCTConvert.h>
+
+typedef NS_ENUM(NSInteger, RNCSafeAreaViewEdgeMode) {
+  RNCSafeAreaViewEdgeModeOff,
+  RNCSafeAreaViewEdgeModeAdditive,
+  RNCSafeAreaViewEdgeModeMaximum
+};
+
+@interface RCTConvert (RNCSafeAreaViewEdgeMode)
++ (RNCSafeAreaViewEdgeMode)RNCSafeAreaViewEdgeMode:(nullable id)json;
+@end

package/ios/RNCSafeAreaViewEdgeMode.m

@@ -0,0 +1,16 @@
+#import "RNCSafeAreaViewEdgeMode.h"
+#import <React/RCTConvert.h>
+
+@implementation RCTConvert (RNCSafeAreaViewEdgeMode)
+
+RCT_ENUM_CONVERTER(
+    RNCSafeAreaViewEdgeMode,
+    (@{
+      @"off" : @(RNCSafeAreaViewEdgeModeOff),
+      @"additive" : @(RNCSafeAreaViewEdgeModeAdditive),
+      @"maximum" : @(RNCSafeAreaViewEdgeModeMaximum),
+    }),
+    RNCSafeAreaViewEdgeModeOff,
+    integerValue);
+
+@end

package/ios/RNCSafeAreaViewEdges.h

@@ -0,0 +1,15 @@
+#import <Foundation/Foundation.h>
+#import "RNCSafeAreaViewEdgeMode.h"
+
+typedef struct RNCSafeAreaViewEdges {
+  RNCSafeAreaViewEdgeMode top;
+  RNCSafeAreaViewEdgeMode right;
+  RNCSafeAreaViewEdgeMode bottom;
+  RNCSafeAreaViewEdgeMode left;
+} RNCSafeAreaViewEdges;
+
+RNCSafeAreaViewEdges RNCSafeAreaViewEdgesMake(
+    RNCSafeAreaViewEdgeMode top,
+    RNCSafeAreaViewEdgeMode right,
+    RNCSafeAreaViewEdgeMode bottom,
+    RNCSafeAreaViewEdgeMode left);