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

package/ios/core/TrueSheetDetentCalculator.mm

@@ -0,0 +1,197 @@
+//
+//  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.
+//
+
+#import "TrueSheetDetentCalculator.h"
+
+@implementation TrueSheetDetentCalculator {
+  NSMutableArray<NSNumber *> *_resolvedDetentOffsets;
+}
+
+#pragma mark - Public Methods
+
+- (CGFloat)detentValueForIndex:(NSInteger)index {
+  NSArray<NSNumber *> *detents = self.delegate.detents;
+  if (index >= 0 && index < (NSInteger)detents.count) {
+    CGFloat value = [detents[index] doubleValue];
+    if (value == -1) {
+      return [self autoHeight] / self.delegate.screenHeight;
+    }
+    if (value == -2) {
+      return [self peekHeight] / self.delegate.screenHeight;
+    }
+    return value;
+  }
+  return 0;
+}
+
+- (CGFloat)autoHeight {
+  // An absolute (floating) header or footer overlaps the content, so it contributes no height
+  CGFloat headerHeight = self.delegate.absoluteHeader ? 0 : [self.delegate.headerHeight floatValue];
+  CGFloat footerHeight = self.delegate.absoluteFooter ? 0 : [self.delegate.footerHeight floatValue];
+  return [self.delegate.contentHeight floatValue] + headerHeight + footerHeight;
+}
+
+- (CGFloat)peekHeight {
+  // A relative footer is laid out below the content, so it's pushed off-screen
+  // at the peek detent and contributes no height
+  CGFloat footerHeight = self.delegate.absoluteFooter ? [self.delegate.footerHeight floatValue] : 0;
+  CGFloat height =
+    [self.delegate.headerHeight floatValue] + footerHeight + [self.delegate.peekContentHeight floatValue];
+  return height > 0 ? height : 150;
+}
+
+- (void)learnOffsetForDetentIndex:(NSInteger)index {
+  if (index < 0 || !_resolvedDetentHeights || index >= (NSInteger)_resolvedDetentHeights.count) {
+    return;
+  }
+
+  CGFloat actualHeight = self.delegate.screenHeight - self.delegate.currentPosition;
+  CGFloat resolverHeight = [_resolvedDetentHeights[index] doubleValue];
+  // Always update — system offset can change between detent transitions
+  if (resolverHeight > 0 && actualHeight > 0) {
+    _resolvedDetentOffsets[index] = @(actualHeight - resolverHeight);
+  }
+}
+
+- (CGFloat)resolvedHeightForIndex:(NSInteger)index {
+  if (_resolvedDetentHeights && index >= 0 && index < (NSInteger)_resolvedDetentHeights.count) {
+    CGFloat h = [_resolvedDetentHeights[index] doubleValue];
+    if (h > 0) {
+      // Use per-detent offset if learned, otherwise find any known offset
+      CGFloat offset = [self offsetForIndex:index];
+      return h + offset;
+    }
+  }
+
+  CGFloat detentValue = [self detentValueForIndex:index];
+  if (_maxDetentHeight > 0) {
+    return detentValue * _maxDetentHeight;
+  }
+  return detentValue * self.delegate.screenHeight;
+}
+
+- (CGFloat)offsetForIndex:(NSInteger)index {
+  // Use this detent's own offset if available
+  if (index >= 0 && index < (NSInteger)_resolvedDetentOffsets.count) {
+    CGFloat offset = [_resolvedDetentOffsets[index] doubleValue];
+    if (offset != 0)
+      return offset;
+  }
+
+  // Fall back to any known offset
+  for (NSInteger i = 0; i < (NSInteger)_resolvedDetentOffsets.count; i++) {
+    CGFloat offset = [_resolvedDetentOffsets[i] doubleValue];
+    if (offset != 0)
+      return offset;
+  }
+
+  return 0;
+}
+
+- (BOOL)findSegmentForPosition:(CGFloat)position outIndex:(NSInteger *)outIndex outProgress:(CGFloat *)outProgress {
+  NSArray<NSNumber *> *detents = self.delegate.detents;
+  NSInteger count = detents.count;
+  if (count == 0) {
+    *outIndex = -1;
+    *outProgress = 0;
+    return NO;
+  }
+
+  CGFloat screenHeight = self.delegate.screenHeight;
+  CGFloat sheetHeight = screenHeight - position;
+  CGFloat firstHeight = [self resolvedHeightForIndex:0];
+
+  // Below first detent - interpolating toward closed
+  if (sheetHeight < firstHeight) {
+    *outIndex = -1;
+    *outProgress = firstHeight > 0 ? (firstHeight - sheetHeight) / firstHeight : 0;
+    return NO;
+  }
+
+  // Single detent
+  if (count == 1) {
+    *outIndex = 0;
+    *outProgress = 0;
+    return NO;
+  }
+
+  CGFloat lastHeight = [self resolvedHeightForIndex:count - 1];
+
+  // Above last detent
+  if (sheetHeight > lastHeight) {
+    *outIndex = count - 1;
+    *outProgress = 0;
+    return NO;
+  }
+
+  // Between detents
+  for (NSInteger i = 0; i < count - 1; i++) {
+    CGFloat h = [self resolvedHeightForIndex:i];
+    CGFloat nextH = [self resolvedHeightForIndex:i + 1];
+
+    if (sheetHeight >= h && sheetHeight <= nextH) {
+      CGFloat range = nextH - h;
+      *outIndex = i;
+      *outProgress = range > 0 ? (sheetHeight - h) / range : 0;
+      return YES;
+    }
+  }
+
+  *outIndex = count - 1;
+  *outProgress = 0;
+  return NO;
+}
+
+- (CGFloat)interpolatedIndexForPosition:(CGFloat)position {
+  NSInteger index;
+  CGFloat progress;
+  BOOL found = [self findSegmentForPosition:position outIndex:&index outProgress:&progress];
+
+  if (!found) {
+    if (index == -1) {
+      return -progress;
+    }
+    return index;
+  }
+
+  return index + fmax(0, fmin(1, progress));
+}
+
+- (CGFloat)interpolatedDetentForPosition:(CGFloat)position {
+  NSInteger index;
+  CGFloat progress;
+  BOOL found = [self findSegmentForPosition:position outIndex:&index outProgress:&progress];
+
+  if (!found) {
+    if (index == -1) {
+      CGFloat firstDetent = [self detentValueForIndex:0];
+      return fmax(0, firstDetent * (1 - progress));
+    }
+    return [self detentValueForIndex:index];
+  }
+
+  CGFloat detent = [self detentValueForIndex:index];
+  CGFloat nextDetent = [self detentValueForIndex:index + 1];
+  return detent + progress * (nextDetent - detent);
+}
+
+- (void)clearResolvedHeights {
+  [_resolvedDetentHeights removeAllObjects];
+  [_resolvedDetentOffsets removeAllObjects];
+}
+
+- (void)setDetentCount:(NSInteger)count {
+  _resolvedDetentHeights = [NSMutableArray arrayWithCapacity:count];
+  _resolvedDetentOffsets = [NSMutableArray arrayWithCapacity:count];
+  for (NSInteger i = 0; i < count; i++) {
+    [_resolvedDetentHeights addObject:@(0)];
+    [_resolvedDetentOffsets addObject:@(0)];
+  }
+}
+
+@end

