@mapvina-com/mapvina-react-native 1.0.0

package/ios/components/annotations/point-annotation/MLRNPointAnnotation.m

@@ -0,0 +1,319 @@
+#import "MLRNPointAnnotation.h"
+#import <React/UIView+React.h>
+#import "MLRNMapTouchEvent.h"
+#import "MLRNMapView.h"
+#import "MLRNUtils.h"
+
+const float CENTER_X_OFFSET_BASE = -0.5f;
+const float CENTER_Y_OFFSET_BASE = -0.5f;
+
+@implementation MLRNPointAnnotation {
+  UITapGestureRecognizer *customViewTap;
+  // Finger-to-anchor offset to preserve the touch position relative to the annotation's anchor
+  CGPoint _dragFingerOffset;
+  BOOL _dragFingerOffsetCaptured;
+}
+
+- (id)init {
+  if (self = [super init]) {
+    customViewTap = [[UITapGestureRecognizer alloc] initWithTarget:self
+                                                            action:@selector(_handleTap:)];
+  }
+  return self;
+}
+
+- (void)insertReactSubview:(UIView *)subview atIndex:(NSInteger)atIndex {
+  if ([subview isKindOfClass:[MLRNCallout class]]) {
+    self.calloutView = (MLRNCallout *)subview;
+    self.calloutView.representedObject = self;
+  } else {
+    [super insertReactSubview:subview atIndex:0];
+  }
+}
+
+- (void)removeReactSubview:(UIView *)subview {
+  if ([subview isKindOfClass:[MLRNCallout class]]) {
+    self.calloutView = nil;
+  } else {
+    [super removeReactSubview:subview];
+  }
+}
+
+- (void)reactSetFrame:(CGRect)frame {
+  // Skip frame updates while dragging
+  if (self.dragState != MLNAnnotationViewDragStateNone) {
+    return;
+  }
+
+  if ([_map.annotations containsObject:self]) {
+    [_map removeAnnotation:self];
+  }
+  [super reactSetFrame:frame];
+  [self _setCenterOffset:frame];
+  [self _addAnnotation];
+}
+
+- (void)setAnchor:(NSDictionary<NSString *, NSNumber *> *)anchor {
+  _anchor = anchor;
+  [self _setCenterOffset:self.frame];
+}
+
+- (void)setOffset:(NSDictionary<NSString *, NSNumber *> *)offset {
+  _offset = offset;
+  [self _setCenterOffset:self.frame];
+}
+
+- (void)setCenter:(CGPoint)center {
+  // Reset drag offset tracking whenever we're not in a drag
+  if (self.dragState == MLNAnnotationViewDragStateNone) {
+    _dragFingerOffsetCaptured = NO;
+    [super setCenter:center];
+    return;
+  }
+
+  if (_map != nil) {
+    CGPoint coordPoint = [_map convertCoordinate:self.coordinate toPointToView:_map];
+
+    // Reject map-redraw resets: MapVina re-projects annotations from their
+    // coordinate on every redraw, snapping the view back mid-drag.
+    if (fabs(center.x - coordPoint.x) < 0.5 && fabs(center.y - coordPoint.y) < 0.5) {
+      return;
+    }
+
+    // Capture the finger-to-anchor offset so the view doesn't snap its center
+    // to the touch point, preserving where the user grabbed relative to the anchor.
+    if (!_dragFingerOffsetCaptured) {
+      _dragFingerOffset = CGPointMake(center.x - coordPoint.x, center.y - coordPoint.y);
+      _dragFingerOffsetCaptured = YES;
+    }
+    center.x -= _dragFingerOffset.x;
+    center.y -= _dragFingerOffset.y;
+  }
+
+  [super setCenter:center];
+}
+
+- (void)setMap:(MLNMapView *)map {
+  if (map == nil) {
+    [_map removeAnnotation:self];
+    _map = nil;
+  } else {
+    _map = map;
+
+    // prevents annotations from flying in from the top left corner
+    // if the frame hasn't been set yet
+    if (![self _isFrameSet]) {
+      return;
+    }
+
+    [self _addAnnotation];
+  }
+}
+
+- (void)setReactSelected:(BOOL)reactSelected {
+  _reactSelected = reactSelected;
+
+  if (_map != nil) {
+    if ([_map isKindOfClass:[MLRNMapView class]]) {
+      ((MLRNMapView *)_map).annotationSelected = YES;
+    }
+    if (_reactSelected) {
+      [_map selectAnnotation:self animated:NO completionHandler:nil];
+    } else {
+      [_map deselectAnnotation:self animated:NO];
+    }
+  }
+}
+
+- (void)setReactDraggable:(BOOL)reactDraggable {
+  _reactDraggable = reactDraggable;
+  self.draggable = _reactDraggable;
+}
+
+- (void)setReactLngLat:(NSArray<NSNumber *> *)reactLngLat {
+  _reactLngLat = reactLngLat;
+  [self _updateCoordinate];
+}
+
+- (NSString *)reuseIdentifier {
+  return _id;
+}
+
+- (NSString *)title {
+  return _reactTitle;
+}
+
+- (NSString *)subtitle {
+  return _reactSnippet;
+}
+
+- (NSString *)toolTip {
+  return _reactTitle;
+}
+
+- (void)setZIndex:(CGFloat)zIndex {
+  _hasExplicitZIndex = YES;
+  _explicitZIndex = zIndex;
+  self.layer.zPosition = zIndex;
+}
+
+- (MLNAnnotationView *)getAnnotationView {
+  // Check both reactSubviews (old arch) and customChildCount (Fabric)
+  BOOL hasCustomChildren = (self.reactSubviews.count > 0) || (self.customChildCount > 0);
+
+  if (!hasCustomChildren) {
+    // Replicate MLNMapView's to allow unified tap/selection behavior.
+    NSBundle *mapVinaBundle = [NSBundle bundleForClass:[MLNMapView class]];
+    UIImage *pinImage = [UIImage imageNamed:@"default_marker"
+                                   inBundle:mapVinaBundle
+              compatibleWithTraitCollection:nil];
+
+    UIImageView *pinImageView = [[UIImageView alloc] initWithImage:pinImage];
+    [pinImageView sizeToFit];
+
+    MLNAnnotationView *defaultView = [[MLNAnnotationView alloc] initWithReuseIdentifier:nil];
+    defaultView.bounds = pinImageView.bounds;
+    [defaultView addSubview:pinImageView];
+    defaultView.centerOffset = CGVectorMake(0, 0);
+    defaultView.enabled = YES;
+    [defaultView addGestureRecognizer:customViewTap];
+    return defaultView;
+  } else {
+    // custom view
+    self.enabled = YES;
+    // Only use latitude-based zPosition if no explicit zIndex was set
+    if (!_hasExplicitZIndex) {
+      const CGFloat defaultZPosition = 0.0;
+      if (self.layer.zPosition == defaultZPosition) {
+        self.layer.zPosition = [self _getZPosition];
+      }
+    }
+    [self addGestureRecognizer:customViewTap];
+    self.annotation = self;
+    return self;
+  }
+}
+
+- (CGFloat)_getZPosition {
+  double latitudeMax = 90.0;
+  return latitudeMax - self.coordinate.latitude;
+}
+
+- (void)_handleTap:(UITapGestureRecognizer *)recognizer {
+  if ([_map isKindOfClass:[MLRNMapView class]]) {
+    ((MLRNMapView *)_map).annotationSelected = YES;
+  }
+  if (self.reactOnPress != nil) {
+    self.reactOnPress([self makeEventPayload]);
+  }
+  [_map selectAnnotation:self animated:NO completionHandler:nil];
+}
+
+- (void)_setCenterOffset:(CGRect)frame {
+  if (frame.size.width == 0 || frame.size.height == 0) {
+    return;
+  }
+
+  float dx = 0;
+  float dy = 0;
+
+  // Apply anchor offset (anchor is a percentage of view dimensions)
+  if (_anchor != nil) {
+    float x = [_anchor[@"x"] floatValue];
+    float y = [_anchor[@"y"] floatValue];
+
+    dx = -(x * frame.size.width - (frame.size.width / 2));
+    dy = -(y * frame.size.height - (frame.size.height / 2));
+
+    // special cases 0 and 1
+    if (x == 0) {
+      dx = frame.size.width / 2;
+    } else if (x == 1) {
+      dx = -frame.size.width / 2;
+    }
+
+    if (y == 0) {
+      dy = frame.size.height / 2;
+    } else if (y == 1) {
+      dy = -frame.size.height / 2;
+    }
+  }
+
+  // Apply pixel offset
+  if (_offset != nil) {
+    dx += [_offset[@"x"] floatValue];
+    dy += [_offset[@"y"] floatValue];
+  }
+
+  self.centerOffset = CGVectorMake(dx, dy);
+}
+
+- (void)_updateCoordinate {
+  if (_reactLngLat == nil || _reactLngLat.count < 2) {
+    return;
+  }
+
+  double lng = [_reactLngLat[0] doubleValue];
+  double lat = [_reactLngLat[1] doubleValue];
+
+  dispatch_async(dispatch_get_main_queue(), ^{
+    self.coordinate = CLLocationCoordinate2DMake(lat, lng);
+  });
+}
+
+- (void)_addAnnotation {
+  if ([_map.annotations containsObject:self]) {
+    return;
+  }
+
+  [_map addAnnotation:self];
+  if (_reactSelected) {
+    [_map selectAnnotation:self animated:NO completionHandler:nil];
+  }
+}
+
+- (BOOL)_isFrameSet {
+  return self.frame.size.width > 0 && self.frame.size.height > 0;
+}
+
+- (NSDictionary *)makeEventPayload {
+  NSMutableDictionary *payload = [NSMutableDictionary dictionary];
+  payload[@"id"] = _id ?: @"";
+  payload[@"lngLat"] = @[ @(self.coordinate.longitude), @(self.coordinate.latitude) ];
+
+  CGPoint screenPoint = [_map convertCoordinate:self.coordinate toPointToView:_map];
+  payload[@"point"] = @[ @(screenPoint.x), @(screenPoint.y) ];
+
+  return payload;
+}
+
+- (void)setDragState:(MLNAnnotationViewDragState)dragState animated:(BOOL)animated {
+  [super setDragState:dragState animated:animated];
+  switch (dragState) {
+    case MLNAnnotationViewDragStateStarting: {
+      if (self.reactOnDragStart != nil) {
+        self.reactOnDragStart([self makeEventPayload]);
+      }
+      break;
+    }
+
+    case MLNAnnotationViewDragStateDragging:
+      if (self.reactOnDrag != nil) {
+        self.reactOnDrag([self makeEventPayload]);
+      }
+      break;
+
+    case MLNAnnotationViewDragStateEnding:
+    case MLNAnnotationViewDragStateCanceling: {
+      if (self.reactOnDragEnd != nil) {
+        self.reactOnDragEnd([self makeEventPayload]);
+      }
+      break;
+    }
+
+    case MLNAnnotationViewDragStateNone:
+      return;
+  }
+}
+
+@end

