@lodev09/react-native-true-sheet 4.0.0-beta.1 → 4.0.0-beta.3

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

@@ -15,6 +15,7 @@ import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.events.EventDispatcher
 import com.facebook.react.views.view.ReactViewGroup
 import com.lodev09.truesheet.core.TrueSheetCoordinatorLayout
+import com.lodev09.truesheet.utils.TouchEventDeduper
 
 /**
  * Delegate interface for footer view size changes and event dispatching
@@ -91,6 +92,7 @@ class TrueSheetFooterView(private val reactContext: ThemedReactContext) :
 
   private val jsTouchDispatcher = JSTouchDispatcher(this)
   private var jsPointerDispatcher: JSPointerDispatcher? = null
+  private val touchDeduper = TouchEventDeduper()
 
   init {
     jsPointerDispatcher = JSPointerDispatcher(this)
@@ -110,7 +112,9 @@ class TrueSheetFooterView(private val reactContext: ThemedReactContext) :
 
   override fun onInterceptTouchEvent(event: MotionEvent): Boolean {
     eventDispatcher?.let { dispatcher ->
-      jsTouchDispatcher.handleTouchEvent(event, dispatcher, reactContext)
+      if (touchDeduper.shouldDispatch(event)) {
+        jsTouchDispatcher.handleTouchEvent(event, dispatcher, reactContext)
+      }
       jsPointerDispatcher?.handleMotionEvent(event, dispatcher, true)
     }
     return super.onInterceptTouchEvent(event)
@@ -128,7 +132,9 @@ class TrueSheetFooterView(private val reactContext: ThemedReactContext) :
     }
 
     eventDispatcher?.let { dispatcher ->
-      jsTouchDispatcher.handleTouchEvent(event, dispatcher, reactContext)
+      if (touchDeduper.shouldDispatch(event)) {
+        jsTouchDispatcher.handleTouchEvent(event, dispatcher, reactContext)
+      }
       jsPointerDispatcher?.handleMotionEvent(event, dispatcher, false)
     }
     super.onTouchEvent(event)

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

@@ -101,13 +101,30 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
 
   override fun onAttachedToWindow() {
     super.onAttachedToWindow()
+    presentInitialIfNeeded()
+  }
 
-    if (initialDetentIndex >= 0 && !didInitiallyPresent) {
-      didInitiallyPresent = true
-      if (initialDetentAnimated) {
-        present(initialDetentIndex, true) { }
-      } else {
-        post { present(initialDetentIndex, false) { } }
+  /**
+   * JS holds initialDetentIndex back one commit so effect-driven content (e.g. a
+   * navigation footer set via setOptions) commits together with it. The prop then
+   * arrives after attach, so the ViewManager triggers this on prop update too.
+   * Posted so sibling mounts from the current transaction land before measuring.
+   */
+  fun presentInitialIfNeeded() {
+    if (initialDetentIndex < 0 || didInitiallyPresent || !isAttachedToWindow) return
+
+    didInitiallyPresent = true
+    post {
+      // The view may have been dropped (flag reset) or detached before this
+      // ran — roll back so a later attach retries instead of presenting a
+      // sheet with no live host.
+      if (!didInitiallyPresent) return@post
+      if (!isAttachedToWindow) {
+        didInitiallyPresent = false
+        return@post
+      }
+      if (!viewController.isPresented) {
+        present(initialDetentIndex, initialDetentAnimated) { }
       }
     }
   }

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

@@ -39,6 +39,7 @@ import com.lodev09.truesheet.core.TrueSheetKeyboardObserverDelegate
 import com.lodev09.truesheet.core.TrueSheetStackManager
 import com.lodev09.truesheet.utils.KeyboardUtils
 import com.lodev09.truesheet.utils.ScreenUtils
+import com.lodev09.truesheet.utils.TouchEventDeduper
 
 // =============================================================================
 // MARK: - Data Types & Delegate Protocol
@@ -199,6 +200,8 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   // the finger drifts outside the footer's rect mid-gesture.
   private var footerOwnsTouchStream = false
 
+  private val touchDeduper = TouchEventDeduper()
+
   private val eventDispatcher
     get() = delegate?.eventDispatcher
 
