@lodev09/react-native-true-sheet 4.0.0-beta.2 → 4.0.0-beta.20

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,11 +139,24 @@ 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)];
   }
+
+  [self applyKeyboardOffset];
 }
 
 - (void)prepareForRecycle {
@@ -143,32 +172,56 @@ using namespace facebook::react;
   _currentKeyboardOffset = 0;
   _bottomInset = 0;
   _keyboardVisible = NO;
+  _didPushBottomInset = NO;
+  _appliedBottomInset = 0;
 }
 
 #pragma mark - TrueSheetKeyboardObserverDelegate
 
+// 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);
+  CGFloat slide = [self keyboardSlideForHeight:height];
   _currentKeyboardOffset = 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 {
@@ -180,20 +233,43 @@ using namespace facebook::react;
                       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 setKeyboardVisible:NO];
+    _currentKeyboardOffset = 0;
+    self.transform = CGAffineTransformIdentity;
     return;
   }
 
   [self setKeyboardVisible:YES];
 
-  CGFloat keyboardOffset = self.keyboardObserver.viewController.footerKeyboardOffset;
-  CGFloat slide = MAX(0, height + keyboardOffset);
+  CGFloat slide = [self keyboardSlideForHeight:height];
   _currentKeyboardOffset = slide;
   self.transform = CGAffineTransformMakeTranslation(0, -slide);
 }

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];
   }
 }
 
@@ -151,7 +152,7 @@ RCT_EXPORT_MODULE(TrueSheetModule)
       // Find the root presented sheet (one without a parent TrueSheet)
       TrueSheetView *rootSheet = nil;
 
-      for (TrueSheetView *view in viewRegistry.allValues) {
+      for (TrueSheetView *view in viewRegistry.objectEnumerator) {
         if (!view.viewController.isPresented) {
           continue;
         }
@@ -191,7 +192,7 @@ RCT_EXPORT_MODULE(TrueSheetModule)
   }
 
   @synchronized(viewRegistry) {
-    return viewRegistry[reactTag];
+    return [viewRegistry objectForKey:reactTag];
   }
 }
 
@@ -201,17 +202,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,32 @@
+//
+//  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
+
+/**
+ * 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;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif

package/ios/TrueSheetOverlayView.mm

@@ -0,0 +1,161 @@
+//
+//  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;
+
+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];
+    }
+  }
+}
+
+- (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];
+  }
+}
+
+#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