@lugg/maps 0.2.0-alpha.0

package/ios/LuggMapsPolylineView.mm

@@ -0,0 +1,116 @@
+#import "LuggMapsPolylineView.h"
+
+#import <react/renderer/components/RNMapsSpec/ComponentDescriptors.h>
+#import <react/renderer/components/RNMapsSpec/EventEmitters.h>
+#import <react/renderer/components/RNMapsSpec/Props.h>
+#import <react/renderer/components/RNMapsSpec/RCTComponentViewHelpers.h>
+
+#import "RCTFabricComponentsPlugins.h"
+#import <React/RCTConversions.h>
+
+using namespace facebook::react;
+
+@interface LuggMapsPolylineView () <RCTLuggMapsPolylineViewViewProtocol>
+@end
+
+@implementation LuggMapsPolylineView {
+  NSArray<CLLocation *> *_coordinates;
+  NSArray<UIColor *> *_strokeColors;
+  BOOL _animated;
+  CGFloat _strokeWidth;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<
+      LuggMapsPolylineViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps =
+        std::make_shared<const LuggMapsPolylineViewProps>();
+    _props = defaultProps;
+
+    _coordinates = @[];
+    _strokeColors = @[ [UIColor blackColor] ];
+    _strokeWidth = 1.0;
+
+    self.hidden = YES;
+  }
+
+  return self;
+}
+
+- (void)updateProps:(Props::Shared const &)props
+           oldProps:(Props::Shared const &)oldProps {
+  [super updateProps:props oldProps:oldProps];
+  const auto &newViewProps =
+      *std::static_pointer_cast<LuggMapsPolylineViewProps const>(props);
+
+  NSMutableArray<CLLocation *> *coords = [NSMutableArray array];
+  for (const auto &coord : newViewProps.coordinates) {
+    CLLocation *location =
+        [[CLLocation alloc] initWithLatitude:coord.latitude
+                                   longitude:coord.longitude];
+    [coords addObject:location];
+  }
+  _coordinates = [coords copy];
+
+  NSMutableArray<UIColor *> *colors = [NSMutableArray array];
+  for (const auto &color : newViewProps.strokeColors) {
+    UIColor *uiColor = RCTUIColorFromSharedColor(color);
+    if (uiColor) {
+      [colors addObject:uiColor];
+    }
+  }
+  NSArray<UIColor *> *newColors =
+      colors.count > 0 ? [colors copy] : @[ [UIColor blackColor] ];
+  if (![newColors isEqualToArray:_strokeColors]) {
+    _strokeColors = newColors;
+    self.cachedSpans = nil;
+  }
+
+  _animated = newViewProps.animated;
+
+  _strokeWidth = newViewProps.strokeWidth > 0 ? newViewProps.strokeWidth : 1.0;
+}
+
+- (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask {
+  [super finalizeUpdates:updateMask];
+
+  if (updateMask & RNComponentViewUpdateMaskProps) {
+    if ([self.delegate respondsToSelector:@selector(polylineViewDidUpdate:)]) {
+      [self.delegate polylineViewDidUpdate:self];
+    }
+  }
+}
+
+- (NSArray<CLLocation *> *)coordinates {
+  return _coordinates;
+}
+
+- (NSArray<UIColor *> *)strokeColors {
+  return _strokeColors;
+}
+
+- (BOOL)animated {
+  return _animated;
+}
+
+- (CGFloat)strokeWidth {
+  return _strokeWidth;
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+  self.polyline = nil;
+  self.renderer = nil;
+  self.cachedSpans = nil;
+  self.delegate = nil;
+}
+
+Class<RCTComponentViewProtocol> LuggMapsPolylineViewCls(void) {
+  return LuggMapsPolylineView.class;
+}
+
+@end

package/ios/LuggMapsWrapperView.h

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

package/ios/LuggMapsWrapperView.mm

@@ -0,0 +1,36 @@
+#import "LuggMapsWrapperView.h"
+
+#import <react/renderer/components/RNMapsSpec/ComponentDescriptors.h>
+#import <react/renderer/components/RNMapsSpec/EventEmitters.h>
+#import <react/renderer/components/RNMapsSpec/Props.h>
+#import <react/renderer/components/RNMapsSpec/RCTComponentViewHelpers.h>
+
+#import "RCTFabricComponentsPlugins.h"
+
+using namespace facebook::react;
+
+@interface LuggMapsWrapperView () <RCTLuggMapsWrapperViewViewProtocol>
+@end
+
+@implementation LuggMapsWrapperView
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<
+      LuggMapsWrapperViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps =
+        std::make_shared<const LuggMapsWrapperViewProps>();
+    _props = defaultProps;
+  }
+
+  return self;
+}
+
+Class<RCTComponentViewProtocol> LuggMapsWrapperViewCls(void) {
+  return LuggMapsWrapperView.class;
+}
+
+@end