@@ -1419,7 +1422,9 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
   override fun onInterceptTouchEvent(event: MotionEvent): Boolean {
     eventDispatcher?.let {
-      jsTouchDispatcher.handleTouchEvent(event, it, reactContext)
+      if (touchDeduper.shouldDispatch(event)) {
+        jsTouchDispatcher.handleTouchEvent(event, it, reactContext)
+      }
       jsPointerDispatcher.handleMotionEvent(event, it, true)
     }
     return super.onInterceptTouchEvent(event)
@@ -1433,7 +1438,9 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
   override fun onTouchEvent(event: MotionEvent): Boolean {
     eventDispatcher?.let {
-      jsTouchDispatcher.handleTouchEvent(event, it, reactContext)
+      if (touchDeduper.shouldDispatch(event)) {
+        jsTouchDispatcher.handleTouchEvent(event, it, reactContext)
+      }
       jsPointerDispatcher.handleMotionEvent(event, it, false)
     }
     super.onTouchEvent(event)

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

@@ -179,6 +179,7 @@ class TrueSheetViewManager :
   @ReactProp(name = "initialDetentIndex", defaultInt = -1)
   override fun setInitialDetentIndex(view: TrueSheetView, index: Int) {
     view.initialDetentIndex = index
+    view.presentInitialIfNeeded()
   }
 
   @ReactProp(name = "initialDetentAnimated", defaultBoolean = true)

package/android/src/main/java/com/lodev09/truesheet/utils/TouchEventDeduper.kt

@@ -0,0 +1,31 @@
+package com.lodev09.truesheet.utils
+
+import android.view.MotionEvent
+
+/**
+ * Guards a nested RootView against dispatching the same [MotionEvent] to JS twice.
+ *
+ * An event that no child consumes reaches both `onInterceptTouchEvent` and `onTouchEvent`,
+ * so dispatching from both starts a second JS touch stream for the same gesture.
+ *
+ * A plain root can live with that, but the sheet's roots are nested: touches that hit no
+ * React child resolve to the root's own tag, and the second stream then finds that view
+ * already holding the responder, so React only asks its ancestors - handing the touch to
+ * touchables outside the sheet.
+ */
+internal class TouchEventDeduper {
+  private var downTime = Long.MIN_VALUE
+  private var eventTime = Long.MIN_VALUE
+  private var action = -1
+
+  fun shouldDispatch(event: MotionEvent): Boolean {
+    if (event.downTime == downTime && event.eventTime == eventTime && event.action == action) {
+      return false
+    }
+
+    downTime = event.downTime
+    eventTime = event.eventTime
+    action = event.action
+    return true
+  }
+}

package/common/cpp/react/renderer/components/TrueSheetSpec/TrueSheetFooterViewShadowNode.cpp

@@ -25,6 +25,13 @@ void TrueSheetFooterViewShadowNode::adjustLayoutWithState() {
   float bottomInset = stateData.bottomInset;
   if (!stateData.initialized && props.autoBottomInset) {
     bottomInset = TrueSheetInsets::bottomSafeArea();
+    if (bottomInset != stateData.bottomInset) {
+      // Record the seeded value so the mounted view reads exactly the inset
+      // baked into this layout — the global may change before mount.
+      auto seededData = stateData;
+      seededData.bottomInset = bottomInset;
+      setStateData(std::move(seededData));
+    }
   }
 
   // A footer pinned to the sheet's bottom edge owns the bottom safe-area

package/ios/TrueSheetContainerView.h

@@ -82,6 +82,11 @@ NS_ASSUME_NONNULL_BEGIN
  */
 - (CGFloat)footerHeight;
 
+/**
+ * Returns the bottom inset currently baked into the footer's height
+ */
+- (CGFloat)footerAppliedBottomInset;
+
 /**
  * Returns the current height of the peek view within the content
  */

package/ios/TrueSheetContainerView.mm

@@ -118,6 +118,10 @@ using namespace facebook::react;
   return _footerView ? _footerView.frame.size.height : 0;
 }
 
+- (CGFloat)footerAppliedBottomInset {
+  return _footerView ? _footerView.appliedBottomInset : 0;
+}
+
 // Distance from the top of the content view to the bottom of the peek view.
 // Includes the peek view's offset within the content (padding, views above it)
 // so the peek detent reveals everything down to the peek content's bottom edge.

package/ios/TrueSheetFooterView.h

@@ -27,6 +27,12 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, weak, nullable) TrueSheetKeyboardObserver *keyboardObserver;
 @property (nonatomic, weak, nullable) id<TrueSheetFooterViewDelegate> delegate;
 
+/**
+ * Bottom inset currently baked into the footer's layout height — pairs with
+ * the measured frame so detent math can subtract exactly what's baked in.
+ */
+@property (nonatomic, readonly) CGFloat appliedBottomInset;
+
 /**
  * Re-applies the footer's keyboard slide using the current keyboard height.
  * No-op when the keyboard is hidden. Used to reflect live `keyboardOffset` changes.

package/ios/TrueSheetFooterView.mm

@@ -25,6 +25,8 @@ using namespace facebook::react;
   CGFloat _currentKeyboardOffset;
   CGFloat _bottomInset;
   BOOL _keyboardVisible;
+  BOOL _didPushBottomInset;
+  CGFloat _appliedBottomInset;
 }
 
 + (ComponentDescriptorProvider)componentDescriptorProvider {
@@ -43,6 +45,8 @@ using namespace facebook::react;
     _currentKeyboardOffset = 0;
     _bottomInset = 0;
     _keyboardVisible = NO;
+    _didPushBottomInset = NO;
+    _appliedBottomInset = 0;
   }
   return self;
 }
@@ -55,7 +59,11 @@ using namespace facebook::react;
 // bottom safe-area inset — the footer owns the sheet's bottom edge, so it
 // absorbs the inset and its background fills it.
 - (void)setBottomInset:(CGFloat)bottomInset {
-  if (_bottomInset == bottomInset) {
+  // The first push must go through even when the value matches the ivar
+  // default (0) — it marks the state initialized so the shadow node stops
+  // seeding from the app-wide precalculated inset, which may belong to
+  // another sheet (e.g. a floating sheet whose real inset is 0).
+  if (_didPushBottomInset && _bottomInset == bottomInset) {
     return;
   }
   _bottomInset = bottomInset;
@@ -85,6 +93,14 @@ using namespace facebook::react;
   // them an inset stale (same reason Android bridges through
   // TrueSheetStateUpdater).
   _state->updateState(std::move(newState), EventQueue::UpdateMode::unstable_Immediate);
+  _didPushBottomInset = YES;
+}
+
+// The inset baked into the current layout by the shadow node (pushed or
+// seeded — see TrueSheetFooterViewShadowNode). Refreshed in
+// updateLayoutMetrics so it always pairs with the measured height.
+- (CGFloat)appliedBottomInset {
+  return _appliedBottomInset;
 }
 
 // Height the footer occupies above the keyboard — its layout height minus the
@@ -123,8 +139,19 @@ using namespace facebook::react;
            oldLayoutMetrics:(const facebook::react::LayoutMetrics &)oldLayoutMetrics {
   [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
 
+  // State lands before layout metrics within the same mount transaction, so
+  // this reflects the inset the shadow node baked into this frame — seeded
+  // values are recorded back into the state at layout time (see
+  // TrueSheetFooterViewShadowNode).
+  CGFloat previousAppliedBottomInset = _appliedBottomInset;
+  if (_state) {
+    _appliedBottomInset = _state->getData().bottomInset;
+  }
+
   CGFloat height = layoutMetrics.frame.size.height;
-  if (height != _lastHeight) {
+  // An inset change alone (fixed-height footer: padding moves, frame doesn't)
+  // still changes what's baked in — report so the controller re-pairs.
+  if (height != _lastHeight || _appliedBottomInset != previousAppliedBottomInset) {
     _lastHeight = height;
     [self.delegate footerViewDidChangeSize:CGSizeMake(layoutMetrics.frame.size.width, height)];
   }
@@ -143,6 +170,8 @@ using namespace facebook::react;
   _currentKeyboardOffset = 0;
   _bottomInset = 0;
   _keyboardVisible = NO;
+  _didPushBottomInset = NO;
+  _appliedBottomInset = 0;
 }
 
 #pragma mark - TrueSheetKeyboardObserverDelegate

package/ios/TrueSheetView.mm

@@ -110,18 +110,47 @@ using namespace facebook::react;
     return;
   }
 
-  if (_initialDetentIndex >= 0 && !_didInitiallyPresent) {
-    UIViewController *vc = [self findPresentingViewController];
+  [self presentInitialIfNeeded];
+}
 
-    // Only present if the view controller is in the same window and not being dismissed
-    if (vc && vc.view.window == self.window && !_controller.isBeingDismissed) {
-      _didInitiallyPresent = YES;
-      [self presentAtIndex:_initialDetentIndex animated:_initialDetentAnimated completion:nil];
-    } else {
-      // Animate next time when sheet finally moves to the correct window
-      _initialDetentAnimated = YES;
-    }
+// JS holds initialDetentIndex back one commit so effect-driven content (e.g. a
+// navigation footer set via setOptions) commits together with it — by the time
+// the prop lands the tree is final and the sheet presents at its final height.
+// Called from didMoveToWindow (re-attach) and finalizeUpdates (the prop
+// arriving after attach, which didMoveToWindow won't re-fire for).
+- (void)presentInitialIfNeeded {
+  if (_initialDetentIndex < 0 || _didInitiallyPresent)
+    return;
+
+  UIViewController *vc = [self findPresentingViewController];
+
+  // Only present if the view controller is in the same window and not being dismissed
+  if (!vc || vc.view.window != self.window || _controller.isBeingDismissed) {
+    // Animate next time when sheet finally moves to the correct window
+    _initialDetentAnimated = YES;
+    return;
   }
+
+  _didInitiallyPresent = YES;
+
+  // Deferred a runloop turn so sibling mounts from the current transaction
+  // (e.g. a footer committed alongside the prop) land before measuring.
+  __weak __typeof(self) weakSelf = self;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    __typeof(self) strongSelf = weakSelf;
+    if (!strongSelf || strongSelf->_controller.isPresented || strongSelf->_controller.isBeingPresented)
+      return;
+
+    [strongSelf presentAtIndex:strongSelf->_initialDetentIndex
+                      animated:strongSelf->_initialDetentAnimated
+                    completion:^(BOOL success, NSError *_Nullable error) {
+                      // Present can fail if the view detached during this turn —
+                      // reset so the next attach/prop update retries.
+                      if (!success) {
+                        strongSelf->_didInitiallyPresent = NO;
+                      }
+                    }];
+  });
 }
 
 - (void)dealloc {
@@ -342,6 +371,9 @@ using namespace facebook::react;
     _pendingPropsUpdate = YES;
   } else if (_initialDetentIndex >= 0) {
     _pendingLayoutUpdate = NO;
+    if (self.window) {
+      [self presentInitialIfNeeded];
+    }
   }
 }
 
@@ -403,9 +435,8 @@ using namespace facebook::react;
     _controller.headerHeight = @(headerHeight);
   }
 
-  CGFloat footerHeight = [_containerView footerHeight];
-  if (footerHeight > 0) {
-    _controller.footerHeight = @(footerHeight);
+  if ([_containerView footerHeight] > 0) {
+    [self syncFooterMetrics];
   }
 
   CGFloat peekContentHeight = [_containerView peekContentHeight];
@@ -480,11 +511,12 @@ using namespace facebook::react;
   if (_containerView) {
     _controller.contentHeight = @([_containerView contentHeight]);
     _controller.headerHeight = @([_containerView headerHeight]);
-    _controller.footerHeight = @([_containerView footerHeight]);
+    [self syncFooterMetrics];
     _controller.peekContentHeight = @([_containerView peekContentHeight]);
   }
   _pendingSizeChange = NO;
 
+  [self refreshFooterBottomInset];
   [_controller setupSheetDetents];
   [_controller setupActiveDetentWithIndex:index];
 
@@ -583,6 +615,10 @@ using namespace facebook::react;
  * Debounced sheet update to handle rapid content/header size changes.
  */
 - (void)setupSheetDetentsForSizeChange {
+  // Keep the footer's absorbed inset in sync with the latest measured heights
+  // even before presenting, so the sheet presents at its final size.
+  [self refreshFooterBottomInset];
+
   // Retargeting the in-flight presentation makes UIKit snap the whole stack
   // (including the sheet behind) instead of animating. Defer to didPresent —
   // presentAtIndex measured synchronously, so this is usually a no-op.
@@ -610,6 +646,7 @@ using namespace facebook::react;
     // Refresh here (not just on peek size events) since the peek's offset
     // within the content can change without its own size changing.
     self->_controller.peekContentHeight = @([self->_containerView peekContentHeight]);
+    [self refreshFooterBottomInset];
     [self->_controller setupSheetDetentsForSizeChange];
   });
 }
