@lugg/maps 0.2.0-alpha.8 → 1.0.0-beta.0

package/ios/core/MKPolylineAnimator.m

@@ -1,12 +1,42 @@
 #import "MKPolylineAnimator.h"
 #import <QuartzCore/QuartzCore.h>
 
+@interface MKDisplayLinkProxy : NSObject
+@property(nonatomic, weak) id target;
+@property(nonatomic, assign) SEL selector;
+@end
+
+@implementation MKDisplayLinkProxy
+- (instancetype)initWithTarget:(id)target selector:(SEL)selector {
+  if (self = [super init]) {
+    _target = target;
+    _selector = selector;
+  }
+  return self;
+}
+- (void)tick:(CADisplayLink *)displayLink {
+  if (_target) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+    [_target performSelector:_selector withObject:displayLink];
+#pragma clang diagnostic pop
+  } else {
+    [displayLink invalidate];
+  }
+}
+@end
+
 @implementation MKPolylineAnimator {
   MKPolyline *_polyline;
   CADisplayLink *_displayLink;
+  MKDisplayLinkProxy *_displayLinkProxy;
   CGFloat _animationProgress;
+  CGFloat _delayRemaining;
   NSArray<NSNumber *> *_cumulativeDistances;
   CGFloat _totalLength;
+  CGColorSpaceRef _colorSpace;
+  RGBAComponents *_colorCache;
+  NSUInteger _colorCacheCount;
 }
 
 - (id)initWithPolyline:(MKPolyline *)polyline {
@@ -14,13 +44,28 @@
   if (self) {
     _polyline = polyline;
     _animationProgress = 0;
+    _animatedOptions = [PolylineAnimatedOptions defaultOptions];
+    _colorSpace = CGColorSpaceCreateDeviceRGB();
     [self createPath];
   }
   return self;
 }
 
+- (void)setAnimatedOptions:(PolylineAnimatedOptions *)animatedOptions {
+  _animatedOptions = animatedOptions ?: [PolylineAnimatedOptions defaultOptions];
+  if (_animated && _displayLink) {
+    [self stopAnimation];
+    [self startAnimation];
+  }
+}
+
 - (void)dealloc {
   [self stopAnimation];
+  free(_colorCache);
+  if (_colorSpace) {
+    CGColorSpaceRelease(_colorSpace);
+    _colorSpace = NULL;
+  }
 }
 
 - (void)setAnimated:(BOOL)animated {
@@ -42,7 +87,9 @@
   }
   [self computeCumulativeDistances];
   _animationProgress = 0;
-  _displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(animationTick:)];
+  _delayRemaining = _animatedOptions.delay / 1000.0;
+  _displayLinkProxy = [[MKDisplayLinkProxy alloc] initWithTarget:self selector:@selector(animationTick:)];
+  _displayLink = [CADisplayLink displayLinkWithTarget:_displayLinkProxy selector:@selector(tick:)];
   [_displayLink addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
 }
 
