react-native-maps 1.28.2 → 1.29.0

package/ios/AirMaps/RNMapsPolygonView.mm

@@ -0,0 +1,240 @@
+//
+//  RNMapsPolygonView.mm
+//  AirMaps
+//
+//
+//  Copyright © 2024 react-native-maps. All rights reserved.
+//
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import "RNMapsPolygonView.h"
+#import "AIRMapPolygon.h"
+#import "AIRMapCoordinate.h"
+#if __has_include(<ReactNativeMaps/generated/RNMapsAirModuleDelegate.h>)
+#import <ReactNativeMaps/generated/RNMapsHostViewDelegate.h>
+#import <ReactNativeMaps/generated/ComponentDescriptors.h>
+#import <ReactNativeMaps/generated/EventEmitters.h>
+#import <ReactNativeMaps/generated/Props.h>
+#import <ReactNativeMaps/generated/RCTComponentViewHelpers.h>
+#else
+#import "../generated/RNMapsHostViewDelegate.h"
+#import "../generated/RNMapsSpecs/ComponentDescriptors.h"
+#import "../generated/RNMapsSpecs/EventEmitters.h"
+#import "../generated/RNMapsSpecs/Props.h"
+#import "../generated/RNMapsSpecs/RCTComponentViewHelpers.h"
+#endif
+#import "RCTFabricComponentsPlugins.h"
+#import <React/RCTConversions.h>
+#import "UIView+AirMap.h"
+
+using namespace facebook::react;
+
+static BOOL coordinatesEqual(const std::vector<RNMapsPolygonCoordinatesStruct>& a,
+                             const std::vector<RNMapsPolygonCoordinatesStruct>& b)
+{
+    if (a.size() != b.size()) {
+        return NO;
+    }
+    for (size_t i = 0; i < a.size(); ++i) {
+        if (a.at(i).latitude != b.at(i).latitude ||
+            a.at(i).longitude != b.at(i).longitude) {
+            return NO;
+        }
+    }
+    return YES;
+}
+
+static BOOL holesEqual(const std::vector<std::vector<RNMapsPolygonHolesStruct>>& a,
+                       const std::vector<std::vector<RNMapsPolygonHolesStruct>>& b)
+{
+    if (a.size() != b.size()) {
+        return NO;
+    }
+    for (size_t h = 0; h < a.size(); ++h) {
+        if (a.at(h).size() != b.at(h).size()) {
+            return NO;
+        }
+        for (size_t i = 0; i < a.at(h).size(); ++i) {
+            if (a.at(h).at(i).latitude != b.at(h).at(i).latitude ||
+                a.at(h).at(i).longitude != b.at(h).at(i).longitude) {
+                return NO;
+            }
+        }
+    }
+    return YES;
+}
+
+@interface RNMapsPolygonView () <RCTRNMapsPolygonViewProtocol>
+@end
+
+@implementation RNMapsPolygonView {
+    AIRMapPolygon *_view;
+}
+
+- (AIRMapPolygon *)polygon {
+    return _view;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+    return concreteComponentDescriptorProvider<RNMapsPolygonComponentDescriptor>();
+}
+
+- (void)prepareContentView
+{
+    _view = [AIRMapPolygon new];
+    _view.strokeWidth = 1.0;
+    _view.lineCap = kCGLineCapRound;
+    _view.lineJoin = kCGLineJoinRound;
+    _view.miterLimit = 10.0;
+    _view.onPress = [self](NSDictionary *dictionary) {
+        if (!_eventEmitter) return;
+        NSDictionary *coordinateDict = dictionary[@"coordinate"];
+        CLLocationCoordinate2D coord = CLLocationCoordinate2DMake(
+            [coordinateDict[@"latitude"] doubleValue],
+            [coordinateDict[@"longitude"] doubleValue]);
+        facebook::react::RNMapsPolygonEventEmitter::OnPressCoordinate coordinate = {
+            .latitude = coord.latitude,
+            .longitude = coord.longitude,
+        };
+
+        CGPoint screenPoint =
+            _view.map ? [_view.map convertCoordinate:coord toPointToView:_view.map] : CGPointZero;
+        facebook::react::RNMapsPolygonEventEmitter::OnPressPosition position = {
+            .x = screenPoint.x,
+            .y = screenPoint.y,
+        };
+        auto eventEmitter = std::static_pointer_cast<RNMapsPolygonEventEmitter const>(_eventEmitter);
+        facebook::react::RNMapsPolygonEventEmitter::OnPress data = {
+            .action = std::string([dictionary[@"action"] UTF8String]),
+            .coordinate = coordinate,
+            .position = position,
+        };
+        eventEmitter->onPress(data);
+    };
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+    if (self = [super initWithFrame:frame]) {
+        static const auto defaultProps = std::make_shared<const RNMapsPolygonProps>();
+        _props = defaultProps;
+        [self prepareContentView];
+    }
+    return self;
+}
+
+- (void)prepareForRecycle
+{
+    [super prepareForRecycle];
+    static const auto defaultProps = std::make_shared<const RNMapsPolygonProps>();
+    _props = defaultProps;
+    _view = nil;
+}
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
+{
+    const auto &oldViewProps = *std::static_pointer_cast<RNMapsPolygonProps const>(_props);
+    const auto &newViewProps = *std::static_pointer_cast<RNMapsPolygonProps const>(props);
+
+    if (!_view) {
+        [self prepareContentView];
+    }
+
+    // Order matters: `AIRMapPolygon setCoordinates:` builds the `MKPolygon` from the
+    // current `interiorPolygons` (holes), while `setHoles:` only updates that array
+    // without rebuilding. So apply holes first, then (re)build coordinates whenever
+    // either holes or coordinates changed.
+    const BOOL holesChanged = !holesEqual(newViewProps.holes, oldViewProps.holes);
+    const BOOL coordinatesChanged =
+        !coordinatesEqual(newViewProps.coordinates, oldViewProps.coordinates);
+
+    if (holesChanged) {
+        if (newViewProps.holes.empty()) {
+            // `setHoles:` ignores an empty array (its `if (holes.count)` guard), so
+            // clear the interior polygons directly to support removing holes.
+            _view.interiorPolygons = nil;
+        } else {
+            NSMutableArray<NSArray<AIRMapCoordinate *> *> *holes =
+                [NSMutableArray arrayWithCapacity:newViewProps.holes.size()];
+            for (const auto &hole : newViewProps.holes) {
+                NSMutableArray<AIRMapCoordinate *> *holeCoordinates =
+                    [NSMutableArray arrayWithCapacity:hole.size()];
+                for (const auto &c : hole) {
+                    AIRMapCoordinate *coordinate = [AIRMapCoordinate new];
+                    coordinate.coordinate = CLLocationCoordinate2DMake(c.latitude, c.longitude);
+                    [holeCoordinates addObject:coordinate];
+                }
+                [holes addObject:holeCoordinates];
+            }
+            _view.holes = holes;
+        }
+    }
+
+    if (coordinatesChanged || holesChanged) {
+        NSMutableArray<AIRMapCoordinate *> *coordinates =
+            [NSMutableArray arrayWithCapacity:newViewProps.coordinates.size()];
+        for (const auto &c : newViewProps.coordinates) {
+            AIRMapCoordinate *coordinate = [AIRMapCoordinate new];
+            coordinate.coordinate = CLLocationCoordinate2DMake(c.latitude, c.longitude);
+            [coordinates addObject:coordinate];
+        }
+        _view.coordinates = coordinates;
+    }
+
+    if (newViewProps.fillColor != oldViewProps.fillColor) {
+        _view.fillColor = newViewProps.fillColor
+            ? RCTUIColorFromSharedColor(newViewProps.fillColor)
+            : nil;
+    }
+    if (newViewProps.strokeColor != oldViewProps.strokeColor) {
+        _view.strokeColor = newViewProps.strokeColor
+            ? RCTUIColorFromSharedColor(newViewProps.strokeColor)
+            : nil;
+    }
+    if (newViewProps.strokeWidth != oldViewProps.strokeWidth) {
+        _view.strokeWidth = newViewProps.strokeWidth;
+    }
+    if (newViewProps.miterLimit != oldViewProps.miterLimit) {
+        _view.miterLimit = newViewProps.miterLimit;
+    }
+    if (newViewProps.lineDashPhase != oldViewProps.lineDashPhase) {
+        _view.lineDashPhase = newViewProps.lineDashPhase;
+    }
+
+    if (newViewProps.lineCap != oldViewProps.lineCap) {
+        switch (newViewProps.lineCap) {
+            case RNMapsPolygonLineCap::Butt: _view.lineCap = kCGLineCapButt; break;
+            case RNMapsPolygonLineCap::Round: _view.lineCap = kCGLineCapRound; break;
+            case RNMapsPolygonLineCap::Square: _view.lineCap = kCGLineCapSquare; break;
+        }
+    }
+
+    if (newViewProps.lineJoin != oldViewProps.lineJoin) {
+        switch (newViewProps.lineJoin) {
+            case RNMapsPolygonLineJoin::Miter: _view.lineJoin = kCGLineJoinMiter; break;
+            case RNMapsPolygonLineJoin::Round: _view.lineJoin = kCGLineJoinRound; break;
+            case RNMapsPolygonLineJoin::Bevel: _view.lineJoin = kCGLineJoinBevel; break;
+        }
+    }
+
+    if (newViewProps.lineDashPattern != oldViewProps.lineDashPattern) {
+        NSMutableArray<NSNumber *> *pattern =
+            [NSMutableArray arrayWithCapacity:newViewProps.lineDashPattern.size()];
+        for (const auto &value : newViewProps.lineDashPattern) {
+            [pattern addObject:@(value)];
+        }
+        _view.lineDashPattern = pattern;
+    }
+
+    [super updateProps:props oldProps:oldProps];
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RNMapsPolygonCls(void)
+{
+    return RNMapsPolygonView.class;
+}
+
+#endif

package/ios/generated/RCTThirdPartyComponentsProvider.mm

@@ -22,8 +22,10 @@
     thirdPartyComponents = @{
 		@"RNMapsGoogleMapView": NSClassFromString(@"RNMapsGoogleMapView"), // react-native-maps
 		@"RNMapsGooglePolygon": NSClassFromString(@"RNMapsGooglePolygonView"), // react-native-maps
+		@"RNMapsGoogleMarker": NSClassFromString(@"RNMapsGoogleMarkerView"), // react-native-maps
 		@"RNMapsMapView": NSClassFromString(@"RNMapsMapView"), // react-native-maps
 		@"RNMapsMarker": NSClassFromString(@"RNMapsMarkerView"), // react-native-maps
+		@"RNMapsPolygon": NSClassFromString(@"RNMapsPolygonView"), // react-native-maps
     };
   });
 

