@lodev09/react-native-true-sheet 3.7.3 → 3.7.4-beta.1

package/ios/TrueSheetViewController.mm

@@ -34,6 +34,7 @@
   BOOL _isDragging;
   BOOL _isTransitioning;
   BOOL _isTrackingPositionFromLayout;
+  BOOL _isWillDismissEmitted;
 
   __weak TrueSheetViewController *_parentSheetController;
 
@@ -57,11 +58,12 @@
     _lastPosition = 0;
     _isDragging = NO;
     _isPresented = NO;
+    _isTransitioning = NO;
+    _isWillDismissEmitted = NO;
     _pendingContentSizeChange = NO;
     _activeDetentIndex = -1;
     _pendingDetentIndex = -1;
 
-    _isTransitioning = NO;
     _transitionFakeView = [UIView new];
     _isTrackingPositionFromLayout = NO;
 
@@ -165,6 +167,9 @@
   [super viewDidLoad];
   self.view.autoresizingMask = UIViewAutoresizingFlexibleHeight | UIViewAutoresizingFlexibleWidth;
 
+  _blurView = [[TrueSheetBlurView alloc] init];
+  [_blurView addToView:self.view];
+
   _grabberView = [[TrueSheetGrabberView alloc] init];
   _grabberView.hidden = YES;
   [_grabberView addToView:self.view];
@@ -181,23 +186,16 @@
     UIViewController *presenter = self.presentingViewController;
     if ([presenter isKindOfClass:[TrueSheetViewController class]]) {
       _parentSheetController = (TrueSheetViewController *)presenter;
-      if ([_parentSheetController.delegate respondsToSelector:@selector(viewControllerWillBlur)]) {
-        [_parentSheetController.delegate viewControllerWillBlur];
-      }
+      [_parentSheetController.delegate viewControllerWillBlur];
     }
 
     dispatch_async(dispatch_get_main_queue(), ^{
-      if ([self.delegate respondsToSelector:@selector(viewControllerWillPresentAtIndex:position:detent:)]) {
-        NSInteger index = self.currentDetentIndex;
-        CGFloat position = self.currentPosition;
-        CGFloat detent = [self detentValueForIndex:index];
-
-        [self.delegate viewControllerWillPresentAtIndex:index position:position detent:detent];
-      }
+      NSInteger index = self.currentDetentIndex;
+      CGFloat position = self.currentPosition;
+      CGFloat detent = [self detentValueForIndex:index];
 
-      if ([self.delegate respondsToSelector:@selector(viewControllerWillFocus)]) {
-        [self.delegate viewControllerWillFocus];
-      }
+      [self.delegate viewControllerWillPresentAtIndex:index position:position detent:detent];
+      [self.delegate viewControllerWillFocus];
     });
   }
 
@@ -208,22 +206,13 @@
   [super viewDidAppear:animated];
 
   if (!_isPresented) {
-    if (_parentSheetController) {
-      if ([_parentSheetController.delegate respondsToSelector:@selector(viewControllerDidBlur)]) {
-        [_parentSheetController.delegate viewControllerDidBlur];
-      }
-    }
+    [_parentSheetController.delegate viewControllerDidBlur];
 
     dispatch_async(dispatch_get_main_queue(), ^{
-      if ([self.delegate respondsToSelector:@selector(viewControllerDidPresentAtIndex:position:detent:)]) {
-        NSInteger index = [self currentDetentIndex];
-        CGFloat detent = [self detentValueForIndex:index];
-        [self.delegate viewControllerDidPresentAtIndex:index position:self.currentPosition detent:detent];
-      }
-
-      if ([self.delegate respondsToSelector:@selector(viewControllerDidFocus)]) {
-        [self.delegate viewControllerDidFocus];
-      }
+      NSInteger index = [self currentDetentIndex];
+      CGFloat detent = [self detentValueForIndex:index];
+      [self.delegate viewControllerDidPresentAtIndex:index position:self.currentPosition detent:detent];
+      [self.delegate viewControllerDidFocus];
 
       [self emitChangePositionDelegateWithPosition:self.currentPosition realtime:NO debug:@"did present"];
     });
@@ -237,52 +226,46 @@
   return self.presentingViewController == nil || self.isBeingDismissed;
 }
 