package/ios/core/GMSPolylineAnimator.h

@@ -0,0 +1,11 @@
+#import "PolylineAnimatorBase.h"
+#import <GoogleMaps/GoogleMaps.h>
+
+@interface GMSPolylineAnimator : PolylineAnimatorBase <PolylineAnimator>
+
+@property(nonatomic, weak) GMSPolyline *polyline;
+@property(nonatomic, assign) BOOL animated;
+
+- (void)update;
+
+@end

package/ios/core/GMSPolylineAnimator.m

@@ -0,0 +1,151 @@
+#import "GMSPolylineAnimator.h"
+#import <QuartzCore/QuartzCore.h>
+
+@implementation GMSPolylineAnimator {
+  CADisplayLink *_displayLink;
+  CGFloat _animationProgress;
+}
+
+- (void)dealloc {
+  [self stopAnimation];
+}
+
+- (void)setAnimated:(BOOL)animated {
+  if (_animated == animated) {
+    return;
+  }
+  _animated = animated;
+
+  if (_animated) {
+    [self startAnimation];
+  } else {
+    [self stopAnimation];
+    [self update];
+  }
+}
+
+- (void)startAnimation {
+  if (_displayLink) {
+    return;
+  }
+  _animationProgress = 0;
+  _displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(animationTick:)];
+  [_displayLink addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
+}
+
+- (void)stopAnimation {
+  [_displayLink invalidate];
+  _displayLink = nil;
+}
+
+- (void)animationTick:(CADisplayLink *)displayLink {
+  CGFloat speed = displayLink.duration / 1.75;
+  _animationProgress += speed;
+
+  if (_animationProgress >= 2.15) {
+    _animationProgress = 0;
+  }
+
+  [self updateAnimatedPolyline];
+}
+
+- (void)update {
+  if (_animated) {
+    return;
+  }
+
+  if (!_polyline || self.coordinates.count < 2) {
+    return;
+  }
+
+  GMSMutablePath *path = [GMSMutablePath path];
+  for (CLLocation *location in self.coordinates) {
+    [path addCoordinate:location.coordinate];
+  }
+  _polyline.path = path;
+
+  if (self.strokeColors.count > 1) {
+    _polyline.spans = [self createGradientSpans];
+  } else {
+    _polyline.strokeColor = self.strokeColors.firstObject ?: [UIColor blackColor];
+  }
+}
+
+- (void)updateAnimatedPolyline {
+  if (!_polyline || self.coordinates.count < 2) {
+    return;
+  }
+
+  NSUInteger segmentCount = self.coordinates.count - 1;
+  CGFloat progress = MIN(_animationProgress, 2.0);
+  CGFloat headPos, tailPos;
+
+  if (progress <= 1.0) {
+    tailPos = 0;
+    headPos = progress * segmentCount;
+  } else {
+    CGFloat shrinkProgress = progress - 1.0;
+    tailPos = shrinkProgress * segmentCount;
+    headPos = segmentCount;
+  }
+
+  if (headPos <= tailPos) {
+    _polyline.path = [GMSMutablePath path];
+    return;
+  }
+
+  NSUInteger startIndex = (NSUInteger)floor(tailPos);
+  NSUInteger endIndex = (NSUInteger)ceil(headPos);
+  CGFloat visibleLength = headPos - tailPos;
+
+  GMSMutablePath *path = [GMSMutablePath path];
+  NSMutableArray<GMSStyleSpan *> *spans = [NSMutableArray array];
+
+  for (NSUInteger i = startIndex; i <= endIndex && i < self.coordinates.count; i++) {
+    CLLocationCoordinate2D coord = self.coordinates[i].coordinate;
+
+    if (i == startIndex && tailPos > (CGFloat)startIndex) {
+      CGFloat t = tailPos - (CGFloat)startIndex;
+      CLLocationCoordinate2D nextCoord = self.coordinates[i + 1].coordinate;
+      coord.latitude = coord.latitude + (nextCoord.latitude - coord.latitude) * t;
+      coord.longitude = coord.longitude + (nextCoord.longitude - coord.longitude) * t;
+    }
+
+    if (i == endIndex && headPos < (CGFloat)endIndex && i > 0) {
+      CGFloat t = headPos - (CGFloat)(endIndex - 1);
+      CLLocationCoordinate2D prevCoord = self.coordinates[i - 1].coordinate;
+      coord.latitude = prevCoord.latitude + (coord.latitude - prevCoord.latitude) * t;
+      coord.longitude = prevCoord.longitude + (coord.longitude - prevCoord.longitude) * t;
+    }
+
+    [path addCoordinate:coord];
+
+    if (i < endIndex && i < segmentCount) {
+      CGFloat segStartPos = MAX((CGFloat)i, tailPos);
+      CGFloat segEndPos = MIN((CGFloat)(i + 1), headPos);
+      CGFloat gradientMid = ((segStartPos + segEndPos) / 2.0 - tailPos) / visibleLength;
+      UIColor *color = [self colorAtGradientPosition:gradientMid];
+      GMSStrokeStyle *style = [GMSStrokeStyle solidColor:color];
+      [spans addObject:[GMSStyleSpan spanWithStyle:style]];
+    }
+  }
+
+  _polyline.path = path;
+  _polyline.spans = spans;
+}
+
+- (NSArray<GMSStyleSpan *> *)createGradientSpans {
+  NSMutableArray<GMSStyleSpan *> *spans = [NSMutableArray array];
+  NSUInteger segmentCount = self.coordinates.count - 1;
+
+  for (NSUInteger i = 0; i < segmentCount; i++) {
+    CGFloat position = (CGFloat)i / (CGFloat)segmentCount;
+    UIColor *color = [self colorAtGradientPosition:position];
+    GMSStrokeStyle *style = [GMSStrokeStyle solidColor:color];
+    [spans addObject:[GMSStyleSpan spanWithStyle:style]];
+  }
+
+  return spans;
+}
+
+@end

