@lodev09/react-native-true-sheet 4.0.0-beta.25 → 4.0.0-beta.26

package/ios/TrueSheetViewController.mm

@@ -49,6 +49,10 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
 - (void)setAccessibilityContentElement:(UIView *)contentView;
 - (NSArray *)accessibilityGrabberElements;
 - (void)endInteractiveDismissState;
+- (void)updateHingeState;
+- (void)correctHingeOffsetForIndex:(NSInteger)index;
+- (CGFloat)tabletopHingeEdge;
+- (CGFloat)hingeOffsetForHeight:(CGFloat)height;
 - (void)animateInteractiveContainerToTransform:(CGAffineTransform)transform
                                       duration:(NSTimeInterval)duration
                           allowUserInteraction:(BOOL)allowUserInteraction
@@ -78,6 +82,7 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   NSInteger _pendingDetentIndex;
   NSInteger _displayedBackgroundIndex;
   BOOL _usesBackgroundEffects;
+  BOOL _refusedPanDismiss;
 
   // Present/dismiss tracking: a display link scoped to the transition
   // coordinator — started alongside the transition, stopped in its completion.
@@ -109,11 +114,23 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   UIView *_anchorView;
 
   __weak UIWindow *_accessibilityWindow;
+  BOOL _appliedAccessibilityFooterElements;
 
   TrueSheetBlurView *_blurView;
   TrueSheetGrabberView *_grabberView;
   TrueSheetDetentCalculator *_detentCalculator;
   TrueSheetDimView *_dimView;
+
+  // Foldable hinge (iOS 27.1+). Tabletop resolves on demand from the window's
+  // division region; these track the last applied posture to detect changes.
+  BOOL _hingeStateKnown;
+  CGFloat _hingeEdge;
+  NSInteger _hingeRestoreIndex;
+  NSInteger _hingeCorrections;
+  // Offset learned at the hinge, shared by every hinge-placed detent
+  CGFloat _hingeOffset;
+  // Offset each hinge-placed detent last resolved with, checked on settle
+  NSMutableDictionary<NSNumber *, NSNumber *> *_hingeOffsets;
 }
 
 #pragma mark - Initialization
@@ -148,6 +165,8 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
     _pendingDetentIndex = -1;
 
     _insetAdjustment = TrueSheetViewInsetAdjustment::Automatic;
+    _hingeRestoreIndex = -1;
+    _hingeOffsets = [NSMutableDictionary dictionary];
     _detentCalculator = [[TrueSheetDetentCalculator alloc] init];
     _detentCalculator.delegate = self;
   }
@@ -234,14 +253,22 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   return self.currentPosition + (presentationY - modelY) + containerTy;
 }
 
+// Some callers run before this controller's view is attached (e.g. mid-presentation
+// detent resolution), so fall back to the presenter's window.
+- (UIWindow *)hostWindow {
+  return self.view.window ?: self.presentingViewController.view.window;
+}
+
 - (CGFloat)screenHeight {
   // In a windowed iPad app (Stage Manager, iPadOS 26 windowing) the window can be shorter than
-  // UIScreen.mainScreen, so prefer the window's height. Some callers run before this controller's
-  // view is attached (e.g. mid-presentation detent resolution), so fall back to the presenter's.
-  UIWindow *window = self.view.window ?: self.presentingViewController.view.window;
+  // UIScreen.mainScreen, so prefer the window's height.
+  UIWindow *window = self.hostWindow;
   return window ? window.bounds.size.height : UIScreen.mainScreen.bounds.size.height;
 }
 
+// Gap UIKit leaves between a floating sheet (iOS 26+) and the screen's bottom edge
+static const CGFloat TrueSheetFloatingSheetInset = 8;
+
 // Only phone sheets absorb the bottom safe-area inset — non-phone idioms
 // (iPad form sheets) are inset from the screen edge by UIKit.
 static BOOL TrueSheetIsPhoneIdiom(void) {
@@ -443,6 +470,20 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   _grabberView = [[TrueSheetGrabberView alloc] init];
   _grabberView.hidden = YES;
   [_grabberView addToView:self.view];
+
+#if RNTS_IPHONE_OS_VERSION_AVAILABLE(27_1)
+  if (@available(iOS 27.1, *)) {
+    __weak __typeof(self) weakSelf = self;
+    UIHingeInteraction *hingeInteraction =
+      [[UIHingeInteraction alloc] initWithUpdateHandler:^(UIHingeInteraction *_, UIHingeInteractionUpdate *__) {
+        // Next run loop, so the division region reflects the new posture
+        dispatch_async(dispatch_get_main_queue(), ^{
+          [weakSelf updateHingeState];
+        });
+      }];
+    [self.view addInteraction:hingeInteraction];
+  }
+#endif
 }
 
 #pragma mark - Custom Dimming