package/ios/generated/RNMapsSpecs/ComponentDescriptors.cpp

@@ -19,10 +19,12 @@ void RNMapsSpecs_registerComponentDescriptorsFromCodegen(
 registry->add(concreteComponentDescriptorProvider<RNMapsCalloutComponentDescriptor>());
 registry->add(concreteComponentDescriptorProvider<RNMapsCircleComponentDescriptor>());
 registry->add(concreteComponentDescriptorProvider<RNMapsGoogleMapViewComponentDescriptor>());
+registry->add(concreteComponentDescriptorProvider<RNMapsGoogleMarkerComponentDescriptor>());
 registry->add(concreteComponentDescriptorProvider<RNMapsGooglePolygonComponentDescriptor>());
 registry->add(concreteComponentDescriptorProvider<RNMapsMapViewComponentDescriptor>());
 registry->add(concreteComponentDescriptorProvider<RNMapsMarkerComponentDescriptor>());
 registry->add(concreteComponentDescriptorProvider<RNMapsOverlayComponentDescriptor>());
+registry->add(concreteComponentDescriptorProvider<RNMapsPolygonComponentDescriptor>());
 registry->add(concreteComponentDescriptorProvider<RNMapsPolylineComponentDescriptor>());
 registry->add(concreteComponentDescriptorProvider<RNMapsUrlTileComponentDescriptor>());
 registry->add(concreteComponentDescriptorProvider<RNMapsWMSTileComponentDescriptor>());

package/ios/generated/RNMapsSpecs/ComponentDescriptors.h

@@ -19,10 +19,12 @@ namespace facebook::react {
 using RNMapsCalloutComponentDescriptor = ConcreteComponentDescriptor<RNMapsCalloutShadowNode>;
 using RNMapsCircleComponentDescriptor = ConcreteComponentDescriptor<RNMapsCircleShadowNode>;
 using RNMapsGoogleMapViewComponentDescriptor = ConcreteComponentDescriptor<RNMapsGoogleMapViewShadowNode>;
+using RNMapsGoogleMarkerComponentDescriptor = ConcreteComponentDescriptor<RNMapsGoogleMarkerShadowNode>;
 using RNMapsGooglePolygonComponentDescriptor = ConcreteComponentDescriptor<RNMapsGooglePolygonShadowNode>;
 using RNMapsMapViewComponentDescriptor = ConcreteComponentDescriptor<RNMapsMapViewShadowNode>;
 using RNMapsMarkerComponentDescriptor = ConcreteComponentDescriptor<RNMapsMarkerShadowNode>;
 using RNMapsOverlayComponentDescriptor = ConcreteComponentDescriptor<RNMapsOverlayShadowNode>;
+using RNMapsPolygonComponentDescriptor = ConcreteComponentDescriptor<RNMapsPolygonShadowNode>;
 using RNMapsPolylineComponentDescriptor = ConcreteComponentDescriptor<RNMapsPolylineShadowNode>;
 using RNMapsUrlTileComponentDescriptor = ConcreteComponentDescriptor<RNMapsUrlTileShadowNode>;
 using RNMapsWMSTileComponentDescriptor = ConcreteComponentDescriptor<RNMapsWMSTileShadowNode>;

package/ios/generated/RNMapsSpecs/EventEmitters.cpp

@@ -384,6 +384,159 @@ void RNMapsGoogleMapViewEventEmitter::onUserLocationChange(OnUserLocationChange
 }
 
 
+void RNMapsGoogleMarkerEventEmitter::onCalloutPress(OnCalloutPress event) const {
+  dispatchEvent("calloutPress", [event=std::move(event)](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    payload.setProperty(runtime, "action", event.action);
+payload.setProperty(runtime, "id", event.id);
+{
+  auto frame = jsi::Object(runtime);
+  frame.setProperty(runtime, "x", event.frame.x);
+  frame.setProperty(runtime, "y", event.frame.y);
+  frame.setProperty(runtime, "width", event.frame.width);
+  frame.setProperty(runtime, "height", event.frame.height);
+  payload.setProperty(runtime, "frame", frame);
+}
+{
+  auto point = jsi::Object(runtime);
+  point.setProperty(runtime, "x", event.point.x);
+  point.setProperty(runtime, "y", event.point.y);
+  payload.setProperty(runtime, "point", point);
+}
+    return payload;
+  });
+}
+
+
+void RNMapsGoogleMarkerEventEmitter::onDrag(OnDrag event) const {
+  dispatchEvent("drag", [event=std::move(event)](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    payload.setProperty(runtime, "id", event.id);
+{
+  auto coordinate = jsi::Object(runtime);
+  coordinate.setProperty(runtime, "latitude", event.coordinate.latitude);
+  coordinate.setProperty(runtime, "longitude", event.coordinate.longitude);
+  payload.setProperty(runtime, "coordinate", coordinate);
+}
+{
+  auto position = jsi::Object(runtime);
+  position.setProperty(runtime, "x", event.position.x);
+  position.setProperty(runtime, "y", event.position.y);
+  payload.setProperty(runtime, "position", position);
+}
+    return payload;
+  });
+}
+
+
+void RNMapsGoogleMarkerEventEmitter::onDragEnd(OnDragEnd event) const {
+  dispatchEvent("dragEnd", [event=std::move(event)](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    payload.setProperty(runtime, "id", event.id);
+{
+  auto coordinate = jsi::Object(runtime);
+  coordinate.setProperty(runtime, "latitude", event.coordinate.latitude);
+  coordinate.setProperty(runtime, "longitude", event.coordinate.longitude);
+  payload.setProperty(runtime, "coordinate", coordinate);
+}
+{
+  auto position = jsi::Object(runtime);
+  position.setProperty(runtime, "x", event.position.x);
+  position.setProperty(runtime, "y", event.position.y);
+  payload.setProperty(runtime, "position", position);
+}
+    return payload;
+  });
+}
+
+
+void RNMapsGoogleMarkerEventEmitter::onDragStart(OnDragStart event) const {
+  dispatchEvent("dragStart", [event=std::move(event)](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    payload.setProperty(runtime, "id", event.id);
+{
+  auto coordinate = jsi::Object(runtime);
+  coordinate.setProperty(runtime, "latitude", event.coordinate.latitude);
+  coordinate.setProperty(runtime, "longitude", event.coordinate.longitude);
+  payload.setProperty(runtime, "coordinate", coordinate);
+}
+{
+  auto position = jsi::Object(runtime);
+  position.setProperty(runtime, "x", event.position.x);
+  position.setProperty(runtime, "y", event.position.y);
+  payload.setProperty(runtime, "position", position);
+}
+    return payload;
+  });
+}
+
+
+void RNMapsGoogleMarkerEventEmitter::onPress(OnPress event) const {
+  dispatchEvent("press", [event=std::move(event)](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    payload.setProperty(runtime, "action", event.action);
+payload.setProperty(runtime, "id", event.id);
+{
+  auto coordinate = jsi::Object(runtime);
+  coordinate.setProperty(runtime, "latitude", event.coordinate.latitude);
+  coordinate.setProperty(runtime, "longitude", event.coordinate.longitude);
+  payload.setProperty(runtime, "coordinate", coordinate);
+}
+{
+  auto position = jsi::Object(runtime);
+  position.setProperty(runtime, "x", event.position.x);
+  position.setProperty(runtime, "y", event.position.y);
+  payload.setProperty(runtime, "position", position);
+}
+    return payload;
+  });
+}
+
+
+void RNMapsGoogleMarkerEventEmitter::onSelect(OnSelect event) const {
+  dispatchEvent("select", [event=std::move(event)](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    payload.setProperty(runtime, "action", event.action);
+payload.setProperty(runtime, "id", event.id);
+{
+  auto coordinate = jsi::Object(runtime);
+  coordinate.setProperty(runtime, "latitude", event.coordinate.latitude);
+  coordinate.setProperty(runtime, "longitude", event.coordinate.longitude);
+  payload.setProperty(runtime, "coordinate", coordinate);
+}
+{
+  auto position = jsi::Object(runtime);
+  position.setProperty(runtime, "x", event.position.x);
+  position.setProperty(runtime, "y", event.position.y);
+  payload.setProperty(runtime, "position", position);
+}
+    return payload;
+  });
+}
+
+
+void RNMapsGoogleMarkerEventEmitter::onDeselect(OnDeselect event) const {
+  dispatchEvent("deselect", [event=std::move(event)](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    payload.setProperty(runtime, "action", event.action);
+payload.setProperty(runtime, "id", event.id);
+{
+  auto coordinate = jsi::Object(runtime);
+  coordinate.setProperty(runtime, "latitude", event.coordinate.latitude);
+  coordinate.setProperty(runtime, "longitude", event.coordinate.longitude);
+  payload.setProperty(runtime, "coordinate", coordinate);
+}
+{
+  auto position = jsi::Object(runtime);
+  position.setProperty(runtime, "x", event.position.x);
+  position.setProperty(runtime, "y", event.position.y);
+  payload.setProperty(runtime, "position", position);
+}
+    return payload;
+  });
+}
+
+
 void RNMapsGooglePolygonEventEmitter::onPress(OnPress event) const {
   dispatchEvent("press", [event=std::move(event)](jsi::Runtime &runtime) {
     auto payload = jsi::Object(runtime);
@@ -953,6 +1106,28 @@ payload.setProperty(runtime, "id", event.id);
 }
 
 
+void RNMapsPolygonEventEmitter::onPress(OnPress event) const {
+  dispatchEvent("press", [event=std::move(event)](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    payload.setProperty(runtime, "action", event.action);
+payload.setProperty(runtime, "id", event.id);
+{
+  auto coordinate = jsi::Object(runtime);
+  coordinate.setProperty(runtime, "latitude", event.coordinate.latitude);
+  coordinate.setProperty(runtime, "longitude", event.coordinate.longitude);
+  payload.setProperty(runtime, "coordinate", coordinate);
+}
+{
+  auto position = jsi::Object(runtime);
+  position.setProperty(runtime, "x", event.position.x);
+  position.setProperty(runtime, "y", event.position.y);
+  payload.setProperty(runtime, "position", position);
+}
+    return payload;
+  });
+}
+
+
 void RNMapsPolylineEventEmitter::onPress(OnPress event) const {
   dispatchEvent("press", [event=std::move(event)](jsi::Runtime &runtime) {
     auto payload = jsi::Object(runtime);

package/ios/generated/RNMapsSpecs/EventEmitters.h

@@ -330,6 +330,141 @@ class RNMapsGoogleMapViewEventEmitter : public ViewEventEmitter {
 
   void onUserLocationChange(OnUserLocationChange value) const;
 };
+class RNMapsGoogleMarkerEventEmitter : public ViewEventEmitter {
+ public:
+  using ViewEventEmitter::ViewEventEmitter;
+
+  struct OnCalloutPressFrame {
+      double x;
+    double y;
+    double width;
+    double height;
+    };
+
+  struct OnCalloutPressPoint {
+      double x;
+    double y;
+    };
+
+  struct OnCalloutPress {
+      std::string action;
+    std::string id;
+    OnCalloutPressFrame frame;
+    OnCalloutPressPoint point;
+    };
+
+  struct OnDragCoordinate {
+      double latitude;
+    double longitude;
+    };
+
+  struct OnDragPosition {
+      double x;
+    double y;
+    };
+
+  struct OnDrag {
+      std::string id;
+    OnDragCoordinate coordinate;
+    OnDragPosition position;
+    };
+
+  struct OnDragEndCoordinate {
+      double latitude;
+    double longitude;
+    };
+
+  struct OnDragEndPosition {
+      double x;
+    double y;
+    };
+
+  struct OnDragEnd {
+      std::string id;
+    OnDragEndCoordinate coordinate;
+    OnDragEndPosition position;
+    };
+
+  struct OnDragStartCoordinate {
+      double latitude;
+    double longitude;
+    };
+
+  struct OnDragStartPosition {
+      double x;
+    double y;
+    };
+
+  struct OnDragStart {
+      std::string id;
+    OnDragStartCoordinate coordinate;
+    OnDragStartPosition position;
+    };
+
+  struct OnPressCoordinate {
+      double latitude;
+    double longitude;
+    };
+
+  struct OnPressPosition {
+      double x;
+    double y;
+    };
+
+  struct OnPress {
+      std::string action;
+    std::string id;
+    OnPressCoordinate coordinate;
+    OnPressPosition position;
+    };
+
+  struct OnSelectCoordinate {
+      double latitude;
+    double longitude;
+    };
+
+  struct OnSelectPosition {
+      double x;
+    double y;
+    };
+
+  struct OnSelect {
+      std::string action;
+    std::string id;
+    OnSelectCoordinate coordinate;
+    OnSelectPosition position;
+    };
+
+  struct OnDeselectCoordinate {
+      double latitude;
+    double longitude;
+    };
+
+  struct OnDeselectPosition {
+      double x;
+    double y;
+    };
+
+  struct OnDeselect {
+      std::string action;
+    std::string id;
+    OnDeselectCoordinate coordinate;
+    OnDeselectPosition position;
+    };
+  void onCalloutPress(OnCalloutPress value) const;
+
+  void onDrag(OnDrag value) const;
+
+  void onDragEnd(OnDragEnd value) const;
+
+  void onDragStart(OnDragStart value) const;
+
+  void onPress(OnPress value) const;
+
+  void onSelect(OnSelect value) const;
+
+  void onDeselect(OnDeselect value) const;
+};
 class RNMapsGooglePolygonEventEmitter : public ViewEventEmitter {
  public:
   using ViewEventEmitter::ViewEventEmitter;
@@ -821,6 +956,28 @@ class RNMapsOverlayEventEmitter : public ViewEventEmitter {
     };
   void onPress(OnPress value) const;
 };
+class RNMapsPolygonEventEmitter : public ViewEventEmitter {
+ public:
+  using ViewEventEmitter::ViewEventEmitter;
+
+  struct OnPressCoordinate {
+      double latitude;
+    double longitude;
+    };
+
+  struct OnPressPosition {
+      double x;
+    double y;
+    };
+
+  struct OnPress {
+      std::string action;
+    std::string id;
+    OnPressCoordinate coordinate;
+    OnPressPosition position;
+    };
+  void onPress(OnPress value) const;
+};
 class RNMapsPolylineEventEmitter : public ViewEventEmitter {
  public:
   using ViewEventEmitter::ViewEventEmitter;