-- (void)viewWillDisappear:(BOOL)animated {
-  [super viewWillDisappear:animated];
+- (void)emitWillDismissEvents {
+  if (self.isDismissing && !_isWillDismissEmitted) {
+    _isWillDismissEmitted = YES;
 
+    [self.delegate viewControllerWillBlur];
+    [self.delegate viewControllerWillDismiss];
+    [_parentSheetController.delegate viewControllerWillFocus];
+  }
+}
+
+- (void)emitDidDismissEvents {
   if (self.isDismissing) {
-    dispatch_async(dispatch_get_main_queue(), ^{
-      if ([self.delegate respondsToSelector:@selector(viewControllerWillBlur)]) {
-        [self.delegate viewControllerWillBlur];
-      }
+    _isPresented = NO;
+    _isWillDismissEmitted = NO;
 
-      if ([self.delegate respondsToSelector:@selector(viewControllerWillDismiss)]) {
-        [self.delegate viewControllerWillDismiss];
-      }
-    });
+    [_parentSheetController.delegate viewControllerDidFocus];
+    _parentSheetController = nil;
 
-    if (_parentSheetController) {
-      if ([_parentSheetController.delegate respondsToSelector:@selector(viewControllerWillFocus)]) {
-        [_parentSheetController.delegate viewControllerWillFocus];
-      }
-    }
+    [self.delegate viewControllerDidBlur];
+    [self.delegate viewControllerDidDismiss];
   }
-
-  [self setupTransitionTracker];
 }
 
-- (void)viewDidDisappear:(BOOL)animated {
-  [super viewDidDisappear:animated];
-
-  if (self.isDismissing) {
-    _isPresented = NO;
-    _activeDetentIndex = -1;
+- (void)viewWillDisappear:(BOOL)animated {
+  [super viewWillDisappear:animated];
 
-    if (_parentSheetController) {
-      if ([_parentSheetController.delegate respondsToSelector:@selector(viewControllerDidFocus)]) {
-        [_parentSheetController.delegate viewControllerDidFocus];
-      }
-      _parentSheetController = nil;
+  // Dispatch to allow pan gesture to set _isDragging before checking
+  // handleTransitionTracker will emit when sheet is transitioning to dismiss
+  dispatch_async(dispatch_get_main_queue(), ^{
+    if (!self->_isDragging) {
+      [self emitWillDismissEvents];
     }
+  });
 
-    if ([self.delegate respondsToSelector:@selector(viewControllerDidBlur)]) {
-      [self.delegate viewControllerDidBlur];
-    }
+  [self setupTransitionTracker];
+}
 
-    if ([self.delegate respondsToSelector:@selector(viewControllerDidDismiss)]) {
-      [self.delegate viewControllerDidDismiss];
-    }
-  }
+- (void)viewDidDisappear:(BOOL)animated {
+  [super viewDidDisappear:animated];
+  [self emitDidDismissEvents];
 }
 
 - (void)viewWillLayoutSubviews {
@@ -309,21 +292,17 @@
 - (void)viewDidLayoutSubviews {
   [super viewDidLayoutSubviews];
 
-  if ([self.delegate respondsToSelector:@selector(viewControllerDidChangeSize:)]) {
-    [self.delegate viewControllerDidChangeSize:self.view.frame.size];
-  }
+  [self.delegate viewControllerDidChangeSize:self.view.frame.size];
 
   if (_pendingDetentIndex >= 0) {
     NSInteger pendingIndex = _pendingDetentIndex;
     _pendingDetentIndex = -1;
 
     dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
-      if ([self.delegate respondsToSelector:@selector(viewControllerDidChangeDetent:position:detent:)]) {
-        [self storeResolvedPositionForIndex:pendingIndex];
-        CGFloat detent = [self detentValueForIndex:pendingIndex];
-        [self.delegate viewControllerDidChangeDetent:pendingIndex position:self.currentPosition detent:detent];
-        [self emitChangePositionDelegateWithPosition:self.currentPosition realtime:NO debug:@"pending detent change"];
-      }
+      [self storeResolvedPositionForIndex:pendingIndex];
+      CGFloat detent = [self detentValueForIndex:pendingIndex];
+      [self.delegate viewControllerDidChangeDetent:pendingIndex position:self.currentPosition detent:detent];
+      [self emitChangePositionDelegateWithPosition:self.currentPosition realtime:NO debug:@"pending detent change"];
     });
   }
 
@@ -382,9 +361,7 @@
   NSInteger index = self.currentDetentIndex;
   CGFloat detent = [self detentValueForIndex:index];
 
-  if ([self.delegate respondsToSelector:@selector(viewControllerDidDrag:index:position:detent:)]) {
-    [self.delegate viewControllerDidDrag:gesture.state index:index position:self.currentPosition detent:detent];
-  }
+  [self.delegate viewControllerDidDrag:gesture.state index:index position:self.currentPosition detent:detent];
 
   switch (gesture.state) {
     case UIGestureRecognizerStateBegan:
@@ -449,7 +426,10 @@
 
     if (self.currentPosition >= self.screenHeight) {
       CGFloat position = fmax(_lastPosition, layerPosition);
+
+      [self emitWillDismissEvents];
       [self emitChangePositionDelegateWithPosition:position realtime:YES debug:@"transition out"];
+
     } else {
       CGFloat position = fmax(self.currentPosition, layerPosition);
       [self emitChangePositionDelegateWithPosition:position realtime:YES debug:@"transition in"];
@@ -472,9 +452,7 @@
 
     CGFloat index = [self interpolatedIndexForPosition:position];
     CGFloat detent = [self interpolatedDetentForPosition:position];
-    if ([self.delegate respondsToSelector:@selector(viewControllerDidChangePosition:position:detent:realtime:)]) {
-      [self.delegate viewControllerDidChangePosition:index position:position detent:detent realtime:realtime];
-    }
+    [self.delegate viewControllerDidChangePosition:index position:position detent:detent realtime:realtime];
   }
 }
 
@@ -671,32 +649,6 @@
 }
 
 - (void)setupBackground {
-#if RNTS_IPHONE_OS_VERSION_AVAILABLE(26_1)
-  BOOL useBackgroundEffect = NO;
-  if (@available(iOS 26.1, *)) {
-    useBackgroundEffect = !self.isDesignCompatibilityMode;
-  }
-
-  // iOS 26.1+: use native backgroundEffect when only backgroundBlur is set (no backgroundColor)
-  // Fall back to TrueSheetBlurView when blur intensity is set (not 100%) since
-  // sheet.backgroundEffect doesn't support intensity control
-  if (@available(iOS 26.1, *)) {
-    if (useBackgroundEffect) {
-      BOOL hasCustomIntensity = self.blurIntensity && [self.blurIntensity floatValue] < 100;
-      if (!self.backgroundColor && self.backgroundBlur && self.backgroundBlur.length > 0) {
-        if (hasCustomIntensity) {
-          // Clear native effect to allow custom blur view with intensity
-          self.sheet.backgroundEffect = [UIColorEffect effectWithColor:[UIColor clearColor]];
-        } else {
-          UIBlurEffectStyle style = [BlurUtil blurEffectStyleFromString:self.backgroundBlur];
-          self.sheet.backgroundEffect = [UIBlurEffect effectWithStyle:style];
-          return;
-        }
-      }
-    }
-  }
-#endif
-
   NSString *effectiveBackgroundBlur = self.backgroundBlur;
   if (@available(iOS 26.0, *)) {
     // iOS 26+ has default liquid glass effect
@@ -704,28 +656,23 @@
     effectiveBackgroundBlur = @"system-material";
   }
 
-  BOOL blurChanged = ![_blurView.backgroundBlur isEqualToString:effectiveBackgroundBlur];
+  BOOL hasBlur = effectiveBackgroundBlur && effectiveBackgroundBlur.length > 0;
 
-  if (_blurView && blurChanged) {
-    [_blurView removeFromSuperview];
-    _blurView = nil;
-  }
-
-  if (effectiveBackgroundBlur && effectiveBackgroundBlur.length > 0) {
-    if (!_blurView) {
-      _blurView = [[TrueSheetBlurView alloc] init];
-      [_blurView addToView:self.view];
-    }
-    _blurView.backgroundBlur = effectiveBackgroundBlur;
-    _blurView.blurIntensity = self.blurIntensity;
-    _blurView.blurInteraction = self.blurInteraction;
-    [_blurView applyBlurEffect];
-  }
+  _blurView.backgroundBlur = hasBlur ? effectiveBackgroundBlur : nil;
+  _blurView.blurIntensity = self.blurIntensity;
+  _blurView.blurInteraction = self.blurInteraction;
+  [_blurView applyBlurEffect];
 
 #if RNTS_IPHONE_OS_VERSION_AVAILABLE(26_1)
   if (@available(iOS 26.1, *)) {
-    if (useBackgroundEffect && self.backgroundColor) {
-      self.sheet.backgroundEffect = [UIColorEffect effectWithColor:self.backgroundColor];
+    if (!self.isDesignCompatibilityMode) {
+      if (self.backgroundColor) {
+        self.sheet.backgroundEffect = [UIColorEffect effectWithColor:self.backgroundColor];
+      } else if (hasBlur) {
+        self.sheet.backgroundEffect = [UIColorEffect effectWithColor:[UIColor clearColor]];
+      } else {
+        self.sheet.backgroundEffect = nil;
+      }
       return;
     }
   }
@@ -788,31 +735,14 @@
 
 - (void)sheetPresentationControllerDidChangeSelectedDetentIdentifier:
   (UISheetPresentationController *)sheetPresentationController {
-  if ([self.delegate respondsToSelector:@selector(viewControllerDidChangeDetent:position:detent:)]) {
-    dispatch_async(dispatch_get_main_queue(), ^{
-      NSInteger index = self.currentDetentIndex;
-      if (index >= 0) {
-        CGFloat detent = [self detentValueForIndex:index];
-        [self.delegate viewControllerDidChangeDetent:index position:self.currentPosition detent:detent];
-      }
-    });
-  }
-}
-
-#pragma mark - RNSLifecycleListenerProtocol
-
-#if RNS_LIFECYCLE_LISTENER_PROTOCOL_AVAILABLE
-
-- (void)screenWillDisappear:(UIViewController *)screen isPresenterUnmounting:(BOOL)isPresenterUnmounting {
-  // Skip if not presented, being dismissed, or if the presenter (modal) itself is being unmounted
-  if (!_isPresented || self.isBeingDismissed || isPresenterUnmounting) {
-    return;
-  }
-  if ([self.delegate respondsToSelector:@selector(viewControllerDidDetectScreenDisappear)]) {
-    [self.delegate viewControllerDidDetectScreenDisappear];
-  }
+  dispatch_async(dispatch_get_main_queue(), ^{
+    NSInteger index = self.currentDetentIndex;
+    if (index >= 0) {
+      CGFloat detent = [self detentValueForIndex:index];
+      [self.delegate viewControllerDidChangeDetent:index position:self.currentPosition detent:detent];
+    }
+  });
 }
-#endif
 
 #pragma mark - RNSDismissibleModalProtocol
 

package/ios/core/RNScreensEventObserver.h

@@ -0,0 +1,43 @@
+//
+//  Created by Jovanni Lo (@lodev09)
+//  Copyright (c) 2024-present. All rights reserved.
+//
+//  This source code is licensed under the MIT license found in the
+//  LICENSE file in the root directory of this source tree.
+//
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <UIKit/UIKit.h>
+#import <react/renderer/components/TrueSheetSpec/TrueSheetViewState.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class TrueSheetView;
+
+@protocol RNScreensEventObserverDelegate <NSObject>
+
+- (void)presenterScreenWillDisappear;
+- (void)presenterScreenWillAppear;
+
+@end
+
+/**
+ * Observes react-native-screens lifecycle events via C++ EventDispatcher.
+ * Detects when the presenting screen unmounts while sheet is presented.
+ */
+@interface RNScreensEventObserver : NSObject
+
+@property (nonatomic, weak) TrueSheetView<RNScreensEventObserverDelegate> *delegate;
+
+- (void)startObservingWithState:(const facebook::react::TrueSheetViewState &)state;
+- (void)stopObserving;
+
+- (void)capturePresenterScreenFromView:(UIView *)view;
+- (BOOL)shouldDismissForScreenTag:(NSInteger)screenTag;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif  // RCT_NEW_ARCH_ENABLED

package/ios/core/RNScreensEventObserver.mm

@@ -0,0 +1,119 @@
+//
+//  Created by Jovanni Lo (@lodev09)
+//  Copyright (c) 2024-present. All rights reserved.
+//
+//  This source code is licensed under the MIT license found in the
+//  LICENSE file in the root directory of this source tree.
+//
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import "RNScreensEventObserver.h"
+#import "TrueSheetView.h"
+
+#import <react/renderer/core/EventDispatcher.h>
+#import <react/renderer/core/ShadowNodeFamily.h>
+
+using namespace facebook::react;
+
+@implementation RNScreensEventObserver {
+  std::weak_ptr<const EventDispatcher> _eventDispatcher;
+  std::shared_ptr<const EventListener> _eventListener;
+  NSInteger _presenterScreenTag;
+  __weak UIViewController *_presenterScreenController;
+  BOOL _dismissedByNavigation;
+}
+
+- (instancetype)init {
+  if (self = [super init]) {
+    _presenterScreenTag = 0;
+    _presenterScreenController = nil;
+  }
+  return self;
+}
+
+- (void)dealloc {
+  [self stopObserving];
+}
+
+- (void)startObservingWithState:(const TrueSheetViewState &)state {
+  if (!_eventDispatcher.expired()) {
+    return;
+  }
+
+  if (auto dispatcherPtr = state.getEventDispatcher().lock()) {
+    _eventDispatcher = state.getEventDispatcher();
+
+    __weak RNScreensEventObserver *weakSelf = self;
+
+    _eventListener = std::make_shared<const EventListener>([weakSelf](const RawEvent &event) {
+      RNScreensEventObserver *strongSelf = weakSelf;
+      if (!strongSelf) {
+        return false;
+      }
+
+      if (auto family = event.shadowNodeFamily.lock()) {
+        Tag screenTag = family->getTag();
+
+        if (event.type == "topWillDisappear") {
+          if ([strongSelf shouldDismissForScreenTag:screenTag]) {
+            strongSelf->_dismissedByNavigation = YES;
+            [strongSelf.delegate presenterScreenWillDisappear];
+          }
+        } else if (event.type == "topWillAppear") {
+          if (screenTag == strongSelf->_presenterScreenTag && strongSelf->_dismissedByNavigation) {
+            strongSelf->_dismissedByNavigation = NO;
+            [strongSelf.delegate presenterScreenWillAppear];
+          }
+        }
+      }
+      return false;
+    });
+
+    dispatcherPtr->addListener(_eventListener);
+  }
+}
+
+- (void)stopObserving {
+  if (_eventListener) {
+    if (auto dispatcher = _eventDispatcher.lock()) {
+      dispatcher->removeListener(_eventListener);
+    }
+    _eventListener = nullptr;
+  }
+  _eventDispatcher.reset();
+}
+
+- (void)capturePresenterScreenFromView:(UIView *)view {
+  _presenterScreenTag = 0;
+  _presenterScreenController = nil;
+
+  for (UIView *current = view.superview; current; current = current.superview) {
+    NSString *className = NSStringFromClass([current class]);
+
+    if ([className isEqualToString:@"RNSScreenView"]) {
+      _presenterScreenTag = current.tag;
+      for (UIResponder *r = current.nextResponder; r; r = r.nextResponder) {
+        if ([r isKindOfClass:[UIViewController class]]) {
+          _presenterScreenController = (UIViewController *)r;
+          break;
+        }
+      }
+      break;
+    }
+  }
+}
+
+- (BOOL)shouldDismissForScreenTag:(NSInteger)screenTag {
+  if (_presenterScreenTag != screenTag) {
+    return NO;
+  }
+
+  // Skip if screen is still top of nav stack (e.g. modal dismiss - sheet dismisses naturally with modal)
+  // Dismiss if a new screen was pushed or popped
+  return _presenterScreenController.navigationController.topViewController != _presenterScreenController;
+}
+
+@end
+
+#endif  // RCT_NEW_ARCH_ENABLED

package/ios/core/TrueSheetBlurView.mm

@@ -34,41 +34,45 @@
   [parentView insertSubview:self atIndex:0];
 }
 
+- (void)clearAnimator {
+  if (_blurAnimator) {
+    [_blurAnimator stopAnimation:YES];
+    _blurAnimator = nil;
+  }
+}
+
 - (void)applyBlurEffect {
   self.userInteractionEnabled = self.blurInteraction;
 
-  // Create animator only once
-  if (!_blurAnimator) {
-    UIBlurEffectStyle style = [BlurUtil blurEffectStyleFromString:self.backgroundBlur];
-    UIBlurEffect *blurEffect = [UIBlurEffect effectWithStyle:style];
+  if (!self.backgroundBlur || self.backgroundBlur.length == 0) {
+    [self clearAnimator];
+    self.effect = nil;
+    return;
+  }
+
+  UIBlurEffectStyle style = [BlurUtil blurEffectStyleFromString:self.backgroundBlur];
+  UIBlurEffect *blurEffect = [UIBlurEffect effectWithStyle:style];
+
+  CGFloat intensity =
+    (self.blurIntensity && [self.blurIntensity floatValue] >= 0) ? [self.blurIntensity floatValue] / 100.0 : 1.0;
 
+  if (intensity >= 1.0) {
+    [self clearAnimator];
+    self.effect = blurEffect;
+    return;
+  }
+
+  if (!_blurAnimator) {
     __weak __typeof(self) weakSelf = self;
     _blurAnimator = [[UIViewPropertyAnimator alloc] initWithDuration:1.0
                                                                curve:UIViewAnimationCurveLinear
                                                           animations:^{
                                                             weakSelf.effect = blurEffect;
                                                           }];
-    _blurAnimator.pausesOnCompletion = YES;
   }
 
-  // Update intensity
-  CGFloat intensity =
-    (self.blurIntensity && [self.blurIntensity floatValue] >= 0) ? [self.blurIntensity floatValue] / 100.0 : 1.0;
+  _blurAnimator.pausesOnCompletion = YES;
   _blurAnimator.fractionComplete = intensity;
 }
 
-- (void)willMoveToSuperview:(UIView *)newSuperview {
-  [super willMoveToSuperview:newSuperview];
-
-  // Clean up when removed from superview
-  if (!newSuperview) {
-    if (_blurAnimator) {
-      [_blurAnimator stopAnimation:YES];
-      _blurAnimator = nil;
-    }
-
-    self.effect = nil;
-  }
-}
-
 @end

package/ios/utils/LayoutUtil.h

@@ -40,6 +40,29 @@ NS_ASSUME_NONNULL_BEGIN
  */
 + (void)pinView:(UIView *)view toParentView:(UIView *)parentView withTopView:(UIView *)topView edges:(UIRectEdge)edges;
 
+/**
+ * Pins a view to its parent view with insets
+ * @param view The view to pin
+ * @param parentView The parent view to pin to
+ * @param edges The edges to pin (UIRectEdge flags)
+ * @param insets The insets to apply to each edge
+ */
++ (void)pinView:(UIView *)view toParentView:(UIView *)parentView edges:(UIRectEdge)edges insets:(UIEdgeInsets)insets;
+
+/**
+ * Pins a view to its parent view with its top edge anchored below a top sibling view, with insets
+ * @param view The view to pin
+ * @param parentView The parent view to pin to
+ * @param topView The view to position below (top sibling)
+ * @param edges The edges to pin to parent (excluding top, which is pinned to topView)
+ * @param insets The insets to apply to each edge
+ */
++ (void)pinView:(UIView *)view
+   toParentView:(UIView *)parentView
+    withTopView:(UIView *)topView
+          edges:(UIRectEdge)edges
+         insets:(UIEdgeInsets)insets;
+
 /**
  * Unpins a view by removing its constraints and re-enabling autoresizing mask translation
  * @param view The view to unpin

package/ios/utils/LayoutUtil.mm

@@ -38,7 +38,32 @@
   }
 }
 
++ (void)pinView:(UIView *)view toParentView:(UIView *)parentView edges:(UIRectEdge)edges insets:(UIEdgeInsets)insets {
+  view.translatesAutoresizingMaskIntoConstraints = NO;
+
+  if (edges & UIRectEdgeTop) {
+    [view.topAnchor constraintEqualToAnchor:parentView.topAnchor constant:insets.top].active = YES;
+  }
+  if (edges & UIRectEdgeBottom) {
+    [view.bottomAnchor constraintEqualToAnchor:parentView.bottomAnchor constant:-insets.bottom].active = YES;
+  }
+  if (edges & UIRectEdgeLeft) {
+    [view.leadingAnchor constraintEqualToAnchor:parentView.leadingAnchor constant:insets.left].active = YES;
+  }
+  if (edges & UIRectEdgeRight) {
+    [view.trailingAnchor constraintEqualToAnchor:parentView.trailingAnchor constant:-insets.right].active = YES;
+  }
+}
+
 + (void)pinView:(UIView *)view toParentView:(UIView *)parentView withTopView:(UIView *)topView edges:(UIRectEdge)edges {
+  [self pinView:view toParentView:parentView withTopView:topView edges:edges insets:UIEdgeInsetsZero];
+}
+
++ (void)pinView:(UIView *)view
+   toParentView:(UIView *)parentView
+    withTopView:(UIView *)topView
+          edges:(UIRectEdge)edges
+         insets:(UIEdgeInsets)insets {
   view.translatesAutoresizingMaskIntoConstraints = NO;
 
   // Pin top edge to bottom of top sibling
@@ -46,13 +71,13 @@
 
   // Pin other edges to parent based on edges parameter
   if (edges & UIRectEdgeBottom) {
-    [view.bottomAnchor constraintEqualToAnchor:parentView.bottomAnchor].active = YES;
+    [view.bottomAnchor constraintEqualToAnchor:parentView.bottomAnchor constant:-insets.bottom].active = YES;
   }
   if (edges & UIRectEdgeLeft) {
-    [view.leadingAnchor constraintEqualToAnchor:parentView.leadingAnchor].active = YES;
+    [view.leadingAnchor constraintEqualToAnchor:parentView.leadingAnchor constant:insets.left].active = YES;
   }
   if (edges & UIRectEdgeRight) {
-    [view.trailingAnchor constraintEqualToAnchor:parentView.trailingAnchor].active = YES;
+    [view.trailingAnchor constraintEqualToAnchor:parentView.trailingAnchor constant:-insets.right].active = YES;
   }
 }