package/ios/core/MKPolylineAnimator.h

@@ -0,0 +1,12 @@
+#import <MapKit/MapKit.h>
+
+@interface MKPolylineAnimator : MKOverlayPathRenderer
+
+- (id)initWithPolyline:(MKPolyline *)polyline;
+
+@property(nonatomic, strong) NSArray<UIColor *> *strokeColors;
+@property(nonatomic, assign) BOOL animated;
+
+- (void)updatePolyline:(MKPolyline *)polyline;
+
+@end

package/ios/core/MKPolylineAnimator.m

@@ -0,0 +1,252 @@
+#import "MKPolylineAnimator.h"
+#import <QuartzCore/QuartzCore.h>
+
+@implementation MKPolylineAnimator {
+  MKPolyline *_polyline;
+  CADisplayLink *_displayLink;
+  CGFloat _animationProgress; // 0→1 grow, 1→2 shrink
+}
+
+- (id)initWithPolyline:(MKPolyline *)polyline {
+  self = [super initWithOverlay:polyline];
+  if (self) {
+    _polyline = polyline;
+    _animationProgress = 0;
+    [self createPath];
+  }
+  return self;
+}
+
+- (void)dealloc {
+  [self stopAnimation];
+}
+
+- (void)setAnimated:(BOOL)animated {
+  if (_animated == animated) {
+    return;
+  }
+  _animated = animated;
+
+  if (_animated) {
+    [self startAnimation];
+  } else {
+    [self stopAnimation];
+  }
+}
+
+- (void)startAnimation {
+  if (_displayLink) {
+    return;
+  }
+  _animationProgress = 0;
+  _displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(animationTick:)];
+  [_displayLink addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
+}
+
+- (void)stopAnimation {
+  [_displayLink invalidate];
+  _displayLink = nil;
+}
+
+- (void)animationTick:(CADisplayLink *)displayLink {
+  // ~1.75s per phase (grow or shrink), matching JS duration
+  CGFloat speed = displayLink.duration / 1.75;
+  _animationProgress += speed;
+
+  // 0→1 grow, 1→2 shrink, then reset with small pause
+  if (_animationProgress >= 2.15) { // 2.0 + 0.15 pause (~300ms at this speed)
+    _animationProgress = 0;
+  }
+
+  MKMapRect bounds = _polyline.boundingMapRect;
+  bounds = MKMapRectInset(bounds, -bounds.size.width * 0.1, -bounds.size.height * 0.1);
+  [self setNeedsDisplayInMapRect:bounds];
+}
+
+- (void)updatePolyline:(MKPolyline *)polyline {
+  _polyline = polyline;
+  [self invalidatePath];
+  [self createPath];
+  [self setNeedsDisplay];
+}
+
+- (void)createPath {
+  CGMutablePathRef path = CGPathCreateMutable();
+  BOOL first = YES;
+  for (NSUInteger i = 0; i < _polyline.pointCount; i++) {
+    CGPoint point = [self pointForMapPoint:_polyline.points[i]];
+    if (first) {
+      CGPathMoveToPoint(path, nil, point.x, point.y);
+      first = NO;
+    } else {
+      CGPathAddLineToPoint(path, nil, point.x, point.y);
+    }
+  }
+  self.path = path;
+}
+
+- (UIColor *)colorAtGradientPosition:(CGFloat)position {
+  if (!_strokeColors || _strokeColors.count == 0) {
+    return self.strokeColor;
+  }
+  if (_strokeColors.count == 1) {
+    return _strokeColors[0];
+  }
+
+  position = MAX(0, MIN(1, position));
+  CGFloat scaledPos = position * (_strokeColors.count - 1);
+  NSUInteger index = (NSUInteger)floor(scaledPos);
+  CGFloat t = scaledPos - index;
+
+  if (index >= _strokeColors.count - 1) {
+    return _strokeColors.lastObject;
+  }
+
+  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];
+
+  return [UIColor colorWithRed:r1 + (r2 - r1) * t
+                         green:g1 + (g2 - g1) * t
+                          blue:b1 + (b2 - b1) * t
+                         alpha:a1 + (a2 - a1) * t];
+}
+
+- (void)drawMapRect:(MKMapRect)mapRect
+          zoomScale:(MKZoomScale)zoomScale
+          inContext:(CGContextRef)context {
+  CGRect pointsRect = CGPathGetBoundingBox(self.path);
+  CGRect mapRectCG = [self rectForMapRect:mapRect];
+  if (!CGRectIntersectsRect(pointsRect, mapRectCG)) {
+    return;
+  }
+
+  CGFloat lineWidth = self.lineWidth / zoomScale;
+  CGContextSetLineWidth(context, lineWidth);
+  CGContextSetLineCap(context, self.lineCap);
+  CGContextSetLineJoin(context, self.lineJoin);
+
+  NSUInteger segmentCount = _polyline.pointCount - 1;
+  if (segmentCount == 0) {
+    return;
+  }
+
+  // Snake animation: grow from start, then shrink from start
+  if (_animated && _polyline.pointCount > 1) {
+    CGFloat progress = MIN(_animationProgress, 2.0);
+    CGFloat headPos, tailPos;
+
+    if (progress <= 1.0) {
+      // Phase 1: grow from start to end
+      tailPos = 0;
+      headPos = progress * segmentCount;
+    } else {
+      // Phase 2: shrink from start
+      CGFloat shrinkProgress = progress - 1.0;
+      tailPos = shrinkProgress * segmentCount;
+      headPos = segmentCount;
+    }
+
+    if (headPos <= tailPos) {
+      return;
+    }
+
+    NSUInteger startIndex = (NSUInteger)floor(tailPos);
+    NSUInteger endIndex = (NSUInteger)ceil(headPos);
+    CGFloat visibleLength = headPos - tailPos;
+
+    for (NSUInteger i = startIndex; i < endIndex && i < segmentCount; i++) {
+      CGPoint segStart = [self pointForMapPoint:_polyline.points[i]];
+      CGPoint segEnd = [self pointForMapPoint:_polyline.points[i + 1]];
+
+      CGPoint drawStart = segStart;
+      CGPoint drawEnd = segEnd;
+      CGFloat segStartPos = (CGFloat)i;
+      CGFloat segEndPos = (CGFloat)(i + 1);
+
+      // Interpolate tail (partial segment at start)
+      if (segStartPos < tailPos) {
+        CGFloat t = tailPos - segStartPos;
+        drawStart.x = segStart.x + (segEnd.x - segStart.x) * t;
+        drawStart.y = segStart.y + (segEnd.y - segStart.y) * t;
+        segStartPos = tailPos;
+      }
+
+      // Interpolate head (partial segment at end)
+      if (segEndPos > headPos) {
+        CGFloat t = headPos - (CGFloat)i;
+        drawEnd.x = segStart.x + (segEnd.x - segStart.x) * t;
+        drawEnd.y = segStart.y + (segEnd.y - segStart.y) * t;
+        segEndPos = headPos;
+      }
+
+      // Calculate gradient position (0-1) within visible portion
+      CGFloat gradientStart = (segStartPos - tailPos) / visibleLength;
+      CGFloat gradientEnd = (segEndPos - tailPos) / visibleLength;
+
+      UIColor *startColor = [self colorAtGradientPosition:gradientStart];
+      UIColor *endColor = [self colorAtGradientPosition:gradientEnd];
+
+      // Draw gradient line segment
+      CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+      NSArray *colors = @[(__bridge id)startColor.CGColor, (__bridge id)endColor.CGColor];
+      CGGradientRef gradient = CGGradientCreateWithColors(colorSpace, (__bridge CFArrayRef)colors, NULL);
+
+      CGContextSaveGState(context);
+      CGContextBeginPath(context);
+      CGContextMoveToPoint(context, drawStart.x, drawStart.y);
+      CGContextAddLineToPoint(context, drawEnd.x, drawEnd.y);
+      CGContextReplacePathWithStrokedPath(context);
+      CGContextClip(context);
+
+      CGContextDrawLinearGradient(context, gradient, drawStart, drawEnd, 0);
+
+      CGContextRestoreGState(context);
+      CGGradientRelease(gradient);
+      CGColorSpaceRelease(colorSpace);
+    }
+    return;
+  }
+
+  // Static gradient rendering
+  if (_strokeColors && _strokeColors.count > 1) {
+    for (NSUInteger i = 0; i < segmentCount; i++) {
+      CGPoint startPoint = [self pointForMapPoint:_polyline.points[i]];
+      CGPoint endPoint = [self pointForMapPoint:_polyline.points[i + 1]];
+
+      CGFloat gradientStart = (CGFloat)i / segmentCount;
+      CGFloat gradientEnd = (CGFloat)(i + 1) / segmentCount;
+
+      UIColor *startColor = [self colorAtGradientPosition:gradientStart];
+      UIColor *endColor = [self colorAtGradientPosition:gradientEnd];
+
+      CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+      NSArray *colors = @[(__bridge id)startColor.CGColor, (__bridge id)endColor.CGColor];
+      CGGradientRef gradient = CGGradientCreateWithColors(colorSpace, (__bridge CFArrayRef)colors, NULL);
+
+      CGContextSaveGState(context);
+      CGContextBeginPath(context);
+      CGContextMoveToPoint(context, startPoint.x, startPoint.y);
+      CGContextAddLineToPoint(context, endPoint.x, endPoint.y);
+      CGContextReplacePathWithStrokedPath(context);
+      CGContextClip(context);
+
+      CGContextDrawLinearGradient(context, gradient, startPoint, endPoint, 0);
+
+      CGContextRestoreGState(context);
+      CGGradientRelease(gradient);
+      CGColorSpaceRelease(colorSpace);
+    }
+    return;
+  }
+
+  // Single color
+  CGContextSetStrokeColorWithColor(context, self.strokeColor.CGColor);
+  CGContextAddPath(context, self.path);
+  CGContextStrokePath(context);
+}
+
+@end