@@ -625,7 +662,7 @@ using namespace facebook::react;
 }
 
 - (void)containerViewFooterDidChangeSize:(CGSize)newSize {
-  _controller.footerHeight = @(newSize.height);
+  [self syncFooterMetrics];
   [self setupSheetDetentsForSizeChange];
   [_controller setupAccessibilityContainer];
 }
@@ -716,6 +753,10 @@ using namespace facebook::react;
   [self updateStateWithSize:size];
 }
 
+- (void)viewControllerSafeAreaInsetsDidChange {
+  [self refreshFooterBottomInset];
+}
+
 - (void)viewControllerWillFocus {
   [TrueSheetFocusEvents emitWillFocus:_eventEmitter];
 }
@@ -784,13 +825,36 @@ using namespace facebook::react;
   _containerView.insetAdjustment = _insetAdjustment;
   _containerView.scrollableOptions = _scrollableOptions;
   _containerView.hasAutoDetent = _hasAutoDetent;
-  _containerView.footerBottomInset = _controller.footerBottomInset;
+  [self refreshFooterBottomInset];
   [_containerView setupScrollable];
+}
+
+// footerHeight and appliedFooterBottomInset must stay paired — detent math
+// subtracts exactly the inset baked into the measured footer height (see
+// autoDetentBottomInset/peekDetentBottomInset).
+- (void)syncFooterMetrics {
+  _controller.footerHeight = @([_containerView footerHeight]);
+  _controller.appliedFooterBottomInset = [_containerView footerAppliedBottomInset];
+}
+
+// Recomputes the inset the footer absorbs and pushes it down. The inset
+// depends on measured heights and detents (see maxNaturalDetentHeight), so
+// this runs on size and detent changes — not just prop updates.
+- (void)refreshFooterBottomInset {
+  if (!_containerView)
+    return;
+
+  // appliedFooterBottomInset is NOT set here — it tracks what's actually
+  // baked into the footer's measured height (reported with its layout), not
+  // what was just pushed. Setting it at push time desyncs the pair and lets
+  // a seeded inset read as natural content height (see maxNaturalDetentHeight).
+  CGFloat inset = _controller.footerBottomInset;
+  _containerView.footerBottomInset = inset;
 
   // Publish the inset so a footer set later (e.g. navigation setOptions) is
   // padded on its very first layout instead of resizing the sheet twice.
   if (_insetAdjustment == TrueSheetViewInsetAdjustment::Automatic) {
-    TrueSheetInsets::setBottomSafeArea(_controller.footerBottomInset);
+    TrueSheetInsets::setBottomSafeArea(inset);
   }
 }
 
