@lodev09/react-native-true-sheet 3.0.0-beta.8 → 3.0.0

package/ios/TrueSheetViewController.mm

@@ -8,7 +8,7 @@
 
 #import "TrueSheetViewController.h"
 #import "TrueSheetContentView.h"
-#import "utils/ConversionUtil.h"
+#import "core/TrueSheetBlurView.h"
 #import "utils/GestureUtil.h"
 #import "utils/WindowUtil.h"
 
@@ -21,14 +21,17 @@
 
 @implementation TrueSheetViewController {
   CGFloat _lastPosition;
-  CGFloat _lastTransitionPosition;
-  BOOL _isTransitioning;
   BOOL _isDragging;
-  BOOL _isTrackingPositionFromLayout;
+  NSInteger _pendingDetentIndex;
 
-  // Hidden view used to track position during native transition animations
-  UIView *_fakeTransitionView;
-  CADisplayLink *_displayLink;
+  // Reference to parent TrueSheetViewController (if presented from another sheet)
+  __weak TrueSheetViewController *_parentSheetController;
+
+  // Blur effect view
+  TrueSheetBlurView *_blurView;
+
+  // Resolved detent positions (Y coordinate when sheet rests at each detent)
+  NSMutableArray<NSNumber *> *_resolvedDetentPositions;
 }
 
 #pragma mark - Initialization
@@ -39,32 +42,24 @@
     _contentHeight = @(0);
     _headerHeight = @(0);
     _grabber = YES;
+    _draggable = YES;
     _dimmed = YES;
     _dimmedDetentIndex = @(0);
     _pageSizing = YES;
     _lastPosition = 0;
-    _lastTransitionPosition = 0;
-    _isTransitioning = NO;
     _isDragging = NO;
-    _isTrackingPositionFromLayout = NO;
-    _layoutTransitioning = NO;
     _isPresented = NO;
     _activeDetentIndex = -1;
+    _pendingDetentIndex = -1;
 
-    _fakeTransitionView = [[UIView alloc] init];
-    _fakeTransitionView.hidden = YES;
-    _fakeTransitionView.userInteractionEnabled = NO;
+    _blurInteraction = YES;
+    _resolvedDetentPositions = [NSMutableArray array];
   }
   return self;
 }
 
 - (void)dealloc {
   [[NSNotificationCenter defaultCenter] removeObserver:self];
-
-  if (_displayLink) {
-    [_displayLink invalidate];
-    _displayLink = nil;
-  }
 }
 
 #pragma mark - Computed Properties
@@ -77,7 +72,7 @@
 }
 
 - (BOOL)isActiveAndVisible {
-  return self.isViewLoaded && self.view.window != nil && !self.isBeingDismissed;
+  return self.isViewLoaded && self.view.window != nil;
 }
 
 - (UIView *)presentedView {
@@ -89,21 +84,8 @@
   return presentedView ? presentedView.frame.origin.y : 0.0;
 }
 