package/ios/core/PolylineAnimatorBase.h

@@ -0,0 +1,22 @@
+#import <CoreLocation/CoreLocation.h>
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+@protocol PolylineAnimator <NSObject>
+
+@property(nonatomic, strong) NSArray<CLLocation *> *coordinates;
+@property(nonatomic, strong) NSArray<UIColor *> *strokeColors;
+@property(nonatomic, assign) BOOL animated;
+
+- (void)update;
+
+@end
+
+@interface PolylineAnimatorBase : NSObject
+
+@property(nonatomic, strong) NSArray<CLLocation *> *coordinates;
+@property(nonatomic, strong) NSArray<UIColor *> *strokeColors;
+
+- (UIColor *)colorAtGradientPosition:(CGFloat)position;
+
+@end

package/ios/core/PolylineAnimatorBase.m

@@ -0,0 +1,35 @@
+#import "PolylineAnimatorBase.h"
+
+@implementation PolylineAnimatorBase
+
+- (UIColor *)colorAtGradientPosition:(CGFloat)position {
+  if (!_strokeColors || _strokeColors.count == 0) {
+    return [UIColor blackColor];
+  }
+  if (_strokeColors.count == 1) {
+    return _strokeColors[0];
+  }
+
+  position = MAX(0, MIN(1, position));
+  CGFloat scaledPos = position * (_strokeColors.count - 1);
+  NSUInteger index = (NSUInteger)floor(scaledPos);
+  CGFloat t = scaledPos - index;
+
+  if (index >= _strokeColors.count - 1) {
+    return _strokeColors.lastObject;
+  }
+
+  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];
+
+  return [UIColor colorWithRed:r1 + (r2 - r1) * t
+                         green:g1 + (g2 - g1) * t
+                          blue:b1 + (b2 - b1) * t
+                         alpha:a1 + (a2 - a1) * t];
+}
+
+@end