@@ -801,6 +865,7 @@ using namespace facebook::react;
   if (_pendingDetents) {
     _controller.detents = _pendingDetents;
     _pendingDetents = nil;
+    [self refreshFooterBottomInset];
   }
 
   UIView *presenterView = _controller.presentingViewController.view;

package/ios/TrueSheetViewController.h

@@ -36,6 +36,7 @@ NS_ASSUME_NONNULL_BEGIN
                                  detent:(CGFloat)detent
                                realtime:(BOOL)realtime;
 - (void)viewControllerDidChangeSize:(CGSize)size;
+- (void)viewControllerSafeAreaInsetsDidChange;
 - (void)viewControllerWillFocus;
 - (void)viewControllerDidFocus;
 - (void)viewControllerWillBlur;
@@ -99,6 +100,14 @@ NS_ASSUME_NONNULL_BEGIN
  */
 @property (nonatomic, readonly) CGFloat footerBottomInset;
 
+/**
+ * The inset currently baked into the footer's measured height, reported
+ * alongside its layout (see TrueSheetFooterView.appliedBottomInset). Detent
+ * resolution subtracts this exact value so the baked inset is never
+ * double-counted.
+ */
+@property (nonatomic, assign) CGFloat appliedFooterBottomInset;
+
 - (void)setupAccessibilityContainer;
 - (void)applyActiveDetent;
 - (void)setupActiveDetentWithIndex:(NSInteger)index;