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

package/ios/TrueSheetFooterView.mm

@@ -67,7 +67,7 @@ using namespace facebook::react;
     return;
   }
   _bottomInset = bottomInset;
-  [self pushBottomInsetState];
+  [self pushStateWithMode:EventQueue::UpdateMode::unstable_Immediate];
 }
 
 // Skipped while the keyboard is open — an absolute footer rises above the
@@ -77,22 +77,36 @@ using namespace facebook::react;
     return;
   }
   _keyboardVisible = keyboardVisible;
-  [self pushBottomInsetState];
+  [self pushStateWithMode:EventQueue::UpdateMode::unstable_Immediate];
 }
 
-- (void)pushBottomInsetState {
+// The keyboard slide is a transform the shadow tree can't see — mirror it so
+// measure() (and Pressability's press region) match where the footer is drawn.
+// Async: no layout reads it.
+- (void)setKeyboardOffset:(CGFloat)keyboardOffset {
+  if (_currentKeyboardOffset == keyboardOffset) {
+    return;
+  }
+  _currentKeyboardOffset = keyboardOffset;
+  [self pushStateWithMode:EventQueue::UpdateMode::Asynchronous];
+}
+
+// Every push carries all fields — RN's EventQueue drops a still-queued update
+// for the same view when the next one is enqueued.
+- (void)pushStateWithMode:(EventQueue::UpdateMode)mode {
   if (!_state) {
     return;
   }
 
   TrueSheetFooterViewState newState;
   newState.bottomInset = _keyboardVisible ? 0 : _bottomInset;
+  newState.translateY = -_currentKeyboardOffset;
   newState.initialized = true;
-  // Immediate so the inset lands before anything reads the footer's height —
-  // the async path races the keyboard caret scroll and detent setup, leaving
-  // them an inset stale (same reason Android bridges through
-  // TrueSheetStateUpdater).
-  _state->updateState(std::move(newState), EventQueue::UpdateMode::unstable_Immediate);
+  // Inset changes go Immediate so they land before anything reads the
+  // footer's height — the async path races the keyboard caret scroll and
+  // detent setup, leaving them an inset stale (same reason Android bridges
+  // through TrueSheetStateUpdater).
+  _state->updateState(std::move(newState), mode);
   _didPushBottomInset = YES;
 }
 
@@ -123,6 +137,11 @@ using namespace facebook::react;
 
 - (void)collectAccessibilityElementsFromView:(UIView *)view into:(NSMutableArray *)elements {
   for (UIView *subview in view.subviews) {
+    // Fabric hides `display: none` views instead of unmounting them
+    if (subview.hidden) {
+      continue;
+    }
+
     if (subview.isAccessibilityElement || subview.accessibilityLabel || subview.accessibilityIdentifier) {
       [elements addObject:subview];
     } else if (subview.accessibilityElements.count > 0) {
@@ -137,7 +156,19 @@ using namespace facebook::react;
 
 - (void)updateLayoutMetrics:(const facebook::react::LayoutMetrics &)layoutMetrics
            oldLayoutMetrics:(const facebook::react::LayoutMetrics &)oldLayoutMetrics {
-  [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
+  // UIKit resizes the sheet for the keyboard inside its animation, and the new
+  // size usually relays out the footer in the same pass. When the keyboard
+  // changes during a React commit (e.g. its input unmounts), that layout can
+  // only mount after the commit, outside the animation — the footer, pinned to
+  // the container's bottom edge, would snap by the keyboard's height while the
+  // sheet is still animating. Carry it on the rest of the keyboard's curve.
+  if (layoutMetrics.frame.origin.y != oldLayoutMetrics.frame.origin.y) {
+    [self animateAlongKeyboard:^{
+      [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
+    }];
+  } else {
+    [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
@@ -155,6 +186,8 @@ using namespace facebook::react;
     _lastHeight = height;
     [self.delegate footerViewDidChangeSize:CGSizeMake(layoutMetrics.frame.size.width, height)];
   }
+
+  [self applyKeyboardOffset];
 }
 
 - (void)prepareForRecycle {
@@ -176,55 +209,127 @@ using namespace facebook::react;
 
 #pragma mark - TrueSheetKeyboardObserverDelegate
 
+- (void)setKeyboardObserver:(TrueSheetKeyboardObserver *)keyboardObserver {
+  [_keyboardObserver removeDelegate:self];
+  _keyboardObserver = keyboardObserver;
+  [keyboardObserver addDelegate:self];
+}
+
+- (void)animateAlongKeyboard:(void (^)(void))changes {
+  NSTimeInterval remaining = self.keyboardObserver.remainingAnimationDuration;
+  if (remaining > 0 && [UIView inheritedAnimationDuration] == 0) {
+    [UIView animateWithDuration:remaining
+                          delay:0
+                        options:self.keyboardObserver.animationCurve | UIViewAnimationOptionBeginFromCurrentState
+                     animations:^{
+                       changes();
+                       [self syncEdgeEffect];
+                     }
+                     completion:nil];
+  } else {
+    changes();
+  }
+}
+
+// Only an absolute footer floats above the keyboard — a relative footer stays
+// in the layout flow behind it, and an absolute one opts out via
+// footerOptions.avoidKeyboard.
+- (BOOL)floatsAboveKeyboard {
+  TrueSheetViewController *controller = self.keyboardObserver.viewController;
+  return controller.absoluteFooter && controller.footerAvoidsKeyboard;
+}
+
+- (CGFloat)keyboardSlideForHeight:(CGFloat)height {
+  UIWindow *window = self.window;
+  if (!window) {
+    return 0;
+  }
+
+  // Measure in the transform's coordinate space, excluding the footer's current slide.
+  CGFloat footerBottom = self.center.y + self.bounds.size.height / 2;
+  CGPoint keyboardTopInWindow = CGPointMake(CGRectGetMidX(window.bounds), CGRectGetMaxY(window.bounds) - height);
+  CGFloat keyboardTop = [self.superview convertPoint:keyboardTopInWindow fromView:window].y;
+  CGFloat keyboardOffset = self.keyboardObserver.viewController.footerKeyboardOffset;
+  return MAX(0, footerBottom - keyboardTop + keyboardOffset);
+}
+
 // Yoga owns the footer's frame (pinned to the container's bottom edge), so the
-// keyboard slide is carried by a transform instead of layout. Only an absolute
-// footer floats above the keyboard — a relative footer stays in the layout
-// flow behind it.
+// keyboard slide is carried by a transform instead of layout.
 - (void)keyboardWillShow:(CGFloat)height duration:(NSTimeInterval)duration curve:(UIViewAnimationOptions)curve {
-  if (!self.keyboardObserver.viewController.absoluteFooter) {
+  if (![self floatsAboveKeyboard]) {
     return;
   }
 
   [self setKeyboardVisible:YES];
 
-  CGFloat keyboardOffset = self.keyboardObserver.viewController.footerKeyboardOffset;
-  CGFloat slide = MAX(0, height + keyboardOffset);
-  _currentKeyboardOffset = slide;
+  CGFloat slide = [self keyboardSlideForHeight:height];
+  [self setKeyboardOffset:slide];
 
   [UIView animateWithDuration:duration
-                        delay:0
-                      options:curve | UIViewAnimationOptionBeginFromCurrentState
-                   animations:^{
-                     self.transform = CGAffineTransformMakeTranslation(0, -slide);
-                   }
-                   completion:nil];
+    delay:0
+    options:curve | UIViewAnimationOptionBeginFromCurrentState
+    animations:^{
+      self.transform = CGAffineTransformMakeTranslation(0, -slide);
+      [self syncEdgeEffect];
+    }
+    completion:^(BOOL finished) {
+      [self applyKeyboardOffset];
+    }];
 }
 
 - (void)keyboardWillHide:(NSTimeInterval)duration curve:(UIViewAnimationOptions)curve {
+  // Offset first — the visible push replaces it in the queue, one commit
+  [self setKeyboardOffset:0];
   [self setKeyboardVisible:NO];
-  _currentKeyboardOffset = 0;
 
   [UIView animateWithDuration:duration
                         delay:0
                       options:curve | UIViewAnimationOptionBeginFromCurrentState
                    animations:^{
                      self.transform = CGAffineTransformIdentity;
+                     [self syncEdgeEffect];
                    }
                    completion:nil];
 }
 
+// UIKit derives the edge effect region from model geometry at commit time,
+// outside our animation context — the blur snaps to the footer's final
+// position while the footer is still animating. Re-evaluating the scroll
+// view's layout inside the animation block makes the region change inherit
+// the keyboard curve.
+- (void)syncEdgeEffect {
+  if (@available(iOS 26.0, *)) {
+    UIScrollView *scrollView = [self edgeInteractionScrollView];
+    if (scrollView) {
+      [scrollView setNeedsLayout];
+      [scrollView layoutIfNeeded];
+    }
+  }
+}
+
 - (void)applyKeyboardOffset {
   CGFloat height = self.keyboardObserver.currentHeight;
-  if (height <= 0 || !self.keyboardObserver.viewController.absoluteFooter) {
+  if (height <= 0) {
+    return;
+  }
+
+  // avoidKeyboard flipped off mid-keyboard — drop the slide already applied
+  if (![self floatsAboveKeyboard]) {
+    [self setKeyboardOffset:0];
+    [self setKeyboardVisible:NO];
+    self.transform = CGAffineTransformIdentity;
     return;
   }
 
   [self setKeyboardVisible:YES];
 
-  CGFloat keyboardOffset = self.keyboardObserver.viewController.footerKeyboardOffset;
-  CGFloat slide = MAX(0, height + keyboardOffset);
-  _currentKeyboardOffset = slide;
-  self.transform = CGAffineTransformMakeTranslation(0, -slide);
+  CGFloat slide = [self keyboardSlideForHeight:height];
+  [self setKeyboardOffset:slide];
+  // A footer mounted or relaid out mid-keyboard animation follows the keyboard
+  // instead of snapping ahead of it
+  [self animateAlongKeyboard:^{
+    self.transform = CGAffineTransformMakeTranslation(0, -slide);
+  }];
 }
 
 @end

package/ios/TrueSheetModule.h

@@ -27,16 +27,11 @@ NS_ASSUME_NONNULL_BEGIN
 
 /**
  * Register a sheet component view with its React tag
- * Called automatically by TrueSheetView during initialization
+ * Called automatically by TrueSheetView when it attaches to a window.
+ * The registry holds views weakly, so no unregistration is needed.
  */
 + (void)registerView:(TrueSheetView *)view withTag:(NSNumber *)tag;
 
-/**
- * Unregister a sheet component view
- * Called automatically by TrueSheetView during dealloc
- */
-+ (void)unregisterViewWithTag:(NSNumber *)tag;
-
 @end
 
 NS_ASSUME_NONNULL_END

package/ios/TrueSheetModule.mm

@@ -18,8 +18,9 @@
 
 #import <TrueSheetSpec/TrueSheetSpec.h>
 
-// Static registry to store view references by tag
-static NSMutableDictionary<NSNumber *, TrueSheetView *> *viewRegistry;
+// Static registry of live hosts by tag — weak so an unmounted host deallocates
+// (RN zeroes the tag before teardown, so hosts can't unregister themselves)
+static NSMapTable<NSNumber *, TrueSheetView *> *viewRegistry;
 
 @interface TrueSheetModule () <NativeTrueSheetModuleSpec>
 @end
@@ -30,7 +31,7 @@ RCT_EXPORT_MODULE(TrueSheetModule)
 
 + (void)initialize {
   if (self == [TrueSheetModule class]) {
-    viewRegistry = [NSMutableDictionary new];
+    viewRegistry = [NSMapTable strongToWeakObjectsMapTable];
   }
 }
 
@@ -148,11 +149,17 @@ RCT_EXPORT_MODULE(TrueSheetModule)
 - (void)dismissAll:(BOOL)animated resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
   RCTExecuteOnMainQueue(^{
     @synchronized(viewRegistry) {
+      // Drop presents still waiting on another sheet's dismissal
+      for (TrueSheetView *view in viewRegistry.objectEnumerator) {
+        [view cancelPendingPresent];
+      }
+
       // Find the root presented sheet (one without a parent TrueSheet)
       TrueSheetView *rootSheet = nil;
 
-      for (TrueSheetView *view in viewRegistry.allValues) {
-        if (!view.viewController.isPresented) {
+      for (TrueSheetView *view in viewRegistry.objectEnumerator) {
+        // A sheet still animating in counts too — dismissAnimated waits for it to land
+        if (!view.viewController.isPresented && !view.viewController.isBeingPresented) {
           continue;
         }
 
@@ -170,7 +177,10 @@ RCT_EXPORT_MODULE(TrueSheetModule)
         return;
       }
 
-      [rootSheet emitDismissedPosition];
+      // Mid-present, the deferred dismiss tracks its own position like a regular dismiss
+      if (rootSheet.viewController.isPresented) {
+        [rootSheet emitDismissedPosition];
+      }
       [rootSheet dismissAnimated:animated
                       completion:^(BOOL success, NSError *_Nullable error) {
                         if (success) {
@@ -191,7 +201,7 @@ RCT_EXPORT_MODULE(TrueSheetModule)
   }
 
   @synchronized(viewRegistry) {
-    return viewRegistry[reactTag];
+    return [viewRegistry objectForKey:reactTag];
   }
 }
 
@@ -201,17 +211,7 @@ RCT_EXPORT_MODULE(TrueSheetModule)
   }
 
   @synchronized(viewRegistry) {
-    viewRegistry[tag] = view;
-  }
-}
-
-+ (void)unregisterViewWithTag:(NSNumber *)tag {
-  if (!tag) {
-    return;
-  }
-
-  @synchronized(viewRegistry) {
-    [viewRegistry removeObjectForKey:tag];
+    [viewRegistry setObject:view forKey:tag];
   }
 }
 

package/ios/TrueSheetOverlayView.h

@@ -0,0 +1,42 @@
+//
+//  Created by Jovanni Lo (@lodev09)
+//  Copyright (c) 2024-present. All rights reserved.
+//
+//  This source code is licensed under the MIT license found in the
+//  LICENSE file in the root directory of this source tree.
+//
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Posted when an overlay container joins or leaves a window.
+ */
+extern NSNotificationName const TrueSheetOverlayWindowDidChangeNotification;
+
+/**
+ * Hidden host that renders its children in a container attached directly to
+ * the window, above every presented sheet.
+ */
+@interface TrueSheetOverlayView : RCTViewComponentView
+
+/**
+ * Re-stacks every overlay container above the window's other subviews.
+ * Called when a sheet presents, since presenting adds its transition view on top.
+ */
++ (void)bringOverlaysToFrontInWindow:(nullable UIWindow *)window;
+
+/**
+ * The overlay containers attached to the window, front to back.
+ */
++ (NSArray<UIView *> *)overlayContainersInWindow:(nullable UIWindow *)window;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif

package/ios/TrueSheetOverlayView.mm

@@ -0,0 +1,175 @@
+//
+//  Created by Jovanni Lo (@lodev09)
+//  Copyright (c) 2024-present. All rights reserved.
+//
+//  This source code is licensed under the MIT license found in the
+//  LICENSE file in the root directory of this source tree.
+//
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import "TrueSheetOverlayView.h"
+#import "core/TrueSheetOverlayContainerView.h"
+
+#import <react/renderer/components/TrueSheetSpec/EventEmitters.h>
+#import <react/renderer/components/TrueSheetSpec/Props.h>
+#import <react/renderer/components/TrueSheetSpec/RCTComponentViewHelpers.h>
+#import <react/renderer/components/TrueSheetSpec/TrueSheetOverlayViewComponentDescriptor.h>
+#import <react/renderer/components/TrueSheetSpec/TrueSheetOverlayViewShadowNode.h>
+
+#import <React/RCTSurfaceTouchHandler.h>
+
+using namespace facebook::react;
+
+NSNotificationName const TrueSheetOverlayWindowDidChangeNotification = @"TrueSheetOverlayWindowDidChangeNotification";
+
+static NSHashTable<TrueSheetOverlayView *> *gOverlayViews;
+
+@interface TrueSheetOverlayView () <TrueSheetOverlayContainerViewDelegate>
+@end
+
+@implementation TrueSheetOverlayView {
+  TrueSheetOverlayContainerView *_containerView;
+  // Owns `_containerView` so it has a view controller in its responder chain. The
+  // container is a sibling of `rootViewController.view`, and a window's responder chain
+  // skips its root view controller — without an owner, `-[UIView reactViewController]`
+  // finds nothing and content that installs a view controller cannot attach.
+  UIViewController *_containerController;
+  RCTSurfaceTouchHandler *_touchHandler;
+  TrueSheetOverlayViewShadowNode::ConcreteState::Shared _state;
+  CGSize _lastStateSize;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<TrueSheetOverlayViewComponentDescriptor>();
+}
+
++ (void)bringOverlaysToFrontInWindow:(nullable UIWindow *)window {
+  if (!window)
+    return;
+
+  for (TrueSheetOverlayView *overlay in gOverlayViews) {
+    if (overlay->_containerView.superview == window) {
+      [window bringSubviewToFront:overlay->_containerView];
+    }
+  }
+}
+
++ (NSArray<UIView *> *)overlayContainersInWindow:(nullable UIWindow *)window {
+  NSMutableArray<UIView *> *containers = [NSMutableArray array];
+  for (UIView *subview in window.subviews.reverseObjectEnumerator) {
+    if ([subview isKindOfClass:[TrueSheetOverlayContainerView class]]) {
+      [containers addObject:subview];
+    }
+  }
+  return containers;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const TrueSheetOverlayViewProps>();
+    _props = defaultProps;
+
+    _containerView = [[TrueSheetOverlayContainerView alloc] initWithFrame:CGRectZero];
+    _containerView.delegate = self;
+
+    // Assigning the container as its view is what puts the controller in the responder
+    // chain; the containment below is for lifecycle only.
+    _containerController = [UIViewController new];
+    _containerController.view = _containerView;
+
+    _touchHandler = [[RCTSurfaceTouchHandler alloc] init];
+    [_touchHandler attachToView:_containerView];
+
+    _lastStateSize = CGSizeZero;
+
+    // The host stays in the React tree for layout only — children render in the container
+    self.hidden = YES;
+
+    if (!gOverlayViews) {
+      gOverlayViews = [NSHashTable weakObjectsHashTable];
+    }
+    [gOverlayViews addObject:self];
+  }
+  return self;
+}
+
+- (void)didMoveToWindow {
+  [super didMoveToWindow];
+
+  UIWindow *window = self.window;
+  if (window) {
+    _containerView.frame = window.bounds;
+    [window addSubview:_containerView];
+
+    UIViewController *root = window.rootViewController;
+    if (root != nil && _containerController.parentViewController != root) {
+      [root addChildViewController:_containerController];
+      [_containerController didMoveToParentViewController:root];
+    }
+  } else {
+    [_containerController willMoveToParentViewController:nil];
+    [_containerView removeFromSuperview];
+    [_containerController removeFromParentViewController];
+  }
+
+  [[NSNotificationCenter defaultCenter] postNotificationName:TrueSheetOverlayWindowDidChangeNotification object:nil];
+}
+
+#pragma mark - State
+
+- (void)updateState:(const State::Shared &)state oldState:(const State::Shared &)oldState {
+  _state = std::static_pointer_cast<TrueSheetOverlayViewShadowNode::ConcreteState const>(state);
+
+  if (self.window) {
+    [self updateStateWithSize:self.window.bounds.size];
+  }
+}
+
+- (void)overlayContainerViewDidLayout:(CGSize)size {
+  [self updateStateWithSize:size];
+}
+
+- (void)updateStateWithSize:(CGSize)size {
+  if (!_state)
+    return;
+
+  if (fabs(size.width - _lastStateSize.width) < 0.5 && fabs(size.height - _lastStateSize.height) < 0.5)
+    return;
+
+  _lastStateSize = size;
+
+  auto stateData = _state->getData();
+  stateData.containerWidth = static_cast<float>(size.width);
+  stateData.containerHeight = static_cast<float>(size.height);
+  _state->updateState(std::move(stateData), EventQueue::UpdateMode::unstable_Immediate);
+}
+
+#pragma mark - Child Component Mounting
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index {
+  [_containerView insertSubview:childComponentView atIndex:index];
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index {
+  [childComponentView removeFromSuperview];
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+
+  [_containerController willMoveToParentViewController:nil];
+  [_containerView removeFromSuperview];
+  [_containerController removeFromParentViewController];
+  _lastStateSize = CGSizeZero;
+  _state.reset();
+  self.hidden = YES;
+}
+
+@end
+
+Class<RCTComponentViewProtocol> TrueSheetOverlayViewCls(void) {
+  return TrueSheetOverlayView.class;
+}
+
+#endif

package/ios/TrueSheetView.h

@@ -34,6 +34,8 @@ typedef void (^TrueSheetCompletionBlock)(BOOL success, NSError *_Nullable error)
 
 - (void)emitDismissedPosition;
 
+- (BOOL)cancelPendingPresent;
+
 - (void)resizeToIndex:(NSInteger)index completion:(nullable TrueSheetCompletionBlock)completion;
 
 - (void)dismissStackAnimated:(BOOL)animated completion:(nullable TrueSheetCompletionBlock)completion;