@lodev09/react-native-true-sheet 3.1.0-beta.2 → 3.1.0-beta.4

package/android/src/main/java/com/lodev09/truesheet/TrueSheetViewController.kt

@@ -64,12 +64,6 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     private const val GRABBER_TAG = "TrueSheetGrabber"
     private const val DEFAULT_MAX_WIDTH = 640 // dp
     private const val DEFAULT_CORNER_RADIUS = 16 // dp
-
-    /**
-     * Gets the effective sheet height by subtracting headerHeight * 2.
-     * This is needed because both native layout and Yoga layout account for the header separately.
-     */
-    fun getEffectiveSheetHeight(sheetHeight: Int, headerHeight: Int): Int = sheetHeight - headerHeight * 2
   }
 
   // ====================================================================
@@ -298,7 +292,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
         // Store resolved position for initial detent
         storeResolvedPosition(detentInfo.index)
-        emitChangePositionDelegate(detentInfo.index, positionPx, realtime = false)
+        emitChangePositionDelegate(positionPx, realtime = false)
 
         // Notify parent sheet that it has lost focus (after this sheet appeared)
         parentSheetView?.viewControllerDidBlur()
@@ -337,9 +331,8 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
         override fun onSlide(sheetView: View, slideOffset: Float) {
           val behavior = behavior ?: return
           val positionPx = getCurrentPositionPx(sheetView)
-          val detentIndex = getDetentIndexForPosition(positionPx)
 
-          emitChangePositionDelegate(detentIndex, positionPx, realtime = true)
+          emitChangePositionDelegate(positionPx, realtime = true)
 
           when (behavior.state) {
             BottomSheetBehavior.STATE_DRAGGING,
@@ -407,14 +400,26 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   private fun setupModalObserver() {
     rnScreensObserver = RNScreensFragmentObserver(
       reactContext = reactContext,
+      onModalWillPresent = {
+        if (isPresented) {
+          delegate?.viewControllerWillBlur()
+        }
+      },
       onModalPresented = {
         if (isPresented) {
           hideDialog()
+          delegate?.viewControllerDidBlur()
+        }
+      },
+      onModalWillDismiss = {
+        if (isPresented) {
+          delegate?.viewControllerWillFocus()
         }
       },
       onModalDismissed = {
         if (isPresented) {
           showDialog()
+          delegate?.viewControllerDidFocus()
         }
       }
     )
@@ -462,10 +467,10 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
    */
   fun hideDialog() {
     isDialogVisible = false
-    dialog?.window?.decorView?.visibility = View.INVISIBLE
+    dialog?.window?.decorView?.visibility = INVISIBLE
 
     // Emit off-screen position (detent = 0 since sheet is fully hidden)
-    emitChangePositionDelegate(currentDetentIndex, screenHeight, realtime = false)
+    emitChangePositionDelegate(screenHeight, realtime = false)
   }
 
   /**
@@ -474,11 +479,11 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
    */
   fun showDialog() {
     isDialogVisible = true
-    dialog?.window?.decorView?.visibility = View.VISIBLE
+    dialog?.window?.decorView?.visibility = VISIBLE
 
     // Emit current position
     val positionPx = bottomSheetView?.let { ScreenUtils.getScreenY(it) } ?: screenHeight
-    emitChangePositionDelegate(currentDetentIndex, positionPx, realtime = false)
+    emitChangePositionDelegate(positionPx, realtime = false)
   }
 
   // ====================================================================
@@ -522,7 +527,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   fun dismiss() {
     this.post {
       // Emit off-screen position (detent = 0 since sheet is fully hidden)
-      emitChangePositionDelegate(currentDetentIndex, screenHeight, realtime = false)
+      emitChangePositionDelegate(screenHeight, realtime = false)
     }
     dialog?.dismiss()
   }
@@ -552,7 +557,6 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     isReconfiguring = true
 
     behavior.apply {
-      skipCollapsed = false
       isFitToContents = false
       maxWidth = DEFAULT_MAX_WIDTH.dpToPx().toInt()
 
@@ -560,16 +564,19 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
         1 -> {
           setPeekHeight(getDetentHeight(detents[0]), isPresented)
           expandedOffset = screenHeight - peekHeight
+          isFitToContents = expandedOffset == 0
         }
 
         2 -> {
           setPeekHeight(getDetentHeight(detents[0]), isPresented)
+          halfExpandedRatio = minOf(getDetentHeight(detents[1]).toFloat() / screenHeight.toFloat(), 0.9f)
           expandedOffset = screenHeight - getDetentHeight(detents[1])
+          isFitToContents = expandedOffset == 0
         }
 
         3 -> {
           setPeekHeight(getDetentHeight(detents[0]), isPresented)
-          halfExpandedRatio = minOf(getDetentHeight(detents[1]).toFloat() / screenHeight.toFloat(), 1.0f)
+          halfExpandedRatio = minOf(getDetentHeight(detents[1]).toFloat() / screenHeight.toFloat(), 0.9f)
           expandedOffset = screenHeight - getDetentHeight(detents[2])
         }
       }
@@ -695,11 +702,10 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
   /**
    * Emits position change to the delegate if the position has changed.
-   * @param index The current detent index (discrete, used as fallback)
    * @param positionPx The current position in pixels (screen Y coordinate)
    * @param realtime Whether the position is a real-time value (during drag or animation tracking)
    */
-  private fun emitChangePositionDelegate(index: Int, positionPx: Int, realtime: Boolean) {
+  private fun emitChangePositionDelegate(positionPx: Int, realtime: Boolean) {
     if (positionPx == lastEmittedPositionPx) return
 
     lastEmittedPositionPx = positionPx
@@ -853,26 +859,6 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
   private fun getCurrentPositionPx(sheetView: View): Int = ScreenUtils.getScreenY(sheetView)
 
-  /**
-   * Returns the detent index for the current position.
-   * Only reports a higher index when the sheet has reached that detent's height.
-   */
-  private fun getDetentIndexForPosition(positionPx: Int): Int {
-    if (detents.isEmpty()) return 0
-
-    val sheetHeight = screenHeight - positionPx
-
-    // Find the highest detent index that the sheet has reached
-    for (i in detents.indices.reversed()) {
-      val detentHeight = getDetentHeight(detents[i])
-      if (sheetHeight >= detentHeight) {
-        return i
-      }
-    }
-
-    return 0
-  }
-
   private fun handleDragBegin(sheetView: View) {
     val detentInfo = getCurrentDetentInfo(sheetView)
     val detent = getDetentValueForIndex(detentInfo.index)
@@ -980,6 +966,9 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     super.onSizeChanged(w, h, oldw, oldh)
     if (w == oldw && h == oldh) return
 
+    // Fix issue where size keeps changing when full expanding to full screen (edgeToEdgeFullScreen enabled)
+    if (h + statusBarHeight >= screenHeight && isExpanded && oldw == w) return
+
     delegate?.viewControllerDidChangeSize(w, h)
 
     val oldScreenHeight = screenHeight
@@ -991,7 +980,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
         positionFooter()
         storeResolvedPosition(currentDetentIndex)
         val positionPx = bottomSheetView?.let { ScreenUtils.getScreenY(it) } ?: screenHeight
-        emitChangePositionDelegate(currentDetentIndex, positionPx, realtime = false)
+        emitChangePositionDelegate(positionPx, realtime = false)
       }
     }
   }

package/android/src/main/java/com/lodev09/truesheet/core/RNScreensFragmentObserver.kt

@@ -13,7 +13,9 @@ private const val RN_SCREENS_PACKAGE = "com.swmansion.rnscreens"
  */
 class RNScreensFragmentObserver(
   private val reactContext: ReactContext,
+  private val onModalWillPresent: () -> Unit = {},
   private val onModalPresented: () -> Unit,
+  private val onModalWillDismiss: () -> Unit = {},
   private val onModalDismissed: () -> Unit
 ) {
   private var fragmentLifecycleCallback: FragmentManager.FragmentLifecycleCallbacks? = null
@@ -27,13 +29,18 @@ class RNScreensFragmentObserver(
     val fragmentManager = activity.supportFragmentManager
 
     fragmentLifecycleCallback = object : FragmentManager.FragmentLifecycleCallbacks() {
-      override fun onFragmentAttached(fm: FragmentManager, fragment: Fragment, context: android.content.Context) {
-        super.onFragmentAttached(fm, fragment, context)
+      override fun onFragmentStarted(fm: FragmentManager, fragment: Fragment) {
+        super.onFragmentStarted(fm, fragment)
+
+        if (isModalFragment(fragment) && !activeModalFragments.contains(fragment)) {
+          // Notify willPresent before adding to active set
+          if (activeModalFragments.isEmpty()) {
+            onModalWillPresent()
+          }
 
-        if (isModalFragment(fragment)) {
           activeModalFragments.add(fragment)
 
-          // Notify when the first modal is attached
+          // Notify didPresent after modal is started
           if (activeModalFragments.size == 1) {
             onModalPresented()
           }
@@ -44,9 +51,14 @@ class RNScreensFragmentObserver(
         super.onFragmentStopped(fm, fragment)
 
         if (activeModalFragments.contains(fragment)) {
+          // Notify willDismiss before removing from active set
+          if (activeModalFragments.size == 1) {
+            onModalWillDismiss()
+          }
+
           activeModalFragments.remove(fragment)
 
-          // Notify when all modals are dismissed
+          // Notify didDismiss after all modals are dismissed
           if (activeModalFragments.isEmpty()) {
             onModalDismissed()
           }

package/ios/TrueSheetViewController.mm

@@ -25,6 +25,11 @@
   BOOL _isDragging;
   NSInteger _pendingDetentIndex;
 
+  // Transitioning tracker
+  CADisplayLink *_transitioningTimer;
+  UIView *_transitionFakeView;
+  BOOL _isTransitioning;
+
   // Reference to parent TrueSheetViewController (if presented from another sheet)
   __weak TrueSheetViewController *_parentSheetController;
 
@@ -36,6 +41,9 @@
 
   // Resolved detent positions (Y coordinate when sheet rests at each detent)
   NSMutableArray<NSNumber *> *_resolvedDetentPositions;
+
+  // Tracks whether this sheet has a presented controller (e.g., RN Screens modal)
+  BOOL _hasPresentedController;
 }
 
 #pragma mark - Initialization
@@ -55,9 +63,12 @@
     _isPresented = NO;
     _activeDetentIndex = -1;
     _pendingDetentIndex = -1;
+    _isTransitioning = NO;
+    _transitionFakeView = [UIView new];
 
     _blurInteraction = YES;
     _resolvedDetentPositions = [NSMutableArray array];
+    _hasPresentedController = NO;
   }
   return self;
 }
@@ -75,10 +86,6 @@
   return self.presentedViewController == nil;
 }
 
-- (BOOL)isActiveAndVisible {
-  return self.isViewLoaded && self.view.window != nil;
-}
-
 - (UIView *)presentedView {
   return self.sheetPresentationController.presentedView;
 }
@@ -137,6 +144,11 @@
 
   // Only trigger on initial presentation, not repositioning
   if (!_isPresented) {
+    // Initially store resolved position during presentation
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [self storeResolvedPositionForIndex:self.currentDetentIndex];
+    });
+
     // Capture parent sheet reference if presented from another TrueSheet
     UIViewController *presenter = self.presentingViewController;
     if ([presenter isKindOfClass:[TrueSheetViewController class]]) {
@@ -149,7 +161,7 @@
 
     if ([self.delegate respondsToSelector:@selector(viewControllerWillPresentAtIndex:position:detent:)]) {
       dispatch_async(dispatch_get_main_queue(), ^{
-        NSInteger index = [self currentDetentIndex];
+        NSInteger index = self.currentDetentIndex;
         CGFloat position = self.currentPosition;
         CGFloat detent = [self detentValueForIndex:index];
 
@@ -157,6 +169,8 @@
       });
     }
   }
+
+  [self setupTransitionTracker];
 }
 
 - (void)viewDidAppear:(BOOL)animated {
@@ -190,17 +204,10 @@
   [super viewWillDisappear:animated];
 
   if (self.isDismissing) {
-    _isPresented = NO;
-    _activeDetentIndex = -1;
-
     if ([self.delegate respondsToSelector:@selector(viewControllerWillDismiss)]) {
       [self.delegate viewControllerWillDismiss];
     }
 
-    dispatch_async(dispatch_get_main_queue(), ^{
-      [self emitChangePositionDelegateWithPosition:self.currentPosition realtime:NO];
-    });
-
     // Notify the parent sheet (if any) that it is about to regain focus
     if (_parentSheetController) {
       if ([_parentSheetController.delegate respondsToSelector:@selector(viewControllerWillFocus)]) {
@@ -208,6 +215,8 @@
       }
     }
   }
+
+  [self setupTransitionTracker];
 }
 
 - (void)viewDidDisappear:(BOOL)animated {
@@ -215,6 +224,9 @@
 
   // Only dispatch didDismiss when actually dismissing (not when another modal is presented on top)
   if (self.isDismissing) {
+    _isPresented = NO;
+    _activeDetentIndex = -1;
+
     // Notify the parent sheet (if any) that it regained focus
     if (_parentSheetController) {
       if ([_parentSheetController.delegate respondsToSelector:@selector(viewControllerDidFocus)]) {
@@ -236,17 +248,13 @@
     [self.delegate viewControllerDidChangeSize:self.view.frame.size];
   }
 
-  // Check if there's an active presented controller that has settled (not being presented/dismissed)
   UIViewController *presented = self.presentedViewController;
   BOOL hasPresentedController = presented != nil && !presented.isBeingPresented && !presented.isBeingDismissed;
 
-  if (!_isDragging) {
-    dispatch_async(dispatch_get_main_queue(), ^{
-      // Update stored position for current detent (handles content size changes)
-      [self storeResolvedPositionForIndex:[self currentDetentIndex]];
-
-      [self emitChangePositionDelegateWithPosition:self.currentPosition realtime:hasPresentedController];
-    });
+  if (!_isDragging && !_isTransitioning) {
+    // Update stored position for current detent (handles content size changes)
+    [self storeResolvedPositionForIndex:self.currentDetentIndex];
+    [self emitChangePositionDelegateWithPosition:self.currentPosition realtime:hasPresentedController];
   }
 
   // Emit pending detent change after programmatic resize settles
@@ -263,6 +271,62 @@
   }
 }
 
+#pragma mark - Presentation Tracking (for RN Screens integration)
+
+- (void)presentViewController:(UIViewController *)viewControllerToPresent
+                     animated:(BOOL)flag
+                   completion:(void (^)(void))completion {
+  // Check if this is a non-TrueSheet controller (e.g., RN Screens modal)
+  BOOL isExternalController = ![viewControllerToPresent isKindOfClass:[TrueSheetViewController class]];
+
+  if (isExternalController && !_hasPresentedController) {
+    _hasPresentedController = YES;
+
+    // Emit blur events when an external controller is presented on top
+    if ([self.delegate respondsToSelector:@selector(viewControllerWillBlur)]) {
+      [self.delegate viewControllerWillBlur];
+    }
+  }
+
+  [super presentViewController:viewControllerToPresent
+                      animated:flag
+                    completion:^{
+                      if (isExternalController && self->_hasPresentedController) {
+                        if ([self.delegate respondsToSelector:@selector(viewControllerDidBlur)]) {
+                          [self.delegate viewControllerDidBlur];
+                        }
+                      }
+                      if (completion) {
+                        completion();
+                      }
+                    }];
+}
+
+- (void)dismissViewControllerAnimated:(BOOL)flag completion:(void (^)(void))completion {
+  UIViewController *presented = self.presentedViewController;
+  BOOL isExternalController = presented && ![presented isKindOfClass:[TrueSheetViewController class]];
+
+  if (isExternalController && _hasPresentedController) {
+    // Emit focus events when external controller is dismissed
+    if ([self.delegate respondsToSelector:@selector(viewControllerWillFocus)]) {
+      [self.delegate viewControllerWillFocus];
+    }
+  }
+
+  [super dismissViewControllerAnimated:flag
+                            completion:^{
+                              if (isExternalController && self->_hasPresentedController) {
+                                self->_hasPresentedController = NO;
+                                if ([self.delegate respondsToSelector:@selector(viewControllerDidFocus)]) {
+                                  [self.delegate viewControllerDidFocus];
+                                }
+                              }
+                              if (completion) {
+                                completion();
+                              }
+                            }];
+}
+
 #pragma mark - Gesture Handling
 
 - (TrueSheetContentView *)findContentView:(UIView *)view {
@@ -333,7 +397,7 @@
 }
 
 - (void)handlePanGesture:(UIPanGestureRecognizer *)gesture {
-  NSInteger index = [self currentDetentIndex];
+  NSInteger index = self.currentDetentIndex;
   CGFloat detent = [self detentValueForIndex:index];
 
   if ([self.delegate respondsToSelector:@selector(viewControllerDidDrag:index:position:detent:)]) {
@@ -349,13 +413,15 @@
       break;
     case UIGestureRecognizerStateEnded:
     case UIGestureRecognizerStateCancelled: {
-      _isDragging = NO;
-      dispatch_async(dispatch_get_main_queue(), ^{
-        // Store resolved position when drag ends
-        [self storeResolvedPositionForIndex:[self currentDetentIndex]];
+      if (!_isTransitioning) {
+        dispatch_async(dispatch_get_main_queue(), ^{
+          // Store resolved position when drag ends
+          [self storeResolvedPositionForIndex:self.currentDetentIndex];
+          [self emitChangePositionDelegateWithPosition:self.currentPosition realtime:NO];
+        });
+      }
 
-        [self emitChangePositionDelegateWithPosition:self.currentPosition realtime:NO];
-      });
+      _isDragging = NO;
       break;
     }
     default:
@@ -365,6 +431,56 @@
 
 #pragma mark - Position Tracking
 
+- (void)setupTransitionTracker {
+  if (!self.transitionCoordinator)
+    return;
+
+  _isTransitioning = YES;
+
+  CGRect dismissedFrame = CGRectMake(0, self.screenHeight, 0, 0);
+  CGRect presentedFrame = CGRectMake(0, self.presentedView.frame.origin.y, 0, 0);
+
+  // Set starting fake view position
+  _transitionFakeView.frame = self.isDismissing ? presentedFrame : dismissedFrame;
+  [self storeResolvedPositionForIndex:self.currentDetentIndex];
+
+  auto animation = ^(id<UIViewControllerTransitionCoordinatorContext> _Nonnull context) {
+    [[context containerView] addSubview:self->_transitionFakeView];
+
+    // Set the fake view target position
+    self->_transitionFakeView.frame = self.isDismissing ? dismissedFrame : presentedFrame;
+
+    self->_transitioningTimer = [CADisplayLink displayLinkWithTarget:self selector:@selector(handleTransitionTracker)];
+    [self->_transitioningTimer addToRunLoop:[NSRunLoop currentRunLoop] forMode:NSDefaultRunLoopMode];
+  };
+
+  [self.transitionCoordinator
+    animateAlongsideTransition:animation
+                    completion:^(id<UIViewControllerTransitionCoordinatorContext> _Nonnull context) {
+                      [self->_transitioningTimer setPaused:YES];
+                      [self->_transitioningTimer invalidate];
+                      [self->_transitionFakeView removeFromSuperview];
+                      self->_isTransitioning = NO;
+                    }];
+}
+
+- (void)handleTransitionTracker {
+  if (!_isDragging && _transitionFakeView.layer) {
+    CALayer *layer = _transitionFakeView.layer;
+
+    CGFloat layerPosition = layer.presentationLayer.frame.origin.y;
+
+    if (self.currentPosition >= self.screenHeight) {
+      // Dismissing position
+      [self emitChangePositionDelegateWithPosition:layerPosition realtime:YES];
+    } else {
+      // Presenting position
+      CGFloat position = fmax(self.currentPosition, layerPosition);
+      [self emitChangePositionDelegateWithPosition:position realtime:YES];
+    }
+  }
+}
+
 - (void)emitChangePositionDelegateWithPosition:(CGFloat)position realtime:(BOOL)realtime {
   // Use epsilon comparison to avoid missing updates due to floating point precision
   if (fabs(_lastPosition - position) > 0.01) {
@@ -741,7 +857,7 @@
   (UISheetPresentationController *)sheetPresentationController {
   if ([self.delegate respondsToSelector:@selector(viewControllerDidChangeDetent:position:detent:)]) {
     dispatch_async(dispatch_get_main_queue(), ^{
-      NSInteger index = [self currentDetentIndex];
+      NSInteger index = self.currentDetentIndex;
       if (index >= 0) {
         CGFloat detent = [self detentValueForIndex:index];
         [self.delegate viewControllerDidChangeDetent:index position:self.currentPosition detent:detent];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lodev09/react-native-true-sheet",
-  "version": "3.1.0-beta.2",
+  "version": "3.1.0-beta.4",
   "description": "The true native bottom sheet experience for your React Native Apps.",
   "source": "./src/index.ts",
   "main": "./lib/module/index.js",