package/ios/events/CameraIdleEvent.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#import <react/renderer/components/RNMapsSpec/EventEmitters.h>
+
+namespace luggmaps {
+namespace events {
+
+struct CameraIdleEvent {
+  double latitude;
+  double longitude;
+  double zoom;
+
+  template <typename Emitter>
+  void emit(std::shared_ptr<Emitter const> emitter) const {
+    typename Emitter::OnCameraIdle event;
+    event.coordinate.latitude = latitude;
+    event.coordinate.longitude = longitude;
+    event.zoom = zoom;
+    emitter->onCameraIdle(event);
+  }
+};
+
+} // namespace events
+} // namespace luggmaps

package/ios/events/CameraMoveEvent.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#import <react/renderer/components/RNMapsSpec/EventEmitters.h>
+
+namespace luggmaps {
+namespace events {
+
+struct CameraMoveEvent {
+  double latitude;
+  double longitude;
+  double zoom;
+  bool dragging;
+
+  template <typename Emitter>
+  void emit(std::shared_ptr<Emitter const> emitter) const {
+    typename Emitter::OnCameraMove event;
+    event.coordinate.latitude = latitude;
+    event.coordinate.longitude = longitude;
+    event.zoom = zoom;
+    event.dragging = dragging;
+    emitter->onCameraMove(event);
+  }
+};
+
+} // namespace events
+} // namespace luggmaps