package/ios/core/TrueSheetGrabberView.h

@@ -0,0 +1,72 @@
+//
+//  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.
+//
+
+#import <UIKit/UIKit.h>
+#import <react/renderer/components/TrueSheetSpec/Props.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface GrabberOptions : NSObject
+
+@property (nonatomic, strong, nullable) NSNumber *width;
+@property (nonatomic, strong, nullable) NSNumber *height;
+@property (nonatomic, strong, nullable) NSNumber *topMargin;
+@property (nonatomic, strong, nullable) NSNumber *cornerRadius;
+@property (nonatomic, strong, nullable) UIColor *color;
+@property (nonatomic, assign) BOOL adaptive;
+
+@end
+
+/**
+ * Native grabber (drag handle) view for the bottom sheet.
+ * Uses UIVibrancyEffect to adapt color based on the background.
+ */
+@interface TrueSheetGrabberView : UIView
+
+/// Width of the grabber pill (default: 36)
+@property (nonatomic, strong, nullable) NSNumber *grabberWidth;
+
+/// Height of the grabber pill (default: 5)
+@property (nonatomic, strong, nullable) NSNumber *grabberHeight;
+
+/// Top margin from the sheet edge (default: 5)
+@property (nonatomic, strong, nullable) NSNumber *topMargin;
+
+/// Corner radius of the grabber pill (default: height / 2)
+@property (nonatomic, strong, nullable) NSNumber *cornerRadius;
+
+/// Custom color for the grabber (uses vibrancy effect when nil)
+@property (nonatomic, strong, nullable) UIColor *color;
+
+/// Whether the grabber color adapts to the background (default: YES)
+@property (nonatomic, strong, nullable) NSNumber *adaptive;
+
+/// Accessibility strings (defaults come from the codegen prop defaults)
+@property (nonatomic, assign) facebook::react::TrueSheetViewAccessibilityOptionsStruct accessibilityOptions;
+
+/// Called when the grabber is tapped
+@property (nonatomic, copy, nullable) void (^onTap)(void);
+
+/// Called when VoiceOver user swipes up (expand)
+@property (nonatomic, copy, nullable) void (^onIncrement)(void);
+
+/// Called when VoiceOver user swipes down (collapse)
+@property (nonatomic, copy, nullable) void (^onDecrement)(void);
+
+/// Adds the grabber view to a parent view with proper constraints
+- (void)addToView:(UIView *)parentView;
+
+/// Applies the current configuration to the grabber view
+- (void)applyConfiguration;
+
+/// Updates the accessibility value based on the current detent position
+- (void)updateAccessibilityValueWithIndex:(NSInteger)index detentCount:(NSInteger)count;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/core/TrueSheetGrabberView.mm