@@ -521,6 +562,11 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
 
     [self setupDimView];
 
+    // A new presentation records the posture it starts in
+    _hingeStateKnown = NO;
+    _hingeRestoreIndex = -1;
+    _hingeOffset = 0;
+
     // UIKit hides the presenter's keyboard under a sheet dimmed at every detent and
     // brings it back on dismiss, but custom dimming leaves the native sheet undimmed.
     if ([self useCustomDimming] && [self isDimmedAtEveryDetent]) {
@@ -558,6 +604,9 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
 
       [self->_grabberView updateAccessibilityValueWithIndex:index detentCount:self->_detents.count];
       [self settleAtDetentIndex:index debug:@"did present"];
+
+      // Apply a posture change that happened while presenting
+      [self updateHingeState];
     });
 
     [self setupGestureRecognizer];
@@ -606,6 +655,34 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   [self setAccessibilityContentElement:contentView];
 }
 
+// Only the topmost sheet may refresh, or it would steal the window
+// accessibility override from the child presented over it.
+- (BOOL)canRefreshAccessibilityContainer {
+  return _isPresented && !self.isBeingDismissed && self.isTopmostPresentedController;
+}
+
+- (void)refreshAccessibilityContainer {
+  if (self.canRefreshAccessibilityContainer) {
+    [self setupAccessibilityContainer];
+  }
+}
+
+- (void)refreshAccessibilityContainerIfFooterChanged {
+  // Only a dimmed sheet's boundary depends on the footer
+  if (!_dimmed || !self.canRefreshAccessibilityContainer) {
+    return;
+  }
+
+  UIView *contentView = self.accessibilityContentView;
+  if (![contentView isKindOfClass:[TrueSheetContainerView class]] ||
+      [(TrueSheetContainerView *)contentView hasAccessibilityFooterElements] == _appliedAccessibilityFooterElements) {
+    return;
+  }
+
+  [self setAccessibilityContentElement:contentView];
+  UIAccessibilityPostNotification(UIAccessibilityLayoutChangedNotification, nil);
+}
+
 - (UIViewController *)accessibilityPresentingViewController {
   UIViewController *presentingViewController = self.presentingViewController;
   while ([presentingViewController isKindOfClass:[TrueSheetViewController class]] &&
@@ -679,6 +756,7 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   // Footer controls exposed as separate accessibility elements can be skipped
   // by XCTest when the presented sheet is a hard modal accessibility boundary.
   BOOL isAccessibilityModal = _dimmed && !hasAccessibilityFooterElements;
+  _appliedAccessibilityFooterElements = hasAccessibilityFooterElements;
 
   // At a hard modal boundary XCTest skips nested elements, so flatten the
   // container's children into the array. Otherwise expose the container itself:
@@ -820,13 +898,20 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
                      }];
   }
 
-  // Dispatch to allow pan gesture to set _isDragging before checking;
-  // the transition tracker emits when the sheet is transitioning to dismiss
-  dispatch_async(dispatch_get_main_queue(), ^{
-    if (!self->_isDragging) {
-      [self emitWillDismissEvents];
-    }
-  });
+  // A swipe can still be cancelled, so emit once it commits on release. Any
+  // other dismiss (programmatic, outside tap, navigation) is already committed.
+  id<UIViewControllerTransitionCoordinator> coordinator = self.transitionCoordinator;
+  if (coordinator.isInteractive) {
+    __weak __typeof(self) weakSelf = self;
+    [coordinator
+      notifyWhenInteractionChangesUsingBlock:^(id<UIViewControllerTransitionCoordinatorContext> _Nonnull context) {
+        if (!context.isCancelled) {
+          [weakSelf emitWillDismissEvents];
+        }
+      }];
+  } else {
+    [self emitWillDismissEvents];
+  }
 
   [self setupTransitionTracker];
 }