-- (CGFloat)bottomInset {
-  if ([UIDevice currentDevice].userInterfaceIdiom == UIUserInterfaceIdiomPad) {
-    return 0;
-  }
-  UIWindow *window = [WindowUtil keyWindow];
-  return window ? window.safeAreaInsets.bottom : 0;
-}
-
-- (CGFloat)currentHeight {
-  return self.containerHeight - self.currentPosition - self.bottomInset;
-}
-
-- (CGFloat)containerHeight {
-  UIView *sheetContainerView = self.sheetPresentationController.containerView;
-  return sheetContainerView ? sheetContainerView.frame.size.height : 0.0;
+- (CGFloat)screenHeight {
+  return UIScreen.mainScreen.bounds.size.height;
 }
 
 - (NSInteger)currentDetentIndex {
@@ -146,10 +128,25 @@
 
   // Only trigger on initial presentation, not repositioning
   if (!_isPresented) {
-    if ([self.delegate respondsToSelector:@selector(viewControllerWillPresent)]) {
-      [self.delegate viewControllerWillPresent];
+    // Capture parent sheet reference if presented from another TrueSheet
+    UIViewController *presenter = self.presentingViewController;
+    if ([presenter isKindOfClass:[TrueSheetViewController class]]) {
+      _parentSheetController = (TrueSheetViewController *)presenter;
+      // Notify parent that it is about to lose focus
+      if ([_parentSheetController.delegate respondsToSelector:@selector(viewControllerWillBlur)]) {
+        [_parentSheetController.delegate viewControllerWillBlur];
+      }
+    }
+
+    if ([self.delegate respondsToSelector:@selector(viewControllerWillPresentAtIndex:position:detent:)]) {
+      dispatch_async(dispatch_get_main_queue(), ^{
+        NSInteger index = [self currentDetentIndex];
+        CGFloat position = self.currentPosition;
+        CGFloat detent = [self detentValueForIndex:index];
+
+        [self.delegate viewControllerWillPresentAtIndex:index position:position detent:detent];
+      });
     }
-    [self setupTransitionPositionTracking];
   }
 }
 
@@ -157,8 +154,19 @@
   [super viewDidAppear:animated];
 
   if (!_isPresented) {
-    if ([self.delegate respondsToSelector:@selector(viewControllerDidPresent)]) {
-      [self.delegate viewControllerDidPresent];
+    // Notify parent that it has lost focus (after the child sheet appeared)
+    if (_parentSheetController) {
+      if ([_parentSheetController.delegate respondsToSelector:@selector(viewControllerDidBlur)]) {
+        [_parentSheetController.delegate viewControllerDidBlur];
+      }
+    }
+
+    if ([self.delegate respondsToSelector:@selector(viewControllerDidPresentAtIndex:position:detent:)]) {
+      dispatch_async(dispatch_get_main_queue(), ^{
+        NSInteger index = [self currentDetentIndex];
+        CGFloat detent = [self detentValueForIndex:index];
+        [self.delegate viewControllerDidPresentAtIndex:index position:self.currentPosition detent:detent];
+      });
     }
     [self setupGestureRecognizer];
     _isPresented = YES;
@@ -168,12 +176,24 @@
 - (void)viewWillDisappear:(BOOL)animated {
   [super viewWillDisappear:animated];
 
-  if (self.isBeingDismissed && [self.delegate respondsToSelector:@selector(viewControllerWillDismiss)]) {
-    [self.delegate viewControllerWillDismiss];
-  }
+  BOOL isActuallyDismissing = self.presentingViewController == nil || self.isBeingDismissed;
+
+  if (isActuallyDismissing) {
+    // Notify the parent sheet (if any) that it is about to regain focus
+    if (_parentSheetController) {
+      if ([_parentSheetController.delegate respondsToSelector:@selector(viewControllerWillFocus)]) {
+        [_parentSheetController.delegate viewControllerWillFocus];
+      }
+    }
+
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [self emitChangePositionDelegateWithPosition:self.currentPosition realtime:NO];
+    });
 
-  [self setupTransitionPositionTracking];
-  _isTrackingPositionFromLayout = NO;
+    if ([self.delegate respondsToSelector:@selector(viewControllerWillDismiss)]) {
+      [self.delegate viewControllerWillDismiss];
+    }
+  }
 }
 
 - (void)viewDidDisappear:(BOOL)animated {
@@ -182,11 +202,19 @@
   // Only dispatch didDismiss when actually dismissing (not when another modal is presented on top)
   BOOL isActuallyDismissing = self.presentingViewController == nil || self.isBeingDismissed;
 
-  if (isActuallyDismissing && [self.delegate respondsToSelector:@selector(viewControllerDidDismiss)]) {
-    [self.delegate viewControllerDidDismiss];
-  }
+  if (isActuallyDismissing) {
+    // Notify the parent sheet (if any) that it regained focus
+    if (_parentSheetController) {
+      if ([_parentSheetController.delegate respondsToSelector:@selector(viewControllerDidFocus)]) {
+        [_parentSheetController.delegate viewControllerDidFocus];
+      }
+      _parentSheetController = nil;
+    }
 
-  _isTrackingPositionFromLayout = NO;
+    if ([self.delegate respondsToSelector:@selector(viewControllerDidDismiss)]) {
+      [self.delegate viewControllerDidDismiss];
+    }
+  }
 
   if (isActuallyDismissing) {
     _isPresented = NO;
@@ -201,16 +229,29 @@
     [self.delegate viewControllerDidChangeSize:self.view.frame.size];
   }
 
-  if (!_isTransitioning && self.isActiveAndVisible) {
-    _isTrackingPositionFromLayout = YES;
+  // 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];
+    });
+  }
 
-    // Treat position changes as transitioning when another controller is presented on top
-    [self emitChangePositionDelegateWithPosition:self.currentPosition
-                                   transitioning:_layoutTransitioning || !self.isTopmostPresentedController];
+  // Emit pending detent change after programmatic resize settles
+  if (_pendingDetentIndex >= 0) {
+    NSInteger pendingIndex = _pendingDetentIndex;
+    _pendingDetentIndex = -1;
 
-    // On iOS 26, this is called twice when we have a ScrollView
-    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.4 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
-      self->_layoutTransitioning = NO;
+    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:)]) {
+        CGFloat detent = [self detentValueForIndex:pendingIndex];
+        [self.delegate viewControllerDidChangeDetent:pendingIndex position:self.currentPosition detent:detent];
+      }
     });
   }
 }