@@ -0,0 +1,178 @@
+//
+//  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.
+//
+
+#import "TrueSheetGrabberView.h"
+
+#import <React/RCTConversions.h>
+
+using namespace facebook::react;
+
+@implementation GrabberOptions
+
+- (instancetype)init {
+  if (self = [super init]) {
+    _adaptive = YES;
+  }
+  return self;
+}
+
+@end
+
+static const CGFloat kDefaultGrabberWidth = 36.0;
+static const CGFloat kDefaultGrabberHeight = 5.0;
+static const CGFloat kDefaultGrabberTopMargin = 5.0;
+static const CGFloat kHitPaddingHorizontal = 20.0;
+static const CGFloat kHitPaddingVertical = 10.0;
+
+@implementation TrueSheetGrabberView {
+  UIVisualEffectView *_vibrancyView;
+  UIView *_fillView;
+}
+
+#pragma mark - Initialization
+
+- (instancetype)init {
+  if (self = [super init]) {
+    [self setupView];
+  }
+  return self;
+}
+
+#pragma mark - Computed Properties
+
+- (CGFloat)effectiveWidth {
+  return _grabberWidth ? [_grabberWidth floatValue] : kDefaultGrabberWidth;
+}
+
+- (CGFloat)effectiveHeight {
+  return _grabberHeight ? [_grabberHeight floatValue] : kDefaultGrabberHeight;
+}
+
+- (CGFloat)effectiveTopMargin {
+  return _topMargin ? [_topMargin floatValue] : kDefaultGrabberTopMargin;
+}
+
+- (CGFloat)effectiveCornerRadius {
+  return _cornerRadius ? [_cornerRadius floatValue] : [self effectiveHeight] / 2.0;
+}
+
+- (BOOL)isAdaptive {
+  return _adaptive ? [_adaptive boolValue] : YES;
+}
+
+#pragma mark - Setup
+
+- (void)setupView {
+  self.clipsToBounds = NO;
+  self.isAccessibilityElement = YES;
+  self.accessibilityTraits = UIAccessibilityTraitAdjustable | UIAccessibilityTraitButton;
+
+  UITapGestureRecognizer *tap = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(handleTap)];
+  [self addGestureRecognizer:tap];
+
+  _vibrancyView = [[UIVisualEffectView alloc] initWithEffect:nil];
+  [self addSubview:_vibrancyView];
+
+  _fillView = [[UIView alloc] init];
+  _fillView.backgroundColor = [UIColor.darkGrayColor colorWithAlphaComponent:0.7];
+  [_vibrancyView.contentView addSubview:_fillView];
+}
+
+#pragma mark - Actions
+
+- (void)handleTap {
+  if (_onTap) {
+    _onTap();
+  }
+}
+
+- (void)accessibilityIncrement {
+  if (_onIncrement) {
+    _onIncrement();
+  }
+}
+
+- (void)accessibilityDecrement {
+  if (_onDecrement) {
+    _onDecrement();
+  }
+}
+
+#pragma mark - Public
+
+- (void)setAccessibilityOptions:(TrueSheetViewAccessibilityOptionsStruct)accessibilityOptions {
+  _accessibilityOptions = accessibilityOptions;
+  self.accessibilityLabel = RCTNSStringFromStringNilIfEmpty(accessibilityOptions.grabberLabel);
+  self.accessibilityHint = RCTNSStringFromStringNilIfEmpty(accessibilityOptions.grabberHint);
+}
+
+- (void)updateAccessibilityValueWithIndex:(NSInteger)index detentCount:(NSInteger)count {
+  if (index < 0 || count <= 0) {
+    self.accessibilityValue = nil;
+    return;
+  }
+
+  if (index >= count - 1) {
+    self.accessibilityValue = RCTNSStringFromStringNilIfEmpty(_accessibilityOptions.expandedValue);
+  } else if (index == 0) {
+    self.accessibilityValue = RCTNSStringFromStringNilIfEmpty(_accessibilityOptions.collapsedValue);
+  } else {
+    NSString *value = RCTNSStringFromStringNilIfEmpty(_accessibilityOptions.detentValue);
+    value = [value stringByReplacingOccurrencesOfString:@"{index}" withString:@(index + 1).stringValue];
+    self.accessibilityValue = [value stringByReplacingOccurrencesOfString:@"{count}" withString:@(count).stringValue];
+  }
+}
+
+- (void)addToView:(UIView *)parentView {
+  if (self.superview == parentView) {
+    return;
+  }
+
+  self.autoresizingMask = UIViewAutoresizingFlexibleLeftMargin | UIViewAutoresizingFlexibleRightMargin;
+  [parentView addSubview:self];
+  [self applyConfiguration];
+}
+
+- (void)applyConfiguration {
+  CGFloat pillWidth = [self effectiveWidth];
+  CGFloat pillHeight = [self effectiveHeight];
+  CGFloat topMargin = [self effectiveTopMargin];
+  CGFloat parentWidth = self.superview ? self.superview.bounds.size.width : UIScreen.mainScreen.bounds.size.width;
+
+  CGFloat frameWidth = pillWidth + kHitPaddingHorizontal * 2;
+  CGFloat frameHeight = pillHeight + kHitPaddingVertical * 2;
+  CGFloat frameY = topMargin - kHitPaddingVertical;
+
+  self.frame = CGRectMake((parentWidth - frameWidth) / 2.0, frameY, frameWidth, frameHeight);
+  self.backgroundColor = UIColor.clearColor;
+
+  CGRect pillRect = CGRectMake(kHitPaddingHorizontal, kHitPaddingVertical, pillWidth, pillHeight);
+  _vibrancyView.frame = pillRect;
+  _vibrancyView.layer.cornerRadius = [self effectiveCornerRadius];
+  _vibrancyView.clipsToBounds = YES;
+  _fillView.frame = _vibrancyView.contentView.bounds;
+
+  if (self.isAdaptive) {
+    _vibrancyView.effect =
+      [UIVibrancyEffect effectForBlurEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleSystemChromeMaterial]
+                                      style:UIVibrancyEffectStyleFill];
+    _vibrancyView.backgroundColor = _color;
+    _fillView.hidden = NO;
+  } else {
+    _vibrancyView.effect = nil;
+    _fillView.hidden = YES;
+    _vibrancyView.backgroundColor = _color ?: [UIColor.darkGrayColor colorWithAlphaComponent:0.7];
+  }
+}
+
+- (void)layoutSubviews {
+  [super layoutSubviews];
+  [self applyConfiguration];
+}
+
+@end