package/ios/components/annotations/point-annotation/MLRNPointAnnotationComponentView.h

@@ -0,0 +1,10 @@
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface MLRNPointAnnotationComponentView : RCTViewComponentView
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/components/annotations/point-annotation/MLRNPointAnnotationComponentView.mm

@@ -0,0 +1,327 @@
+#import "MLRNPointAnnotationComponentView.h"
+
+#import <react/renderer/components/MapVinaReactNativeSpec/ComponentDescriptors.h>
+#import <react/renderer/components/MapVinaReactNativeSpec/EventEmitters.h>
+#import <react/renderer/components/MapVinaReactNativeSpec/Props.h>
+#import <react/renderer/components/MapVinaReactNativeSpec/RCTComponentViewHelpers.h>
+
+#import "RCTFabricComponentsPlugins.h"
+
+#import <React/RCTConversions.h>
+#import <React/UIView+React.h>
+#import "MLRNCallout.h"
+#import "MLRNPointAnnotation.h"
+
+using namespace facebook::react;
+
+// MARK: - MLRNPointAnnotationComponentView
+
+@interface MLRNPointAnnotationComponentView () <RCTMLRNPointAnnotationViewProtocol>
+
+@end
+
+@implementation MLRNPointAnnotationComponentView {
+  MLRNPointAnnotation *_view;
+}
+
++ (BOOL)shouldBeRecycled {
+  // Prevent Fabric from recycling this view - MapVina reparents annotation views
+  // which conflicts with Fabric's view hierarchy management
+  return NO;
+}
+
+- (UIView *)contentView {
+  // Return _view so MapView's mountChildComponentView can find it via contentView
+  // We don't set self.contentView = _view directly to avoid Fabric's view management
+  return _view;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const MLRNPointAnnotationProps>();
+    _props = defaultProps;
+    [self prepareView];
+  }
+
+  return self;
+}
+
+- (void)prepareView {
+  _view = [[MLRNPointAnnotation alloc] init];
+
+  // Capture weak self reference to prevent retain cycle
+  __weak __typeof__(self) weakSelf = self;
+
+  [_view setReactOnPress:^(NSDictionary *event) {
+    __typeof__(self) strongSelf = weakSelf;
+
+    if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+      NSString *idValue = event[@"id"];
+      facebook::react::MLRNPointAnnotationEventEmitter::OnPress eventStruct{
+          std::string([idValue UTF8String] ?: ""),
+          folly::dynamic::array([event[@"lngLat"][0] doubleValue],
+                                [event[@"lngLat"][1] doubleValue]),
+          folly::dynamic::array([event[@"point"][0] doubleValue],
+                                [event[@"point"][1] doubleValue])};
+
+      std::dynamic_pointer_cast<const facebook::react::MLRNPointAnnotationEventEmitter>(
+          strongSelf->_eventEmitter)
+          ->onPress(eventStruct);
+    }
+  }];
+
+  [_view setReactOnSelect:^(NSDictionary *event) {
+    __typeof__(self) strongSelf = weakSelf;
+
+    if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+      NSString *idValue = event[@"id"];
+      facebook::react::MLRNPointAnnotationEventEmitter::OnSelect eventStruct{
+          std::string([idValue UTF8String] ?: ""),
+          folly::dynamic::array([event[@"lngLat"][0] doubleValue],
+                                [event[@"lngLat"][1] doubleValue]),
+          folly::dynamic::array([event[@"point"][0] doubleValue],
+                                [event[@"point"][1] doubleValue])};
+
+      std::dynamic_pointer_cast<const facebook::react::MLRNPointAnnotationEventEmitter>(
+          strongSelf->_eventEmitter)
+          ->onSelect(eventStruct);
+    }
+  }];
+
+  [_view setReactOnDeselect:^(NSDictionary *event) {
+    __typeof__(self) strongSelf = weakSelf;
+
+    if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+      NSString *idValue = event[@"id"];
+      facebook::react::MLRNPointAnnotationEventEmitter::OnDeselect eventStruct{
+          std::string([idValue UTF8String] ?: ""),
+          folly::dynamic::array([event[@"lngLat"][0] doubleValue],
+                                [event[@"lngLat"][1] doubleValue]),
+          folly::dynamic::array([event[@"point"][0] doubleValue],
+                                [event[@"point"][1] doubleValue])};
+
+      std::dynamic_pointer_cast<const facebook::react::MLRNPointAnnotationEventEmitter>(
+          strongSelf->_eventEmitter)
+          ->onDeselect(eventStruct);
+    }
+  }];
+
+  [_view setReactOnDragStart:^(NSDictionary *event) {
+    __typeof__(self) strongSelf = weakSelf;
+
+    if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+      NSString *idValue = event[@"id"];
+      facebook::react::MLRNPointAnnotationEventEmitter::OnDragStart eventStruct{
+          std::string([idValue UTF8String] ?: ""),
+          folly::dynamic::array([event[@"lngLat"][0] doubleValue],
+                                [event[@"lngLat"][1] doubleValue]),
+          folly::dynamic::array([event[@"point"][0] doubleValue],
+                                [event[@"point"][1] doubleValue])};
+
+      std::dynamic_pointer_cast<const facebook::react::MLRNPointAnnotationEventEmitter>(
+          strongSelf->_eventEmitter)
+          ->onDragStart(eventStruct);
+    }
+  }];
+
+  [_view setReactOnDrag:^(NSDictionary *event) {
+    __typeof__(self) strongSelf = weakSelf;
+
+    if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+      NSString *idValue = event[@"id"];
+      facebook::react::MLRNPointAnnotationEventEmitter::OnDrag eventStruct{
+          std::string([idValue UTF8String] ?: ""),
+          folly::dynamic::array([event[@"lngLat"][0] doubleValue],
+                                [event[@"lngLat"][1] doubleValue]),
+          folly::dynamic::array([event[@"point"][0] doubleValue],
+                                [event[@"point"][1] doubleValue])};
+
+      std::dynamic_pointer_cast<const facebook::react::MLRNPointAnnotationEventEmitter>(
+          strongSelf->_eventEmitter)
+          ->onDrag(eventStruct);
+    }
+  }];
+
+  [_view setReactOnDragEnd:^(NSDictionary *event) {
+    __typeof__(self) strongSelf = weakSelf;
+
+    if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+      NSString *idValue = event[@"id"];
+      facebook::react::MLRNPointAnnotationEventEmitter::OnDragEnd eventStruct{
+          std::string([idValue UTF8String] ?: ""),
+          folly::dynamic::array([event[@"lngLat"][0] doubleValue],
+                                [event[@"lngLat"][1] doubleValue]),
+          folly::dynamic::array([event[@"point"][0] doubleValue],
+                                [event[@"point"][1] doubleValue])};
+
+      std::dynamic_pointer_cast<const facebook::react::MLRNPointAnnotationEventEmitter>(
+          strongSelf->_eventEmitter)
+          ->onDragEnd(eventStruct);
+    }
+  }];
+
+  // Add _view as a subview (not contentView) so the MapView can discover it
+  // via its addToMap: method which iterates through subviews looking for
+  // MLRNPointAnnotation instances to set their map property.
+  // Note: MapVina will reparent _view when displaying the annotation,
+  // but that's fine - the initial subview relationship lets MapView find it.
+  [self addSubview:_view];
+}
+
+- (void)updateLayoutMetrics:(const facebook::react::LayoutMetrics &)layoutMetrics
+           oldLayoutMetrics:(const facebook::react::LayoutMetrics &)oldLayoutMetrics {
+  [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
+
+  // Forward layout to _view - this triggers reactSetFrame: which adds the annotation to the map
+  CGRect frame = CGRectMake(layoutMetrics.frame.origin.x, layoutMetrics.frame.origin.y,
+                            layoutMetrics.frame.size.width, layoutMetrics.frame.size.height);
+  [_view reactSetFrame:frame];
+}
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView
+                          index:(NSInteger)index {
+  // Track custom children for Fabric - needed for getAnnotationView to know
+  // if this is a custom annotation or should use the default pin
+  BOOL needsAnnotationRefresh = NO;
+
+  BOOL isCallout = NO;
+
+  if ([childComponentView isKindOfClass:[RCTViewComponentView class]]) {
+    UIView *contentView = ((RCTViewComponentView *)childComponentView).contentView;
+    if ([contentView isKindOfClass:[MLRNCallout class]]) {
+      // Set up calloutView reference for Callout children
+      // NOTE: We do NOT add Callout as a subview - MapVina will present it
+      // when the annotation is selected via calloutViewForAnnotation delegate
+      _view.calloutView = (MLRNCallout *)contentView;
+      _view.calloutView.representedObject = _view;
+      isCallout = YES;
+    } else {
+      // Track non-Callout custom children (custom annotation views)
+      // If this is the first custom child and annotation is already on map,
+      // we need to refresh so MapVina picks up the custom view
+      if (_view.customChildCount == 0 && _view.map != nil) {
+        needsAnnotationRefresh = YES;
+      }
+      _view.customChildCount++;
+    }
+  }
+
+  // Add non-Callout children directly to _view (the annotation view).
+  // We do NOT call super because we want children in _view, not in self.
+  // This allows children to move with _view when MapVina reparents it.
+  // Callouts are NOT added as subviews - they're presented by MapVina on selection.
+  // Note: We use the current subview count as the index because Callouts are skipped,
+  // so React's index won't match our actual subview indices.
+  if (!isCallout) {
+    [_view addSubview:childComponentView];
+  }
+
+  // If annotation was added before children were mounted, MapVina would have
+  // returned nil from getAnnotationView (no custom children). Now that we have
+  // children, remove and re-add to trigger viewForAnnotation: again.
+  if (needsAnnotationRefresh && [_view.map.annotations containsObject:_view]) {
+    [_view.map removeAnnotation:_view];
+    [_view.map addAnnotation:_view];
+  }
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView
+                            index:(NSInteger)index {
+  // Update tracking for custom children
+  BOOL isCallout = NO;
+
+  if ([childComponentView isKindOfClass:[RCTViewComponentView class]]) {
+    UIView *contentView = ((RCTViewComponentView *)childComponentView).contentView;
+    if ([contentView isKindOfClass:[MLRNCallout class]]) {
+      // Clear calloutView reference - Callout was never added as subview
+      _view.calloutView = nil;
+      isCallout = YES;
+    } else if (_view.customChildCount > 0) {
+      // Decrement custom child count
+      _view.customChildCount--;
+    }
+  }
+
+  // Remove from _view (not from self, since we added to _view)
+  // Don't remove Callout since it was never added as subview
+  if (!isCallout) {
+    [childComponentView removeFromSuperview];
+  }
+}
+
+#pragma mark - RCTComponentViewProtocol
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps {
+  const auto &oldViewProps = *std::static_pointer_cast<MLRNPointAnnotationProps const>(_props);
+  const auto &newViewProps = *std::static_pointer_cast<MLRNPointAnnotationProps const>(props);
+
+  if (oldViewProps.id != newViewProps.id) {
+    [_view setId:RCTNSStringFromString(newViewProps.id)];
+  }
+
+  if (oldViewProps.title != newViewProps.title) {
+    [_view setReactTitle:RCTNSStringFromStringNilIfEmpty(newViewProps.title)];
+  }
+
+  if (oldViewProps.snippet != newViewProps.snippet) {
+    [_view setReactSnippet:RCTNSStringFromStringNilIfEmpty(newViewProps.snippet)];
+  }
+
+  if (oldViewProps.selected != newViewProps.selected) {
+    [_view setReactSelected:newViewProps.selected];
+  }
+
+  if (oldViewProps.draggable != newViewProps.draggable) {
+    [_view setReactDraggable:newViewProps.draggable];
+  }
+
+  if (!oldViewProps.lngLat.isNull() || !newViewProps.lngLat.isNull()) {
+    if (newViewProps.lngLat.isArray() && newViewProps.lngLat.size() >= 2) {
+      NSArray<NSNumber *> *lngLat =
+          @[ @(newViewProps.lngLat[0].asDouble()), @(newViewProps.lngLat[1].asDouble()) ];
+      [_view setReactLngLat:lngLat];
+    }
+  }
+
+  if (oldViewProps.anchor.x != newViewProps.anchor.x ||
+      oldViewProps.anchor.y != newViewProps.anchor.y) {
+    NSDictionary *anchor = @{@"x" : @(newViewProps.anchor.x), @"y" : @(newViewProps.anchor.y)};
+    [_view setAnchor:anchor];
+  }
+
+  if (oldViewProps.offset.x != newViewProps.offset.x ||
+      oldViewProps.offset.y != newViewProps.offset.y) {
+    NSDictionary *offset = @{@"x" : @(newViewProps.offset.x), @"y" : @(newViewProps.offset.y)};
+    [_view setOffset:offset];
+  }
+
+  // Handle zIndex from style prop - it's in the base ViewProps
+  if (oldViewProps.zIndex != newViewProps.zIndex) {
+    if (newViewProps.zIndex.has_value()) {
+      [_view setZIndex:(CGFloat)newViewProps.zIndex.value()];
+    }
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<MLRNPointAnnotationComponentDescriptor>();
+}
+
+#pragma mark - Native Commands
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args {
+  RCTMLRNPointAnnotationHandleCommand(self, commandName, args);
+}
+
+- (void)refresh {
+  // refresh is only used on Android to rerender the bitmap
+  // On iOS, this is a no-op
+}
+
+@end
+
+Class<RCTComponentViewProtocol> MLRNPointAnnotationCls(void) {
+  return MLRNPointAnnotationComponentView.class;
+}

package/ios/components/camera/CameraEasing.h

@@ -0,0 +1,8 @@
+#import <Foundation/Foundation.h>
+
+typedef NS_ENUM(NSInteger, MLRNCameraEasing) {
+  MLRNCameraEasingNone = 0,
+  MLRNCameraEasingLinear = 1,
+  MLRNCameraEasingEase = 2,
+  MLRNCameraEasingFly = 3,
+};

package/ios/components/camera/CameraStop.h

@@ -0,0 +1,22 @@
+#import <MapVina/MapVina.h>
+
+#import "CameraEasing.h"
+#import "MLRNCamera.h"
+
+@interface CameraStop : NSObject
+
+@property (nonatomic, assign) CLLocationCoordinate2D center;
+
+@property (nonatomic, strong) NSNumber *zoom;
+@property (nonatomic, strong) NSNumber *bearing;
+@property (nonatomic, strong) NSNumber *pitch;
+
+@property (nonatomic, assign) MLNCoordinateBounds bounds;
+@property (nonatomic, assign) UIEdgeInsets padding;
+
+@property (nonatomic, assign) NSTimeInterval duration;
+@property (nonatomic, strong) NSNumber *easing;
+
++ (CameraStop *)fromDictionary:(NSDictionary *)args;
+
+@end