@@ -65,23 +112,64 @@
 - (void)stopAnimation {
   [_displayLink invalidate];
   _displayLink = nil;
+  _displayLinkProxy = nil;
+}
+
+- (void)pause {
+  _displayLink.paused = YES;
+}
+
+- (void)resume {
+  _displayLink.paused = NO;
 }
 
 - (NSUInteger)indexForDistance:(CGFloat)distance {
-  for (NSUInteger i = 1; i < _cumulativeDistances.count; i++) {
-    if (_cumulativeDistances[i].doubleValue >= distance) {
-      return i - 1;
+  NSUInteger left = 0;
+  NSUInteger right = _cumulativeDistances.count - 1;
+
+  while (left < right) {
+    NSUInteger mid = (left + right + 1) / 2;
+    if (_cumulativeDistances[mid].doubleValue <= distance) {
+      left = mid;
+    } else {
+      right = mid - 1;
     }
   }
-  return _cumulativeDistances.count - 2;
+
+  return MIN(left, _cumulativeDistances.count - 2);
+}
+
+- (CGFloat)applyEasing:(CGFloat)t {
+  NSString *easing = _animatedOptions.easing ?: @"linear";
+
+  if ([easing isEqualToString:@"easeIn"]) {
+    return t * t;
+  } else if ([easing isEqualToString:@"easeOut"]) {
+    return t * (2 - t);
+  } else if ([easing isEqualToString:@"easeInOut"]) {
+    return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+  }
+  return t;
 }
 
 - (void)animationTick:(CADisplayLink *)displayLink {
-  CGFloat speed = displayLink.duration / 1.0;
+  if (_delayRemaining > 0) {
+    _delayRemaining -= displayLink.duration;
+    return;
+  }
+
+  CGFloat duration = _animatedOptions.duration / 1000.0;
+  if (duration <= 0) duration = 2.15;
+
+  CGFloat trailLength = MAX(0.01, MIN(1.0, _animatedOptions.trailLength));
+  CGFloat maxProgress = (trailLength < 1.0) ? 1.0 : 2.15;
+
+  CGFloat speed = displayLink.duration / duration;
   _animationProgress += speed;
 
-  if (_animationProgress >= 2.15) {
+  if (_animationProgress >= maxProgress) {
     _animationProgress = 0;
+    _delayRemaining = _animatedOptions.delay / 1000.0;
   }
 
   MKMapRect bounds = _polyline.boundingMapRect;
@@ -114,34 +202,60 @@
   self.path = path;
 }
 
-- (UIColor *)colorAtGradientPosition:(CGFloat)position {
-  if (!_strokeColors || _strokeColors.count == 0) {
-    return self.strokeColor;
+- (void)setStrokeColors:(NSArray<UIColor *> *)strokeColors {
+  _strokeColors = strokeColors;
+  [self rebuildColorCache];
+}
+
+- (void)rebuildColorCache {
+  free(_colorCache);
+  _colorCache = NULL;
+  _colorCacheCount = _strokeColors.count;
+  if (_colorCacheCount == 0) return;
+
+  _colorCache = (RGBAComponents *)malloc(sizeof(RGBAComponents) * _colorCacheCount);
+  for (NSUInteger i = 0; i < _colorCacheCount; i++) {
+    [_strokeColors[i] getRed:&_colorCache[i].r
+                       green:&_colorCache[i].g
+                        blue:&_colorCache[i].b
+                       alpha:&_colorCache[i].a];
+  }
+}
+
+- (void)colorAtGradientPosition:(CGFloat)position rgba:(RGBAComponents *)out {
+  if (_colorCacheCount == 0) {
+    CGFloat r, g, b, a;
+    [self.strokeColor getRed:&r green:&g blue:&b alpha:&a];
+    *out = (RGBAComponents){r, g, b, a};
+    return;
   }
-  if (_strokeColors.count == 1) {
-    return _strokeColors[0];
+  if (_colorCacheCount == 1) {
+    *out = _colorCache[0];
+    return;
   }
 
   position = MAX(0, MIN(1, position));
-  CGFloat scaledPos = position * (_strokeColors.count - 1);
-  NSUInteger index = (NSUInteger)floor(scaledPos);
+  CGFloat scaledPos = position * (_colorCacheCount - 1);
+  NSUInteger index = (NSUInteger)scaledPos;
   CGFloat t = scaledPos - index;
 
-  if (index >= _strokeColors.count - 1) {
-    return _strokeColors.lastObject;
+  if (index >= _colorCacheCount - 1) {
+    *out = _colorCache[_colorCacheCount - 1];
+    return;
   }
 
-  UIColor *c1 = _strokeColors[index];
-  UIColor *c2 = _strokeColors[index + 1];
-
-  CGFloat r1, g1, b1, a1, r2, g2, b2, a2;
-  [c1 getRed:&r1 green:&g1 blue:&b1 alpha:&a1];
-  [c2 getRed:&r2 green:&g2 blue:&b2 alpha:&a2];
+  RGBAComponents c1 = _colorCache[index];
+  RGBAComponents c2 = _colorCache[index + 1];
+  out->r = c1.r + (c2.r - c1.r) * t;
+  out->g = c1.g + (c2.g - c1.g) * t;
+  out->b = c1.b + (c2.b - c1.b) * t;
+  out->a = c1.a + (c2.a - c1.a) * t;
+}
 
-  return [UIColor colorWithRed:r1 + (r2 - r1) * t
-                         green:g1 + (g2 - g1) * t
-                          blue:b1 + (b2 - b1) * t
-                         alpha:a1 + (a2 - a1) * t];
+- (UIColor *)colorAtGradientPosition:(CGFloat)position {
+  RGBAComponents rgba;
+  [self colorAtGradientPosition:position rgba:&rgba];
+  return [UIColor colorWithRed:rgba.r green:rgba.g blue:rgba.b alpha:rgba.a];
 }
 
 - (void)drawMapRect:(MKMapRect)mapRect
@@ -165,14 +279,21 @@
 
   // Snake animation: grow from start, then shrink from start
   if (_animated && _polyline.pointCount > 1 && _totalLength > 0) {
-    CGFloat progress = MIN(_animationProgress, 2.0);
+    CGFloat trailLength = MAX(0.01, MIN(1.0, _animatedOptions.trailLength));
+    CGFloat maxProgress = (trailLength < 1.0) ? 1.0 : 2.0;
+    CGFloat progress = MIN(_animationProgress, maxProgress);
+    CGFloat easedProgress = [self applyEasing:progress / maxProgress] * maxProgress;
+
     CGFloat headDist, tailDist;
 
-    if (progress <= 1.0) {
+    if (trailLength < 1.0) {
+      headDist = easedProgress * _totalLength;
+      tailDist = MAX(0, headDist - _totalLength * trailLength);
+    } else if (easedProgress <= 1.0) {
       tailDist = 0;
-      headDist = progress * _totalLength;
+      headDist = easedProgress * _totalLength;
     } else {
-      CGFloat shrinkProgress = progress - 1.0;
+      CGFloat shrinkProgress = easedProgress - 1.0;
       tailDist = shrinkProgress * _totalLength;
       headDist = _totalLength;
     }
@@ -219,12 +340,15 @@
       CGFloat gradientStart = (drawStartDist - tailDist) / visibleLength;
       CGFloat gradientEnd = (drawEndDist - tailDist) / visibleLength;
 
-      UIColor *startColor = [self colorAtGradientPosition:gradientStart];
-      UIColor *endColor = [self colorAtGradientPosition:gradientEnd];
+      RGBAComponents startRGBA, endRGBA;
+      [self colorAtGradientPosition:gradientStart rgba:&startRGBA];
+      [self colorAtGradientPosition:gradientEnd rgba:&endRGBA];
 
-      CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
-      NSArray *colors = @[(__bridge id)startColor.CGColor, (__bridge id)endColor.CGColor];
-      CGGradientRef gradient = CGGradientCreateWithColors(colorSpace, (__bridge CFArrayRef)colors, NULL);
+      CGFloat components[] = {
+        startRGBA.r, startRGBA.g, startRGBA.b, startRGBA.a,
+        endRGBA.r, endRGBA.g, endRGBA.b, endRGBA.a
+      };
+      CGGradientRef gradient = CGGradientCreateWithColorComponents(_colorSpace, components, NULL, 2);
 
       CGContextSaveGState(context);
       CGContextBeginPath(context);
@@ -237,7 +361,6 @@
 
       CGContextRestoreGState(context);
       CGGradientRelease(gradient);
-      CGColorSpaceRelease(colorSpace);
     }
     return;
   }
@@ -251,12 +374,15 @@
       CGFloat gradientStart = (CGFloat)i / segmentCount;
       CGFloat gradientEnd = (CGFloat)(i + 1) / segmentCount;
 
-      UIColor *startColor = [self colorAtGradientPosition:gradientStart];
-      UIColor *endColor = [self colorAtGradientPosition:gradientEnd];
+      RGBAComponents startRGBA, endRGBA;
+      [self colorAtGradientPosition:gradientStart rgba:&startRGBA];
+      [self colorAtGradientPosition:gradientEnd rgba:&endRGBA];
 
-      CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
-      NSArray *colors = @[(__bridge id)startColor.CGColor, (__bridge id)endColor.CGColor];
-      CGGradientRef gradient = CGGradientCreateWithColors(colorSpace, (__bridge CFArrayRef)colors, NULL);
+      CGFloat components[] = {
+        startRGBA.r, startRGBA.g, startRGBA.b, startRGBA.a,
+        endRGBA.r, endRGBA.g, endRGBA.b, endRGBA.a
+      };
+      CGGradientRef gradient = CGGradientCreateWithColorComponents(_colorSpace, components, NULL, 2);
 
       CGContextSaveGState(context);
       CGContextBeginPath(context);
@@ -269,7 +395,6 @@
 
       CGContextRestoreGState(context);
       CGGradientRelease(gradient);
-      CGColorSpaceRelease(colorSpace);
     }
     return;
   }

package/ios/core/MapProviderDelegate.h

@@ -0,0 +1,84 @@
+#import <CoreLocation/CoreLocation.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class LuggMarkerView;
+@class LuggPolylineView;
+@class LuggPolygonView;
+
+@protocol MapProviderDelegate <NSObject>
+- (void)mapProviderDidReady;
+- (void)mapProviderDidMoveCamera:(double)latitude
+                       longitude:(double)longitude
+                            zoom:(double)zoom
+                         gesture:(BOOL)gesture;
+- (void)mapProviderDidIdleCamera:(double)latitude
+                       longitude:(double)longitude
+                            zoom:(double)zoom
+                         gesture:(BOOL)gesture;
+- (void)mapProviderDidPress:(double)latitude
+                  longitude:(double)longitude
+                          x:(double)x
+                          y:(double)y;
+- (void)mapProviderDidLongPress:(double)latitude
+                      longitude:(double)longitude
+                              x:(double)x
+                              y:(double)y;
+@end
+
+@protocol MapProvider <NSObject>
+
+@property(nonatomic, weak, nullable) id<MapProviderDelegate> delegate;
+@property(nonatomic, readonly) BOOL isMapReady;
+
+- (void)initializeMapInView:(UIView *)wrapperView
+          initialCoordinate:(CLLocationCoordinate2D)coordinate
+                initialZoom:(double)zoom;
+- (void)destroy;
+
+// Props
+- (void)setZoomEnabled:(BOOL)enabled;
+- (void)setScrollEnabled:(BOOL)enabled;
+- (void)setRotateEnabled:(BOOL)enabled;
+- (void)setPitchEnabled:(BOOL)enabled;
+- (void)setUserLocationEnabled:(BOOL)enabled;
+- (void)setTheme:(NSInteger)theme;
+- (void)setMinZoom:(double)minZoom;
+- (void)setMaxZoom:(double)maxZoom;
+- (void)setEdgeInsets:(UIEdgeInsets)edgeInsets
+        oldEdgeInsets:(UIEdgeInsets)oldEdgeInsets;
+- (void)setEdgeInsets:(UIEdgeInsets)edgeInsets
+        oldEdgeInsets:(UIEdgeInsets)oldEdgeInsets
+             duration:(double)duration;
+
+// Children
+- (void)addMarkerView:(LuggMarkerView *)markerView;
+- (void)removeMarkerView:(LuggMarkerView *)markerView;
+- (void)syncMarkerView:(LuggMarkerView *)markerView;
+- (void)addPolylineView:(LuggPolylineView *)polylineView;
+- (void)removePolylineView:(LuggPolylineView *)polylineView;
+- (void)syncPolylineView:(LuggPolylineView *)polylineView;
+- (void)addPolygonView:(LuggPolygonView *)polygonView;
+- (void)removePolygonView:(LuggPolygonView *)polygonView;
+- (void)syncPolygonView:(LuggPolygonView *)polygonView;
+
+// Lifecycle
+- (void)pauseAnimations;
+- (void)resumeAnimations;
+
+// Commands
+- (void)moveCamera:(double)latitude
+         longitude:(double)longitude
+              zoom:(double)zoom
+          duration:(double)duration;
+- (void)fitCoordinates:(NSArray *)coordinates
+         edgeInsetsTop:(double)edgeInsetsTop
+        edgeInsetsLeft:(double)edgeInsetsLeft
+      edgeInsetsBottom:(double)edgeInsetsBottom
+       edgeInsetsRight:(double)edgeInsetsRight
+              duration:(double)duration;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/core/PolylineAnimatorBase.h

@@ -2,21 +2,44 @@
 #import <Foundation/Foundation.h>
 #import <UIKit/UIKit.h>
 
+@interface PolylineAnimatedOptions : NSObject
+
+@property(nonatomic, assign) NSTimeInterval duration;
+@property(nonatomic, copy) NSString *easing;
+@property(nonatomic, assign) CGFloat trailLength;
+@property(nonatomic, assign) NSTimeInterval delay;
+
++ (instancetype)defaultOptions;
+
+@end
+
 @protocol PolylineAnimator <NSObject>
 
 @property(nonatomic, strong) NSArray<CLLocation *> *coordinates;
 @property(nonatomic, strong) NSArray<UIColor *> *strokeColors;
 @property(nonatomic, assign) BOOL animated;
+@property(nonatomic, strong) PolylineAnimatedOptions *animatedOptions;
 
 - (void)update;
 
 @end
 
-@interface PolylineAnimatorBase : NSObject
+typedef struct {
+  CGFloat r, g, b, a;
+} RGBAComponents;
+
+@interface PolylineAnimatorBase : NSObject {
+@protected
+  RGBAComponents *_colorCache;
+  NSUInteger _colorCacheCount;
+}
 
 @property(nonatomic, strong) NSArray<CLLocation *> *coordinates;
 @property(nonatomic, strong) NSArray<UIColor *> *strokeColors;
+@property(nonatomic, strong) PolylineAnimatedOptions *animatedOptions;
 
 - (UIColor *)colorAtGradientPosition:(CGFloat)position;
+- (void)colorAtGradientPosition:(CGFloat)position rgba:(RGBAComponents *)out;
+- (CGFloat)applyEasing:(CGFloat)t;
 
 @end

package/ios/core/PolylineAnimatorBase.m

@@ -1,35 +1,98 @@
 #import "PolylineAnimatorBase.h"
 
+@implementation PolylineAnimatedOptions
+
++ (instancetype)defaultOptions {
+  PolylineAnimatedOptions *options = [[PolylineAnimatedOptions alloc] init];
+  options.duration = 2.15;
+  options.easing = @"linear";
+  options.trailLength = 1.0;
+  options.delay = 0;
+  return options;
+}
+
+@end
+
 @implementation PolylineAnimatorBase
 
-- (UIColor *)colorAtGradientPosition:(CGFloat)position {
-  if (!_strokeColors || _strokeColors.count == 0) {
-    return [UIColor blackColor];
+- (instancetype)init {
+  if (self = [super init]) {
+    _animatedOptions = [PolylineAnimatedOptions defaultOptions];
+    _colorCache = NULL;
+    _colorCacheCount = 0;
+  }
+  return self;
+}
+
+- (void)dealloc {
+  free(_colorCache);
+}
+
+- (void)setStrokeColors:(NSArray<UIColor *> *)strokeColors {
+  _strokeColors = strokeColors;
+  [self rebuildColorCache];
+}
+
+- (void)rebuildColorCache {
+  free(_colorCache);
+  _colorCache = NULL;
+  _colorCacheCount = _strokeColors.count;
+  if (_colorCacheCount == 0) return;
+
+  _colorCache = (RGBAComponents *)malloc(sizeof(RGBAComponents) * _colorCacheCount);
+  for (NSUInteger i = 0; i < _colorCacheCount; i++) {
+    [_strokeColors[i] getRed:&_colorCache[i].r
+                       green:&_colorCache[i].g
+                        blue:&_colorCache[i].b
+                       alpha:&_colorCache[i].a];
+  }
+}
+
+- (CGFloat)applyEasing:(CGFloat)t {
+  NSString *easing = self.animatedOptions.easing ?: @"linear";
+
+  if ([easing isEqualToString:@"easeIn"]) {
+    return t * t;
+  } else if ([easing isEqualToString:@"easeOut"]) {
+    return t * (2 - t);
+  } else if ([easing isEqualToString:@"easeInOut"]) {
+    return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
   }
-  if (_strokeColors.count == 1) {
-    return _strokeColors[0];
+  return t;
+}
+
+- (void)colorAtGradientPosition:(CGFloat)position rgba:(RGBAComponents *)out {
+  if (_colorCacheCount == 0) {
+    *out = (RGBAComponents){0, 0, 0, 1};
+    return;
+  }
+  if (_colorCacheCount == 1) {
+    *out = _colorCache[0];
+    return;
   }
 
   position = MAX(0, MIN(1, position));
-  CGFloat scaledPos = position * (_strokeColors.count - 1);
-  NSUInteger index = (NSUInteger)floor(scaledPos);
+  CGFloat scaledPos = position * (_colorCacheCount - 1);
+  NSUInteger index = (NSUInteger)scaledPos;
   CGFloat t = scaledPos - index;
 
-  if (index >= _strokeColors.count - 1) {
-    return _strokeColors.lastObject;
+  if (index >= _colorCacheCount - 1) {
+    *out = _colorCache[_colorCacheCount - 1];
+    return;
   }
 
-  UIColor *c1 = _strokeColors[index];
-  UIColor *c2 = _strokeColors[index + 1];
-
-  CGFloat r1, g1, b1, a1, r2, g2, b2, a2;
-  [c1 getRed:&r1 green:&g1 blue:&b1 alpha:&a1];
-  [c2 getRed:&r2 green:&g2 blue:&b2 alpha:&a2];
+  RGBAComponents c1 = _colorCache[index];
+  RGBAComponents c2 = _colorCache[index + 1];
+  out->r = c1.r + (c2.r - c1.r) * t;
+  out->g = c1.g + (c2.g - c1.g) * t;
+  out->b = c1.b + (c2.b - c1.b) * t;
+  out->a = c1.a + (c2.a - c1.a) * t;
+}
 
-  return [UIColor colorWithRed:r1 + (r2 - r1) * t
-                         green:g1 + (g2 - g1) * t
-                          blue:b1 + (b2 - b1) * t
-                         alpha:a1 + (a2 - a1) * t];
+- (UIColor *)colorAtGradientPosition:(CGFloat)position {
+  RGBAComponents rgba;
+  [self colorAtGradientPosition:position rgba:&rgba];
+  return [UIColor colorWithRed:rgba.r green:rgba.g blue:rgba.b alpha:rgba.a];
 }
 
 @end

package/ios/events/LongPressEvent.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#import <react/renderer/components/RNMapsSpec/EventEmitters.h>
+
+namespace luggmaps {
+namespace events {
+
+struct LongPressEvent {
+  double latitude;
+  double longitude;
+  double x;
+  double y;
+
+  template <typename Emitter>
+  void emit(const facebook::react::SharedEventEmitter &eventEmitter) const {
+    if (!eventEmitter)
+      return;
+    auto emitter = std::static_pointer_cast<Emitter const>(eventEmitter);
+    typename Emitter::OnMapLongPress event;
+    event.coordinate.latitude = latitude;
+    event.coordinate.longitude = longitude;
+    event.point.x = x;
+    event.point.y = y;
+    emitter->onMapLongPress(event);
+  }
+};
+
+} // namespace events
+} // namespace luggmaps

package/ios/events/MarkerDragEvent.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#import <react/renderer/components/RNMapsSpec/EventEmitters.h>
+
+namespace luggmaps {
+namespace events {
+
+struct MarkerDragStartEvent {
+  double latitude;
+  double longitude;
+  double x;
+  double y;
+
+  template <typename Emitter>
+  void emit(const facebook::react::SharedEventEmitter &eventEmitter) const {
+    if (!eventEmitter)
+      return;
+    auto emitter = std::static_pointer_cast<Emitter const>(eventEmitter);
+    typename Emitter::OnMarkerDragStart event;
+    event.coordinate.latitude = latitude;
+    event.coordinate.longitude = longitude;
+    event.point.x = x;
+    event.point.y = y;
+    emitter->onMarkerDragStart(event);
+  }
+};
+
+struct MarkerDragChangeEvent {
+  double latitude;
+  double longitude;
+  double x;
+  double y;
+
+  template <typename Emitter>
+  void emit(const facebook::react::SharedEventEmitter &eventEmitter) const {
+    if (!eventEmitter)
+      return;
+    auto emitter = std::static_pointer_cast<Emitter const>(eventEmitter);
+    typename Emitter::OnMarkerDragChange event;
+    event.coordinate.latitude = latitude;
+    event.coordinate.longitude = longitude;
+    event.point.x = x;
+    event.point.y = y;
+    emitter->onMarkerDragChange(event);
+  }
+};
+
+struct MarkerDragEndEvent {
+  double latitude;
+  double longitude;
+  double x;
+  double y;
+
+  template <typename Emitter>
+  void emit(const facebook::react::SharedEventEmitter &eventEmitter) const {
+    if (!eventEmitter)
+      return;
+    auto emitter = std::static_pointer_cast<Emitter const>(eventEmitter);
+    typename Emitter::OnMarkerDragEnd event;
+    event.coordinate.latitude = latitude;
+    event.coordinate.longitude = longitude;
+    event.point.x = x;
+    event.point.y = y;
+    emitter->onMarkerDragEnd(event);
+  }
+};
+
+} // namespace events
+} // namespace luggmaps

package/ios/events/MarkerPressEvent.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#import <react/renderer/components/RNMapsSpec/EventEmitters.h>
+
+namespace luggmaps {
+namespace events {
+
+struct MarkerPressEvent {
+  double latitude;
+  double longitude;
+  double x;
+  double y;
+
+  template <typename Emitter>
+  void emit(const facebook::react::SharedEventEmitter &eventEmitter) const {
+    if (!eventEmitter)
+      return;
+    auto emitter = std::static_pointer_cast<Emitter const>(eventEmitter);
+    typename Emitter::OnMarkerPress event;
+    event.coordinate.latitude = latitude;
+    event.coordinate.longitude = longitude;
+    event.point.x = x;
+    event.point.y = y;
+    emitter->onMarkerPress(event);
+  }
+};
+
+} // namespace events
+} // namespace luggmaps