package/ios/core/TrueSheetKeyboardObserver.h

@@ -0,0 +1,39 @@
+//
+//  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 <UIKit/UIKit.h>
+
+@class TrueSheetViewController;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol TrueSheetKeyboardObserverDelegate <NSObject>
+
+- (void)keyboardWillShow:(CGFloat)height duration:(NSTimeInterval)duration curve:(UIViewAnimationOptions)curve;
+- (void)keyboardWillHide:(NSTimeInterval)duration curve:(UIViewAnimationOptions)curve;
+
+@end
+
+@interface TrueSheetKeyboardObserver : NSObject
+
+@property (nonatomic, weak, nullable) TrueSheetViewController *viewController;
+@property (nonatomic, readonly) CGFloat currentHeight;
+
+- (void)addDelegate:(id<TrueSheetKeyboardObserverDelegate>)delegate;
+- (void)removeDelegate:(id<TrueSheetKeyboardObserverDelegate>)delegate;
+
+- (void)start;
+- (void)stop;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif

package/ios/core/TrueSheetKeyboardObserver.mm

@@ -0,0 +1,112 @@
+//
+//  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 "TrueSheetKeyboardObserver.h"
+#import "../TrueSheetViewController.h"
+#import "../utils/UIView+FirstResponder.h"
+
+@implementation TrueSheetKeyboardObserver {
+  NSHashTable<id<TrueSheetKeyboardObserverDelegate>> *_delegates;
+  CGFloat _currentHeight;
+}
+
+- (CGFloat)currentHeight {
+  return _currentHeight;
+}
+
+- (instancetype)init {
+  if (self = [super init]) {
+    _delegates = [NSHashTable weakObjectsHashTable];
+  }
+  return self;
+}
+
+- (void)addDelegate:(id<TrueSheetKeyboardObserverDelegate>)delegate {
+  [_delegates addObject:delegate];
+}
+
+- (void)removeDelegate:(id<TrueSheetKeyboardObserverDelegate>)delegate {
+  [_delegates removeObject:delegate];
+}
+
+- (void)start {
+  [[NSNotificationCenter defaultCenter] addObserver:self
+                                           selector:@selector(keyboardWillChangeFrame:)
+                                               name:UIKeyboardWillChangeFrameNotification
+                                             object:nil];
+}
+
+- (void)stop {
+  [[NSNotificationCenter defaultCenter] removeObserver:self name:UIKeyboardWillChangeFrameNotification object:nil];
+}
+
+- (void)dealloc {
+  [self stop];
+}
+
+- (BOOL)isFirstResponderWithinSheet {
+  if (!_viewController) {
+    return NO;
+  }
+  UIView *firstResponder = [_viewController.view findFirstResponder];
+  return firstResponder != nil;
+}
+
+- (void)keyboardWillChangeFrame:(NSNotification *)notification {
+  if (_viewController && !_viewController.isTopmostPresentedController) {
+    return;
+  }
+
+  if (![self isFirstResponderWithinSheet]) {
+    return;
+  }
+
+  NSDictionary *userInfo = notification.userInfo;
+  CGRect keyboardFrame = [userInfo[UIKeyboardFrameEndUserInfoKey] CGRectValue];
+  NSTimeInterval duration = [userInfo[UIKeyboardAnimationDurationUserInfoKey] doubleValue];
+  UIViewAnimationOptions curve = [userInfo[UIKeyboardAnimationCurveUserInfoKey] unsignedIntegerValue] << 16;
+
+  UIWindow *window = _viewController.view.window;
+  if (!window) {
+    return;
+  }
+
+  CGRect keyboardFrameInWindow = [window convertRect:keyboardFrame fromWindow:nil];
+  CGFloat keyboardHeight = MAX(0, window.bounds.size.height - keyboardFrameInWindow.origin.y);
+
+  _currentHeight = keyboardHeight;
+
+  if (keyboardHeight > 0) {
+    _viewController.keyboardSheetGrown = YES;
+  } else {
+    // The sheet stays grown until UIKit finishes the shrink-back animation —
+    // clear after it completes, unless the keyboard came back in the meantime.
+    __weak __typeof(self) weakSelf = self;
+    dispatch_after(
+      dispatch_time(DISPATCH_TIME_NOW, (int64_t)((duration + 0.1) * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+        __strong __typeof(weakSelf) strongSelf = weakSelf;
+        if (strongSelf && strongSelf->_currentHeight == 0) {
+          strongSelf->_viewController.keyboardSheetGrown = NO;
+        }
+      });
+  }
+
+  for (id<TrueSheetKeyboardObserverDelegate> delegate in _delegates) {
+    if (keyboardHeight > 0) {
+      [delegate keyboardWillShow:keyboardHeight duration:duration curve:curve];
+    } else {
+      [delegate keyboardWillHide:duration curve:curve];
+    }
+  }
+}
+
+@end
+
+#endif

package/ios/events/TrueSheetDragEvents.h

@@ -0,0 +1,39 @@
+//
+//  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 <Foundation/Foundation.h>
+#import <react/renderer/components/TrueSheetSpec/EventEmitters.h>
+
+using namespace facebook::react;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface TrueSheetDragEvents : NSObject
+
++ (void)emitDragBegin:(std::shared_ptr<const facebook::react::EventEmitter>)eventEmitter
+                index:(NSInteger)index
+             position:(CGFloat)position
+               detent:(CGFloat)detent;
+
++ (void)emitDragChange:(std::shared_ptr<const facebook::react::EventEmitter>)eventEmitter
+                 index:(NSInteger)index
+              position:(CGFloat)position
+                detent:(CGFloat)detent;
+
++ (void)emitDragEnd:(std::shared_ptr<const facebook::react::EventEmitter>)eventEmitter
+              index:(NSInteger)index
+           position:(CGFloat)position
+             detent:(CGFloat)detent;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif  // RCT_NEW_ARCH_ENABLED

package/ios/events/TrueSheetDragEvents.mm

@@ -0,0 +1,62 @@
+//
+//  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 "TrueSheetDragEvents.h"
+
+@implementation TrueSheetDragEvents
+
++ (void)emitDragBegin:(std::shared_ptr<const facebook::react::EventEmitter>)eventEmitter
+                index:(NSInteger)index
+             position:(CGFloat)position
+               detent:(CGFloat)detent {
+  if (!eventEmitter)
+    return;
+
+  auto emitter = std::static_pointer_cast<TrueSheetViewEventEmitter const>(eventEmitter);
+  TrueSheetViewEventEmitter::OnDragBegin event;
+  event.index = static_cast<int>(index);
+  event.position = static_cast<double>(position);
+  event.detent = static_cast<double>(detent);
+  emitter->onDragBegin(event);
+}
+
++ (void)emitDragChange:(std::shared_ptr<const facebook::react::EventEmitter>)eventEmitter
+                 index:(NSInteger)index
+              position:(CGFloat)position
+                detent:(CGFloat)detent {
+  if (!eventEmitter)
+    return;
+
+  auto emitter = std::static_pointer_cast<TrueSheetViewEventEmitter const>(eventEmitter);
+  TrueSheetViewEventEmitter::OnDragChange event;
+  event.index = static_cast<int>(index);
+  event.position = static_cast<double>(position);
+  event.detent = static_cast<double>(detent);
+  emitter->onDragChange(event);
+}
+
++ (void)emitDragEnd:(std::shared_ptr<const facebook::react::EventEmitter>)eventEmitter
+              index:(NSInteger)index
+           position:(CGFloat)position
+             detent:(CGFloat)detent {
+  if (!eventEmitter)
+    return;
+
+  auto emitter = std::static_pointer_cast<TrueSheetViewEventEmitter const>(eventEmitter);
+  TrueSheetViewEventEmitter::OnDragEnd event;
+  event.index = static_cast<int>(index);
+  event.position = static_cast<double>(position);
+  event.detent = static_cast<double>(detent);
+  emitter->onDragEnd(event);
+}
+
+@end
+
+#endif  // RCT_NEW_ARCH_ENABLED