@@ -237,13 +278,28 @@
   if (!presentedView)
     return;
 
+  // Disable pan gestures if draggable is NO
+  if (!self.draggable) {
+    [GestureUtil setPanGesturesEnabled:NO forView:presentedView];
+
+    // Also disable ScrollView's pan gesture if present
+    TrueSheetContentView *contentView = [self findContentView:presentedView];
+    if (contentView) {
+      RCTScrollViewComponentView *scrollViewComponent = [contentView findScrollView:nil];
+      if (scrollViewComponent && scrollViewComponent.scrollView) {
+        [GestureUtil setPanGesturesEnabled:NO forView:scrollViewComponent.scrollView];
+      }
+    }
+    return;
+  }
+
   // Attach to presented view's pan gesture (sheet's drag gesture from UIKit)
   [GestureUtil attachPanGestureHandler:presentedView target:self selector:@selector(handlePanGesture:)];
 
   // Also attach to ScrollView's pan gesture if present
   TrueSheetContentView *contentView = [self findContentView:presentedView];
   if (contentView) {
-    RCTScrollViewComponentView *scrollViewComponent = [contentView findScrollView];
+    RCTScrollViewComponentView *scrollViewComponent = [contentView findScrollView:nil];
     if (scrollViewComponent && scrollViewComponent.scrollView) {
       [GestureUtil attachPanGestureHandler:scrollViewComponent.scrollView
                                     target:self
@@ -252,11 +308,29 @@
   }
 }
 
+- (void)updateDraggable {
+  UIView *presentedView = self.presentedView;
+  if (!presentedView)
+    return;
+
+  [GestureUtil setPanGesturesEnabled:self.draggable forView:presentedView];
+
+  // Also update ScrollView's pan gesture if present
+  TrueSheetContentView *contentView = [self findContentView:presentedView];
+  if (contentView) {
+    RCTScrollViewComponentView *scrollViewComponent = [contentView findScrollView:nil];
+    if (scrollViewComponent && scrollViewComponent.scrollView) {
+      [GestureUtil setPanGesturesEnabled:self.draggable forView:scrollViewComponent.scrollView];
+    }
+  }
+}
+
 - (void)handlePanGesture:(UIPanGestureRecognizer *)gesture {
   NSInteger index = [self currentDetentIndex];
+  CGFloat detent = [self detentValueForIndex:index];
 
-  if ([self.delegate respondsToSelector:@selector(viewControllerDidDrag:index:position:)]) {
-    [self.delegate viewControllerDidDrag:gesture.state index:index position:self.currentPosition];
+  if ([self.delegate respondsToSelector:@selector(viewControllerDidDrag:index:position:detent:)]) {
+    [self.delegate viewControllerDidDrag:gesture.state index:index position:self.currentPosition detent:detent];
   }
 
   switch (gesture.state) {
@@ -264,14 +338,19 @@
       _isDragging = YES;
       break;
     case UIGestureRecognizerStateChanged:
-      if (!_isTrackingPositionFromLayout) {
-        [self emitChangePositionDelegateWithPosition:self.currentPosition transitioning:NO];
-      }
+      [self emitChangePositionDelegateWithPosition:self.currentPosition realtime:YES];
       break;
     case UIGestureRecognizerStateEnded:
-    case UIGestureRecognizerStateCancelled:
+    case UIGestureRecognizerStateCancelled: {
       _isDragging = NO;
+      dispatch_async(dispatch_get_main_queue(), ^{
+        // Store resolved position when drag ends
+        [self storeResolvedPositionForIndex:[self currentDetentIndex]];
+
+        [self emitChangePositionDelegateWithPosition:self.currentPosition realtime:NO];
+      });
       break;
+    }
     default:
       break;
   }
@@ -279,90 +358,156 @@
 
 #pragma mark - Position Tracking
 
-- (void)emitChangePositionDelegateWithPosition:(CGFloat)position transitioning:(BOOL)transitioning {
-  if (_lastPosition != position) {
+- (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) {
     _lastPosition = position;
 
-    NSInteger index = [self currentDetentIndex];
-    if ([self.delegate respondsToSelector:@selector(viewControllerDidChangePosition:position:transitioning:)]) {
-      [self.delegate viewControllerDidChangePosition:index position:position transitioning:transitioning];
+    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];
     }
   }
 }
 
-/**
- * Sets up position tracking during view controller transitions using a fake view.
- *
- * This uses a hidden "fake" view added to the container that animates alongside
- * the presented view. By observing the presentation layer, we can track smooth
- * position changes during native transition animations.
- */
-- (void)setupTransitionPositionTracking {
-  if (self.transitionCoordinator == nil)
-    return;
+/// Stores the current position for the given detent index
+- (void)storeResolvedPositionForIndex:(NSInteger)index {
+  if (index >= 0 && index < (NSInteger)_resolvedDetentPositions.count) {
+    _resolvedDetentPositions[index] = @(self.currentPosition);
+  }
+}
+
+/// Returns the estimated Y position for a detent index, using stored positions when available
+- (CGFloat)estimatedPositionForIndex:(NSInteger)index {
+  if (index < 0 || index >= (NSInteger)_resolvedDetentPositions.count)
+    return 0;
 
-  _isTransitioning = YES;
+  CGFloat storedPos = [_resolvedDetentPositions[index] doubleValue];
+  if (storedPos > 0) {
+    return storedPos;
+  }
 
-  UIView *containerView = self.sheetPresentationController.containerView;
-  UIView *presentedView = self.presentedView;
+  // Estimate based on detent value and known offset from first resolved position
+  CGFloat detentValue = [self detentValueForIndex:index];
+  CGFloat basePosition = self.screenHeight - (detentValue * self.screenHeight);
 
-  if (!containerView || !presentedView)
-    return;
+  // Find a resolved position to calculate offset
+  for (NSInteger i = 0; i < (NSInteger)_resolvedDetentPositions.count; i++) {
+    CGFloat pos = [_resolvedDetentPositions[i] doubleValue];
+    if (pos > 0) {
+      CGFloat knownDetent = [self detentValueForIndex:i];
+      CGFloat expectedPos = self.screenHeight - (knownDetent * self.screenHeight);
+      CGFloat offset = pos - expectedPos;
+      return basePosition + offset;
+    }
+  }
+
+  return basePosition;
+}
 
-  CGRect frame = presentedView.frame;
-  BOOL isPresenting = self.isBeingPresented;
+/// Finds the segment containing the given position and returns the lower index and progress within that segment.
+/// Returns YES if a segment was found, NO otherwise. When NO, `outIndex` contains the boundary index.
+- (BOOL)findSegmentForPosition:(CGFloat)position outIndex:(NSInteger *)outIndex outProgress:(CGFloat *)outProgress {
+  NSInteger count = _resolvedDetentPositions.count;
+  if (count == 0) {
+    *outIndex = -1;
+    *outProgress = 0;
+    return NO;
+  }
 
-  // Set initial position: presenting starts from bottom, dismissing from current
-  frame.origin.y = isPresenting ? self.containerHeight : presentedView.frame.origin.y;
-  _fakeTransitionView.frame = frame;
+  if (count == 1) {
+    *outIndex = 0;
+    *outProgress = 0;
+    return NO;
+  }
+
+  CGFloat firstPos = [self estimatedPositionForIndex:0];
+  CGFloat lastPos = [self estimatedPositionForIndex:count - 1];
 
-  auto animation = ^(id<UIViewControllerTransitionCoordinatorContext> _Nonnull context) {
-    [[context containerView] addSubview:self->_fakeTransitionView];
+  // Below first detent (position > firstPos means sheet is smaller)
+  if (position > firstPos) {
+    CGFloat range = self.screenHeight - firstPos;
+    *outIndex = -1;
+    *outProgress = range > 0 ? (position - firstPos) / range : 0;
+    return NO;
+  }
 
-    CGRect finalFrame = presentedView.frame;
-    finalFrame.origin.y = presentedView.frame.origin.y;
-    self->_fakeTransitionView.frame = finalFrame;
+  // Above last detent
+  if (position < lastPos) {
+    *outIndex = count - 1;
+    *outProgress = 0;
+    return NO;
+  }
 
-    self->_lastTransitionPosition = finalFrame.origin.y;
+  // Find segment (positions decrease as index increases)
+  for (NSInteger i = 0; i < count - 1; i++) {
+    CGFloat pos = [self estimatedPositionForIndex:i];
+    CGFloat nextPos = [self estimatedPositionForIndex:i + 1];
 
-    // Track position at screen refresh rate via display link
-    self->_displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(trackTransitionPosition:)];
-    [self->_displayLink addToRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];
-  };
+    if (position <= pos && position >= nextPos) {
+      CGFloat range = pos - nextPos;
+      *outIndex = i;
+      *outProgress = range > 0 ? (pos - position) / range : 0;
+      return YES;
+    }
+  }
 
-  [self.transitionCoordinator
-    animateAlongsideTransition:animation
-                    completion:^(id<UIViewControllerTransitionCoordinatorContext> _Nonnull context) {
-                      [self->_displayLink invalidate];
-                      self->_displayLink = nil;
-                      [self->_fakeTransitionView removeFromSuperview];
-                      self->_isTransitioning = NO;
-                    }];
+  *outIndex = count - 1;
+  *outProgress = 0;
+  return NO;
 }
 
-- (void)trackTransitionPosition:(CADisplayLink *)displayLink {
-  UIView *presentedView = self.presentedView;
+- (CGFloat)interpolatedIndexForPosition:(CGFloat)position {
+  NSInteger index;
+  CGFloat progress;
+  BOOL found = [self findSegmentForPosition:position outIndex:&index outProgress:&progress];
 
-  if (_isDragging || !_fakeTransitionView || !presentedView)
-    return;
+  if (!found) {
+    if (index == -1) {
+      // Below first detent - return negative progress
+      return -progress;
+    }
+    // At or beyond boundary
+    return index;
+  }
 
-  // Presentation layer contains in-flight animated values (not final/target values)
-  CALayer *presentationLayer = _fakeTransitionView.layer.presentationLayer;
+  // Within a segment - interpolate
+  return index + fmax(0, fmin(1, progress));
+}
 
-  if (presentationLayer) {
-    BOOL transitioning = NO;
-    CGFloat position = presentationLayer.frame.origin.y;
+- (CGFloat)interpolatedDetentForPosition:(CGFloat)position {
+  NSInteger index;
+  CGFloat progress;
+  BOOL found = [self findSegmentForPosition:position outIndex:&index outProgress:&progress];
 
-    // If position matches last transition position (within epsilon), sheet is repositioning after drag
-    if (fabs(_lastTransitionPosition - position) < 0.5) {
-      transitioning = YES;
-      position = presentedView.frame.origin.y;
-    } else {
-      _lastTransitionPosition = position;
+  if (!found) {
+    if (index == -1) {
+      // Below first detent
+      CGFloat firstDetent = [self detentValueForIndex:0];
+      return fmax(0, firstDetent * (1 - progress));
     }
+    // At or beyond boundary
+    return [self detentValueForIndex:index];
+  }
+
+  // Within a segment - interpolate between detent values
+  CGFloat detent = [self detentValueForIndex:index];
+  CGFloat nextDetent = [self detentValueForIndex:index + 1];
+  return detent + progress * (nextDetent - detent);
+}
 
-    [self emitChangePositionDelegateWithPosition:position transitioning:transitioning];
+- (CGFloat)detentValueForIndex:(NSInteger)index {
+  if (index >= 0 && index < (NSInteger)_detents.count) {
+    CGFloat value = [_detents[index] doubleValue];
+    // For auto (-1), calculate actual fraction from content + header height
+    if (value == -1) {
+      CGFloat autoHeight = [self.contentHeight floatValue] + [self.headerHeight floatValue];
+      return autoHeight / self.screenHeight;
+    }
+    return value;
   }
+  return 0;
 }
 
 #pragma mark - Sheet Configuration
@@ -373,16 +518,18 @@
     return;
 
   NSMutableArray<UISheetPresentationControllerDetent *> *detents = [NSMutableArray array];
+  [_resolvedDetentPositions removeAllObjects];
 
-  // Subtract bottomInset to prevent iOS from adding extra bottom insets
-  CGFloat totalHeight = [self.contentHeight floatValue] + [self.headerHeight floatValue] - self.bottomInset;
+  CGFloat autoHeight = [self.contentHeight floatValue] + [self.headerHeight floatValue];
 
   for (NSInteger index = 0; index < self.detents.count; index++) {
     id detent = self.detents[index];
     UISheetPresentationControllerDetent *sheetDetent = [self detentForValue:detent
-                                                                 withHeight:totalHeight
+                                                             withAutoHeight:autoHeight
                                                                     atIndex:index];
     [detents addObject:sheetDetent];
+    // Initialize with placeholder - will be updated when sheet settles at each detent
+    [_resolvedDetentPositions addObject:@(0)];
   }
 
   sheet.detents = detents;
@@ -408,25 +555,19 @@
   }
 }
 
-- (UISheetPresentationControllerDetent *)detentForValue:(id)detent withHeight:(CGFloat)height atIndex:(NSInteger)index {
+- (UISheetPresentationControllerDetent *)detentForValue:(id)detent
+                                         withAutoHeight:(CGFloat)autoHeight
+                                                atIndex:(NSInteger)index {
   if (![detent isKindOfClass:[NSNumber class]]) {
     return [UISheetPresentationControllerDetent mediumDetent];
   }
 
-  CGFloat value = [detent floatValue];
+  CGFloat value = [detent doubleValue];
 
   // -1 represents "auto" (fit content height)
   if (value == -1) {
     if (@available(iOS 16.0, *)) {
-      NSString *detentId = @"custom-auto";
-      return [UISheetPresentationControllerDetent
-        customDetentWithIdentifier:detentId
-                          resolver:^CGFloat(id<UISheetPresentationControllerDetentResolutionContext> context) {
-                            CGFloat maxDetentValue = context.maximumDetentValue;
-                            CGFloat maxValue =
-                              self.maxHeight ? fmin(maxDetentValue, [self.maxHeight floatValue]) : maxDetentValue;
-                            return fmin(height, maxValue);
-                          }];
+      return [self customDetentWithIdentifier:@"custom-auto" height:autoHeight];
     } else {
       return [UISheetPresentationControllerDetent mediumDetent];
     }
@@ -438,21 +579,9 @@
   }
 
   if (@available(iOS 16.0, *)) {
-    if (value == 1.0) {
-      return [UISheetPresentationControllerDetent largeDetent];
-    } else if (value == 0.5) {
-      return [UISheetPresentationControllerDetent mediumDetent];
-    } else {
-      NSString *detentId = [NSString stringWithFormat:@"custom-%f", value];
-      return [UISheetPresentationControllerDetent
-        customDetentWithIdentifier:detentId
-                          resolver:^CGFloat(id<UISheetPresentationControllerDetentResolutionContext> context) {
-                            CGFloat maxDetentValue = context.maximumDetentValue;
-                            CGFloat maxValue =
-                              self.maxHeight ? fmin(maxDetentValue, [self.maxHeight floatValue]) : maxDetentValue;
-                            return fmin(value * maxDetentValue, maxValue);
-                          }];
-    }
+    NSString *detentId = [NSString stringWithFormat:@"custom-%f", value];
+    CGFloat sheetHeight = value * self.screenHeight;
+    return [self customDetentWithIdentifier:detentId height:sheetHeight];
   } else if (value >= 0.5) {
     return [UISheetPresentationControllerDetent largeDetent];
   } else {
@@ -460,6 +589,18 @@
   }
 }
 
+- (UISheetPresentationControllerDetent *)customDetentWithIdentifier:(NSString *)identifier
+                                                             height:(CGFloat)height API_AVAILABLE(ios(16.0)) {
+  return [UISheetPresentationControllerDetent
+    customDetentWithIdentifier:identifier
+                      resolver:^CGFloat(id<UISheetPresentationControllerDetentResolutionContext> context) {
+                        CGFloat maxDetentValue = context.maximumDetentValue;
+                        CGFloat maxValue =
+                          self.maxHeight ? fmin(maxDetentValue, [self.maxHeight floatValue]) : maxDetentValue;
+                        return fmin(height, maxValue);
+                      }];
+}
+
 - (UISheetPresentationControllerDetentIdentifier)detentIdentifierForIndex:(NSInteger)index {
   UISheetPresentationController *sheet = self.sheetPresentationController;
   if (!sheet)
@@ -512,6 +653,16 @@
   [self applyActiveDetent];
 }
 
+- (void)resizeToDetentIndex:(NSInteger)index {
+  if (index == _activeDetentIndex) {
+    return;
+  }
+
+  _pendingDetentIndex = index;
+  _activeDetentIndex = index;
+  [self applyActiveDetent];
+}
+
 - (void)setupSheetProps {
   UISheetPresentationController *sheet = self.sheetPresentationController;
   if (!sheet) {
@@ -527,7 +678,7 @@
   }
 
   sheet.prefersEdgeAttachedInCompactHeight = YES;
-  sheet.prefersGrabberVisible = self.grabber;
+  sheet.prefersGrabberVisible = self.grabber && self.draggable;
 
   if (self.cornerRadius) {
     sheet.preferredCornerRadius = [self.cornerRadius floatValue];
@@ -539,16 +690,25 @@
 
   // Setup or remove blur effect
   if (self.blurTint && self.blurTint.length > 0) {
-    UIBlurEffectStyle style = [ConversionUtil blurEffectStyleFromString:self.blurTint];
-    UIVisualEffectView *blurView = [[UIVisualEffectView alloc] initWithEffect:[UIBlurEffect effectWithStyle:style]];
-    blurView.frame = self.view.bounds;
-    blurView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
-    [self.view insertSubview:blurView atIndex:0];
+    // Create blur view if needed
+    if (!_blurView) {
+      _blurView = [[TrueSheetBlurView alloc] init];
+      _blurView.frame = self.view.bounds;
+      _blurView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+      [self.view insertSubview:_blurView atIndex:0];
+    }
+
+    // Update blur properties and apply effect
+    _blurView.blurTint = self.blurTint;
+    _blurView.blurIntensity = self.blurIntensity;
+    _blurView.blurInteraction = self.blurInteraction;
+    [_blurView applyBlurEffect];
   } else {
-    for (UIView *subview in self.view.subviews) {
-      if ([subview isKindOfClass:[UIVisualEffectView class]]) {
-        [subview removeFromSuperview];
-      }
+    // Remove blur effect
+    if (_blurView) {
+      [_blurView removeBlurEffect];
+      [_blurView removeFromSuperview];
+      _blurView = nil;
     }
   }
 }
@@ -557,9 +717,14 @@
 
 - (void)sheetPresentationControllerDidChangeSelectedDetentIdentifier:
   (UISheetPresentationController *)sheetPresentationController {
-  NSInteger index = [self currentDetentIndex];
-  if (index >= 0 && [self.delegate respondsToSelector:@selector(viewControllerDidChangeDetent:position:)]) {
-    [self.delegate viewControllerDidChangeDetent:index position:self.currentPosition];
+  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];
+      }
+    });
   }
 }