@@ -846,6 +931,7 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   // the footer out of the auto detent.
   _keyboardSheetGrown = NO;
   _keyboardHeight = 0;
+  _minimizedKeyboardOverlap = 0;
 
   [self emitDidDismissEvents];
 }
@@ -902,7 +988,10 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
       animateAlongsideTransition:^(id<UIViewControllerTransitionCoordinatorContext> context) {
         [self.sheet invalidateDetents];
       }
-                      completion:nil];
+      completion:^(id<UIViewControllerTransitionCoordinatorContext> context) {
+        // Rotating a half-open foldable swaps between book and tabletop
+        [self updateHingeState];
+      }];
   }
 }
 
@@ -943,6 +1032,10 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
     }
   }
 
+  // The hinge callback can run before the division region updates; the
+  // relayout UIKit does for the posture change always sees the new region.
+  [self updateHingeState];
+
   if (_pendingDetentIndex >= 0) {
     NSInteger pendingIndex = _pendingDetentIndex;
     _pendingDetentIndex = -1;
@@ -1118,13 +1211,6 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   CGFloat position = self.livePosition;
 
   if (self.isBeingDismissed) {
-    // Emit only once the dismiss is committed: on release UIKit moves the
-    // model frame off-screen, while a cancelled drag rewinds it back to the
-    // detent (isBeingDismissed stays YES during the rewind).
-    if (self.currentPosition >= self.screenHeight) {
-      [self emitWillDismissEvents];
-    }
-
     // Hide blur at the end of dismiss to prevent UIVisualEffectView
     // from causing a flicker/flash at the bottom edge of the sheet.
     if (self.screenHeight - position < 1) {
@@ -1145,6 +1231,7 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   // measured frame; the next unobstructed settle learns.
   if (self.presentedViewController == nil) {
     [self learnOffsetForDetentIndex:index];
+    [self correctHingeOffsetForIndex:index];
   }
 
   [self emitChangePositionDelegateWithPosition:self.currentPosition realtime:NO debug:debug];
@@ -1304,7 +1391,7 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
 }
 
 - (void)learnOffsetForDetentIndex:(NSInteger)index {
-  if (_keyboardSheetGrown) {
+  if (_keyboardSheetGrown || _minimizedKeyboardOverlap > 0) {
     return;
   }
   [_detentCalculator learnOffsetForDetentIndex:index];
@@ -1338,6 +1425,146 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   return [_detentCalculator detentValueForIndex:index];
 }
 
+#pragma mark - Hinge
+
+/**
+ * Bottom edge (window coordinates) of an active horizontal fold, or 0 when the
+ * device isn't in tabletop. The division region is only active while the hinge
+ * is partially open, so this also excludes flat and closed postures.
+ */
+- (CGFloat)tabletopHingeEdge {
+#if RNTS_IPHONE_OS_VERSION_AVAILABLE(27_1)
+  if (@available(iOS 27.1, *)) {
+    UIWindow *window = self.hostWindow;
+    for (UIViewReservedRegion *region in [window reservedRegionsOfKind:[UIViewReservedRegionKind divisionRegionKind]]) {
+      CGRect frame = region.frame;
+      if (region.isActive && frame.size.width > frame.size.height) {
+        return CGRectGetMaxY(frame);
+      }
+    }
+  }
+#endif
+  return 0;
+}
+
+/**
+ * Gap between a hinge-placed detent's resolved height and the sheet's actual top
+ * edge: UIKit adds the bottom safe area, plus the floating sheet's inset. Every
+ * hinge-placed detent rests at the same height, so they share one offset — the
+ * first settle at the hinge learns it.
+ */
+- (CGFloat)hingeOffsetForHeight:(CGFloat)height {
+  if (_hingeOffset > 0) {
+    return _hingeOffset;
+  }
+
+  return [self bottomSafeAreaForHeight:height] + TrueSheetFloatingSheetInset;
+}
+
+// A hinge-placed detent resolved with an off estimate lands a few points off
+// the hinge — re-resolve once the settle has learned the real offset.
+- (void)correctHingeOffsetForIndex:(NSInteger)index {
+  NSNumber *usedOffset = _hingeOffsets[@(index)];
+  if (!usedOffset || _hingeCorrections >= 2) {
+    return;
+  }
+
+  CGFloat learnedOffset = [_detentCalculator learnedOffsetForIndex:index];
+  if (learnedOffset == 0 || fabs(learnedOffset - usedOffset.doubleValue) <= 1) {
+    return;
+  }
+
+  _hingeOffset = learnedOffset;
+  _hingeCorrections++;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [self invalidateDetentsAnimated];
+  });
+}
+
+- (void)invalidateDetentsAnimated {
+  if (@available(iOS 16.0, *)) {
+    [self.sheet animateChanges:^{
+      self->_pendingContentSizeChange = YES;
+      [self.sheet invalidateDetents];
+    }];
+  }
+}
+
+/**
+ * Re-resolves hinge-placed detents when the posture changes, and runs 'snap':
+ * entering tabletop moves the sheet to the hinge detent, leaving it restores the
+ * previous detent if the sheet is still on the hinge. The posture a presentation
+ * starts in only records state, so presenting while already in tabletop doesn't
+ * jump the sheet. A change while presenting, dismissing, or dragging stays
+ * pending until the sheet is at rest again.
+ */
+- (void)updateHingeState {
+  NSInteger hingeIndex = self.foldOptions.hingeDetentIndex;
+  if (hingeIndex < 0 && self.foldOptions.hingeBehavior == TrueSheetViewHingeBehavior::None) {
+    return;
+  }
+
+  // Covered by a full-screen presentation, the sheet has no window to read the posture from
+  if (!self.viewIfLoaded.window) {
+    return;
+  }
+
+  CGFloat edge = [self tabletopHingeEdge];
+  if (!_hingeStateKnown) {
+    _hingeStateKnown = YES;
+    _hingeEdge = edge;
+    return;
+  }
+
+  if (!self.isPresented || self.isBeingDismissed || _isDragging || fabs(edge - _hingeEdge) < 0.5) {
+    return;
+  }
+
+  BOOL entered = edge > 0 && _hingeEdge == 0;
+  BOOL left = edge == 0 && _hingeEdge > 0;
+  _hingeEdge = edge;
+  _hingeOffset = 0;
+  _hingeCorrections = 0;
+
+  NSInteger targetIndex = -1;
+  NSInteger detentCount = (NSInteger)self.detents.count;
+  BOOL snaps =
+    self.foldOptions.hingeBehavior == TrueSheetViewHingeBehavior::Snap && hingeIndex >= 0 && hingeIndex < detentCount;
+  if (entered && snaps) {
+    _hingeRestoreIndex = self.currentDetentIndex;
+    targetIndex = hingeIndex;
+  } else if (left && _hingeRestoreIndex >= 0) {
+    // Keep a detent the user picked while folded
+    if (snaps && self.currentDetentIndex == hingeIndex) {
+      targetIndex = MIN(_hingeRestoreIndex, detentCount - 1);
+    }
+    _hingeRestoreIndex = -1;
+  }
+
+  // A resize settles through the pending detent change
+  BOOL resizes = targetIndex >= 0 && targetIndex != self.activeDetentIndex;
+
+  if (@available(iOS 16.0, *)) {
+    [self.sheet animateChanges:^{
+      [self.sheet invalidateDetents];
+      if (resizes) {
+        [self resizeToDetentIndex:targetIndex];
+      }
+    }];
+  }
+
+  // UIKit often re-resolves detents for the posture change on its own before
+  // this runs, so the invalidation above triggers no layout pass to settle in.
+  // Settle once the frame is final, same as a pending detent change.
+  if (!resizes) {
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+      if (self.isPresented && !self.isBeingDismissed && !self->_isDragging && !self->_isTransitioning) {
+        [self settleAtDetentIndex:self.currentDetentIndex debug:@"hinge"];
+      }
+    });
+  }
+}
+
 #pragma mark - Sheet Configuration
 
 /**
@@ -1359,12 +1586,19 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
     _autoDetentHeight = autoHeight;
     _peekDetentHeight = peekHeight;
 
+    [self invalidateDetentsAnimated];
+  }
+  // iOS 15: detents are fixed medium/large — size changes can't affect them.
+}
+
+// Re-resolves the detents in place, e.g. when an input to the resolver
+// changes after UIKit has already laid out the sheet.
+- (void)invalidateDetents {
+  if (@available(iOS 16.0, *)) {
     [self.sheet animateChanges:^{
-      self->_pendingContentSizeChange = YES;
       [self.sheet invalidateDetents];
     }];
   }
-  // iOS 15: detents are fixed medium/large — size changes can't affect them.
 }
 
 - (void)setupSheetDetentsForDetentsChange {
@@ -1381,6 +1615,7 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
 
   NSMutableArray<UISheetPresentationControllerDetent *> *detents = [NSMutableArray array];
   [_detentCalculator clearResolvedHeights];
+  _hingeCorrections = 0;
 
   _autoDetentHeight = [_detentCalculator autoHeightForKeyboardHeight:_keyboardHeight];
   _peekDetentHeight = [_detentCalculator peekHeight];
@@ -1503,24 +1738,66 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
                                              : maxDetentValue;
 
                         CGFloat adjustedHeight = height - bottomAdjustment;
+                        NSInteger lastIndex = (NSInteger)self.detents.count - 1;
+
+                        // Tabletop: the hinge detent rests on the hinge, and 'avoid'/'snap'
+                        // cap every detent there.
+                        BOOL avoidsHinge = self.foldOptions.hingeBehavior != TrueSheetViewHingeBehavior::None;
+                        NSInteger hingeIndex = self.foldOptions.hingeDetentIndex;
+                        BOOL hasHingeDetent = hingeIndex >= 0 && hingeIndex <= lastIndex;
+                        CGFloat hingeEdge = (hasHingeDetent || avoidsHinge) ? [self tabletopHingeEdge] : 0;
+                        CGFloat hingeOffset = 0;
+                        CGFloat hingeHeight = 0;
+                        if (hingeEdge > 0) {
+                          CGFloat panelHeight = self.screenHeight - hingeEdge;
+                          hingeOffset = [self hingeOffsetForHeight:panelHeight];
+                          hingeHeight = panelHeight - hingeOffset;
+                          if (hasHingeDetent) {
+                            // Lower detents stay below the hinge detent and higher ones above
+                            // it, so the detents keep their order
+                            CGFloat hingeDetentHeight =
+                              avoidsHinge ? hingeHeight - (lastIndex - hingeIndex) : hingeHeight;
+                            if (index == hingeIndex) {
+                              adjustedHeight = hingeHeight;
+                            } else if (index < hingeIndex) {
+                              adjustedHeight = fmin(adjustedHeight, hingeDetentHeight - (hingeIndex - index));
+                            } else {
+                              adjustedHeight = fmax(adjustedHeight, hingeDetentHeight + (index - hingeIndex));
+                            }
+                          }
+                          if (avoidsHinge) {
+                            maxValue = fmin(maxValue, hingeHeight);
+                          }
+                        }
 
                         // Only the last detent may occupy the full maximum. Two detents
                         // resolving to the same height (e.g. a capped auto and 1) make
                         // UIKit skip the stack's deck animation when presenting a child
                         // sheet and snap the sheet behind into place instead.
-                        NSInteger lastIndex = (NSInteger)self.detents.count - 1;
                         if (adjustedHeight >= maxValue && index < lastIndex) {
                           maxValue -= lastIndex - index;
                         }
 
                         CGFloat resolved = fmin(adjustedHeight, maxValue);
 
+                        // Detents within the collapse spacing of the hinge are hinge-placed.
+                        // They rest with the hinge offset, so position events map them right
+                        // before the first settle there.
+                        if (hingeHeight > 0 && fabs(resolved - hingeHeight) <= lastIndex + 0.5) {
+                          self->_hingeOffsets[@(index)] = @(hingeOffset);
+                          [self->_detentCalculator assumeOffset:hingeOffset forIndex:index];
+                        } else {
+                          [self->_hingeOffsets removeObjectForKey:@(index)];
+                        }
+
                         NSMutableArray *heights = self->_detentCalculator.resolvedDetentHeights;
                         if (heights && index >= 0 && index < (NSInteger)heights.count) {
                           heights[index] = @(resolved);
                         }
 
-                        return resolved;
+                        // Recorded uncompensated above: UIKit adds the overlap back on
+                        // top. A sheet shorter than the overlap still grows by the rest.
+                        return fmax(resolved - self.minimizedKeyboardOverlap, 0);
                       }];
 }
 
@@ -1716,11 +1993,7 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
     _grabberView.onDecrement = nil;
   }
 
-  // Only the topmost sheet may refresh, or a parent's prop update would steal the
-  // window accessibility override from the child presented over it.
-  if (_isPresented && self.isTopmostPresentedController) {
-    [self setupAccessibilityContainer];
-  }
+  [self refreshAccessibilityContainer];
 }
 
 - (void)handleGrabberTap {
@@ -1861,13 +2134,43 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
 #pragma mark - UISheetPresentationControllerDelegate
 
 - (BOOL)presentationControllerShouldDismiss:(UIPresentationController *)presentationController {
-  return self.dismissible;
+  // A sheet that can't be dragged can't be swiped away either, including by
+  // pulling down its scroll view: refuse a dismissal while any pan is under
+  // way, and keep the one from a tap outside the sheet. Reset on every call:
+  // UIKit skips didAttemptToDismiss for a short pull.
+  _refusedPanDismiss =
+    self.dismissible && !self.draggable && [self hasActivePanInView:presentationController.containerView];
+  return self.dismissible && !_refusedPanDismiss;
+}
+
+- (BOOL)hasActivePanInView:(UIView *)view {
+  if (!view) {
+    return NO;
+  }
+  for (UIGestureRecognizer *recognizer in view.gestureRecognizers ?: @[]) {
+    if ([recognizer isKindOfClass:[UIPanGestureRecognizer class]] &&
+        (recognizer.state == UIGestureRecognizerStateBegan || recognizer.state == UIGestureRecognizerStateChanged)) {
+      return YES;
+    }
+  }
+  for (UIView *subview in view.subviews) {
+    if ([self hasActivePanInView:subview]) {
+      return YES;
+    }
+  }
+  return NO;
 }
 
 // UIKit calls this after shouldDismiss returns NO — the sheet has already
 // bounced back, so JS can confirm and dismiss programmatically (Apple's
 // unsaved-changes pattern).
 - (void)presentationControllerDidAttemptToDismiss:(UIPresentationController *)presentationController {
+  // A swipe refused only because the sheet can't be dragged isn't an attempt
+  // to dismiss a non-dismissible sheet.
+  if (_refusedPanDismiss) {
+    _refusedPanDismiss = NO;
+    return;
+  }
   [self.delegate viewControllerDidAttemptDismiss];
 }
 

package/ios/core/TrueSheetDetentCalculator.h

@@ -76,6 +76,17 @@ NS_ASSUME_NONNULL_BEGIN
  */
 - (CGFloat)resolvedHeightForIndex:(NSInteger)index;
 
+/**
+ Returns the offset learned for this detent itself, or 0 when none is learned.
+ */
+- (CGFloat)learnedOffsetForIndex:(NSInteger)index;
+
+/**
+ Sets the offset this detent is expected to rest with, unless its learned
+ offset is already within a point of it.
+ */
+- (void)assumeOffset:(CGFloat)offset forIndex:(NSInteger)index;
+
 /**
  Finds the segment between detents for a given position.
  Returns YES if position is between two detents, NO if at edges.

package/ios/core/TrueSheetDetentCalculator.mm

@@ -80,13 +80,25 @@
   return detentValue * self.delegate.screenHeight;
 }
 
-- (CGFloat)offsetForIndex:(NSInteger)index {
-  // Use this detent's own offset if available
+- (CGFloat)learnedOffsetForIndex:(NSInteger)index {
   if (index >= 0 && index < (NSInteger)_resolvedDetentOffsets.count) {
-    CGFloat offset = [_resolvedDetentOffsets[index] doubleValue];
-    if (offset != 0)
-      return offset;
+    return [_resolvedDetentOffsets[index] doubleValue];
+  }
+  return 0;
+}
+
+- (void)assumeOffset:(CGFloat)offset forIndex:(NSInteger)index {
+  if (index >= 0 && index < (NSInteger)_resolvedDetentOffsets.count &&
+      fabs([_resolvedDetentOffsets[index] doubleValue] - offset) > 1) {
+    _resolvedDetentOffsets[index] = @(offset);
   }
+}
+
+- (CGFloat)offsetForIndex:(NSInteger)index {
+  // Use this detent's own offset if available
+  CGFloat learnedOffset = [self learnedOffsetForIndex:index];
+  if (learnedOffset != 0)
+    return learnedOffset;
 
   // Fall back to any known offset
   for (NSInteger i = 0; i < (NSInteger)_resolvedDetentOffsets.count; i++) {