@lugg/maps 1.0.0-beta.3 → 1.0.0-beta.5

package/ios/core/GoogleMapProvider.mm

@@ -1,8 +1,17 @@
 #import "GoogleMapProvider.h"
+
+using facebook::react::LuggMapViewInsetAdjustment;
+using facebook::react::LuggMapViewMapType;
+using facebook::react::LuggMapViewPoiFilterMode;
+using facebook::react::LuggMapViewTheme;
+
 #import "../LuggCalloutView.h"
+#import "../LuggCircleView.h"
+#import "../LuggGroundOverlayView.h"
 #import "../LuggMarkerView.h"
 #import "../LuggPolygonView.h"
 #import "../LuggPolylineView.h"
+#import "../LuggTileOverlayView.h"
 #import "GMSPolylineAnimator.h"
 #import "PolylineAnimatorBase.h"
 
@@ -10,7 +19,8 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 
 @interface GoogleMapProvider () <
     LuggMarkerViewDelegate, LuggCalloutViewDelegate, LuggPolylineViewDelegate,
-    LuggPolygonViewDelegate>
+    LuggPolygonViewDelegate, LuggCircleViewDelegate,
+    LuggGroundOverlayViewDelegate, LuggTileOverlayViewDelegate>
 @end
 
 @implementation GoogleMapProvider {
@@ -18,14 +28,20 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   GMSMapView *_mapView;
   BOOL _isMapReady;
   BOOL _isDragging;
-  NSInteger _theme;
+  LuggMapViewTheme _theme;
   UIEdgeInsets _edgeInsets;
   NSMutableArray<LuggMarkerView *> *_pendingMarkerViews;
   NSMutableArray<LuggPolylineView *> *_pendingPolylineViews;
   NSMutableArray<LuggPolygonView *> *_pendingPolygonViews;
+  NSMutableArray<LuggCircleView *> *_pendingCircleViews;
+  NSMutableArray<LuggGroundOverlayView *> *_pendingGroundOverlayViews;
+  NSMutableArray<LuggTileOverlayView *> *_pendingTileOverlayViews;
   NSMapTable<LuggPolylineView *, GMSPolylineAnimator *> *_polylineAnimators;
   NSMapTable<GMSPolygon *, LuggPolygonView *> *_polygonToViewMap;
+  NSMapTable<GMSCircle *, LuggCircleView *> *_circleToViewMap;
   NSMapTable<GMSMarker *, LuggMarkerView *> *_markerToViewMap;
+  NSMapTable<GMSGroundOverlay *, LuggGroundOverlayView *>
+      *_groundOverlayToViewMap;
   LuggMarkerView *_activeNonBubbledMarker;
 
   // Edge insets animation
@@ -45,9 +61,14 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
     _pendingMarkerViews = [NSMutableArray array];
     _pendingPolylineViews = [NSMutableArray array];
     _pendingPolygonViews = [NSMutableArray array];
+    _pendingCircleViews = [NSMutableArray array];
+    _pendingGroundOverlayViews = [NSMutableArray array];
+    _pendingTileOverlayViews = [NSMutableArray array];
     _polylineAnimators = [NSMapTable weakToStrongObjectsMapTable];
     _polygonToViewMap = [NSMapTable strongToWeakObjectsMapTable];
+    _circleToViewMap = [NSMapTable strongToWeakObjectsMapTable];
     _markerToViewMap = [NSMapTable strongToWeakObjectsMapTable];
+    _groundOverlayToViewMap = [NSMapTable strongToWeakObjectsMapTable];
   }
   return self;
 }
@@ -101,6 +122,9 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   [self processPendingMarkers];
   [self processPendingPolylines];
   [self processPendingPolygons];
+  [self processPendingCircles];
+  [self processPendingGroundOverlays];
+  [self processPendingTileOverlays];
 
   [_delegate mapProviderDidReady];
 }
@@ -110,9 +134,14 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   [_pendingMarkerViews removeAllObjects];
   [_pendingPolylineViews removeAllObjects];
   [_pendingPolygonViews removeAllObjects];
+  [_pendingCircleViews removeAllObjects];
+  [_pendingGroundOverlayViews removeAllObjects];
+  [_pendingTileOverlayViews removeAllObjects];
   [_polylineAnimators removeAllObjects];
   [_polygonToViewMap removeAllObjects];
+  [_circleToViewMap removeAllObjects];
   [_markerToViewMap removeAllObjects];
+  [_groundOverlayToViewMap removeAllObjects];
   [_mapView clear];
   [_mapView removeFromSuperview];
   _mapView = nil;
@@ -141,7 +170,43 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   _mapView.myLocationEnabled = enabled;
 }
 
-- (void)setTheme:(NSInteger)theme {
+- (void)setInsetAdjustment:(LuggMapViewInsetAdjustment)insetAdjustment {
+  _mapView.paddingAdjustmentBehavior =
+      (insetAdjustment == LuggMapViewInsetAdjustment::Automatic)
+          ? kGMSMapViewPaddingAdjustmentBehaviorAlways
+          : kGMSMapViewPaddingAdjustmentBehaviorNever;
+}
+
+- (void)setPoiEnabled:(BOOL)enabled {
+}
+
+- (void)setPoiFilterMode:(LuggMapViewPoiFilterMode)mode {
+}
+
+- (void)setPoiFilterCategories:(NSArray<NSString *> *)categories {
+}
+
+- (void)setMapType:(LuggMapViewMapType)mapType {
+  if (!_mapView)
+    return;
+
+  switch (mapType) {
+  case LuggMapViewMapType::Satellite:
+    _mapView.mapType = kGMSTypeSatellite;
+    break;
+  case LuggMapViewMapType::Terrain:
+    _mapView.mapType = kGMSTypeTerrain;
+    break;
+  case LuggMapViewMapType::Hybrid:
+    _mapView.mapType = kGMSTypeHybrid;
+    break;
+  default:
+    _mapView.mapType = kGMSTypeNormal;
+    break;
+  }
+}
+
+- (void)setTheme:(LuggMapViewTheme)theme {
   _theme = theme;
   [self applyTheme];
 }
@@ -151,13 +216,13 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
     return;
 
   switch (_theme) {
-  case 1: // Dark
+  case LuggMapViewTheme::Dark:
     _mapView.overrideUserInterfaceStyle = UIUserInterfaceStyleDark;
     break;
-  case 0: // Light
+  case LuggMapViewTheme::Light:
     _mapView.overrideUserInterfaceStyle = UIUserInterfaceStyleLight;
     break;
-  default: // System
+  default:
     _mapView.overrideUserInterfaceStyle = UIUserInterfaceStyleUnspecified;
     break;
   }
@@ -291,15 +356,26 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 }
 
 - (void)mapView:(GMSMapView *)mapView didTapOverlay:(GMSOverlay *)overlay {
-  if (![overlay isKindOfClass:[GMSPolygon class]])
-    return;
-
-  GMSPolygon *polygon = (GMSPolygon *)overlay;
-  LuggPolygonView *polygonView = [_polygonToViewMap objectForKey:polygon];
-  if (!polygonView || !polygonView.tappable)
-    return;
-
-  [polygonView emitPressEvent];
+  if ([overlay isKindOfClass:[GMSPolygon class]]) {
+    GMSPolygon *polygon = (GMSPolygon *)overlay;
+    LuggPolygonView *polygonView = [_polygonToViewMap objectForKey:polygon];
+    if (polygonView && polygonView.tappable) {
+      [polygonView emitPressEvent];
+    }
+  } else if ([overlay isKindOfClass:[GMSCircle class]]) {
+    GMSCircle *circle = (GMSCircle *)overlay;
+    LuggCircleView *circleView = [_circleToViewMap objectForKey:circle];
+    if (circleView && circleView.tappable) {
+      [circleView emitPressEvent];
+    }
+  } else if ([overlay isKindOfClass:[GMSGroundOverlay class]]) {
+    GMSGroundOverlay *groundOverlay = (GMSGroundOverlay *)overlay;
+    LuggGroundOverlayView *groundOverlayView =
+        [_groundOverlayToViewMap objectForKey:groundOverlay];
+    if (groundOverlayView && groundOverlayView.tappable) {
+      [groundOverlayView emitPressEvent];
+    }
+  }
 }
 
 - (BOOL)mapView:(GMSMapView *)mapView didTapMarker:(GMSMarker *)marker {
@@ -312,15 +388,21 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 
     LuggCalloutView *calloutView = markerView.calloutView;
     if (calloutView && calloutView.hasCustomContent) {
-      [mapView animateToLocation:marker.position];
-
-      dispatch_async(dispatch_get_main_queue(), ^{
-        if (calloutView.bubbled) {
-          mapView.selectedMarker = marker;
-        } else {
-          [self showNonBubbledCallout:markerView];
-        }
-      });
+      if (markerView.centerOnPress) {
+        [mapView animateToLocation:marker.position];
+      }
+
+      mapView.selectedMarker = marker;
+
+      if (!calloutView.bubbled) {
+        [self showNonBubbledCallout:markerView];
+      }
+
+      return YES;
+    }
+
+    if (!markerView.centerOnPress) {
+      mapView.selectedMarker = marker;
       return YES;
     }
   }
@@ -439,7 +521,7 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   if (contentSize.width <= 0 || contentSize.height <= 0)
     return;
 
-  CGPoint anchor = calloutView.anchor;
+  CGPoint offset = calloutView.offset;
   CGPoint point = [_mapView.projection
       pointForCoordinate:_activeNonBubbledMarker.coordinate];
 
@@ -448,9 +530,34 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
       iconView.bounds.size.height * _activeNonBubbledMarker.scale;
 
   contentView.center =
-      CGPointMake(point.x + contentSize.width * (0.5 - anchor.x),
-                  point.y - markerHeight * _activeNonBubbledMarker.anchor.y +
-                      contentSize.height * (0.5 - anchor.y));
+      CGPointMake(point.x + offset.x,
+                  point.y - markerHeight * _activeNonBubbledMarker.anchor.y -
+                      contentSize.height / 2.0 + offset.y);
+}
+
+- (void)showCalloutForMarkerView:(LuggMarkerView *)markerView {
+  LuggCalloutView *calloutView = markerView.calloutView;
+  if (calloutView && calloutView.hasCustomContent) {
+    [self dismissNonBubbledCallout];
+    GMSMarker *marker = (GMSMarker *)markerView.marker;
+    if (calloutView.bubbled) {
+      _mapView.selectedMarker = marker;
+    } else {
+      [self showNonBubbledCallout:markerView];
+    }
+    return;
+  }
+
+  if (markerView.title.length > 0) {
+    _mapView.selectedMarker = (GMSMarker *)markerView.marker;
+  }
+}
+
+- (void)hideCalloutForMarkerView:(LuggMarkerView *)markerView {
+  [self dismissNonBubbledCallout];
+  if (_mapView.selectedMarker == markerView.marker) {
+    _mapView.selectedMarker = nil;
+  }
 }
 
 #pragma mark - MarkerViewDelegate
@@ -475,6 +582,24 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   [self syncPolygonView:polygonView];
 }
 
+#pragma mark - CircleViewDelegate
+
+- (void)circleViewDidUpdate:(LuggCircleView *)circleView {
+  [self syncCircleView:circleView];
+}
+
+#pragma mark - GroundOverlayViewDelegate
+
+- (void)groundOverlayViewDidUpdate:(LuggGroundOverlayView *)groundOverlayView {
+  [self syncGroundOverlayView:groundOverlayView];
+}
+
+#pragma mark - TileOverlayViewDelegate
+
+- (void)tileOverlayViewDidUpdate:(LuggTileOverlayView *)tileOverlayView {
+  [self syncTileOverlayView:tileOverlayView];
+}
+
 #pragma mark - Marker Management
 
 - (void)addMarkerView:(LuggMarkerView *)markerView {
@@ -739,6 +864,243 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   [_polygonToViewMap setObject:polygonView forKey:polygon];
 }
 
+#pragma mark - Circle Management
+
+- (void)addCircleView:(LuggCircleView *)circleView {
+  circleView.delegate = self;
+  [self syncCircleView:circleView];
+}
+
+- (void)removeCircleView:(LuggCircleView *)circleView {
+  GMSCircle *circle = (GMSCircle *)circleView.circle;
+  if (circle) {
+    [_circleToViewMap removeObjectForKey:circle];
+    circle.map = nil;
+    circleView.circle = nil;
+  }
+}
+
+- (void)syncCircleView:(LuggCircleView *)circleView {
+  if (!_mapView) {
+    if (![_pendingCircleViews containsObject:circleView]) {
+      [_pendingCircleViews addObject:circleView];
+    }
+    return;
+  }
+
+  if (!circleView.circle) {
+    [self addCircleViewToMap:circleView];
+    return;
+  }
+
+  GMSCircle *circle = (GMSCircle *)circleView.circle;
+  circle.position = circleView.center;
+  circle.radius = circleView.radius;
+  circle.fillColor = circleView.fillColor;
+  circle.strokeColor = circleView.strokeColor;
+  circle.strokeWidth = circleView.strokeWidth;
+  circle.zIndex = (int)circleView.zIndex;
+  circle.tappable = circleView.tappable;
+}
+
+- (void)processPendingCircles {
+  if (!_mapView)
+    return;
+
+  for (LuggCircleView *circleView in _pendingCircleViews) {
+    [self addCircleViewToMap:circleView];
+  }
+  [_pendingCircleViews removeAllObjects];
+}
+
+- (void)addCircleViewToMap:(LuggCircleView *)circleView {
+  if (!_mapView)
+    return;
+
+  GMSCircle *circle = [GMSCircle circleWithPosition:circleView.center
+                                             radius:circleView.radius];
+  circle.fillColor = circleView.fillColor;
+  circle.strokeColor = circleView.strokeColor;
+  circle.strokeWidth = circleView.strokeWidth;
+  circle.zIndex = (int)circleView.zIndex;
+  circle.tappable = circleView.tappable;
+  circle.map = _mapView;
+  circleView.circle = circle;
+  [_circleToViewMap setObject:circleView forKey:circle];
+}
+
+#pragma mark - Ground Overlay Management
+
+- (void)addGroundOverlayView:(LuggGroundOverlayView *)groundOverlayView {
+  groundOverlayView.delegate = self;
+  [self syncGroundOverlayView:groundOverlayView];
+}
+
+- (void)removeGroundOverlayView:(LuggGroundOverlayView *)groundOverlayView {
+  groundOverlayView.delegate = nil;
+  GMSGroundOverlay *overlay = (GMSGroundOverlay *)groundOverlayView.overlay;
+  if (overlay) {
+    [_groundOverlayToViewMap removeObjectForKey:overlay];
+    overlay.map = nil;
+    groundOverlayView.overlay = nil;
+  }
+}
+
+- (void)syncGroundOverlayView:(LuggGroundOverlayView *)groundOverlayView {
+  if (!_mapView) {
+    if (![_pendingGroundOverlayViews containsObject:groundOverlayView]) {
+      [_pendingGroundOverlayViews addObject:groundOverlayView];
+    }
+    return;
+  }
+
+  NSString *imageUri = groundOverlayView.imageUri;
+  if (imageUri.length == 0)
+    return;
+
+  // Remove old overlay
+  GMSGroundOverlay *oldOverlay = (GMSGroundOverlay *)groundOverlayView.overlay;
+  if (oldOverlay) {
+    [_groundOverlayToViewMap removeObjectForKey:oldOverlay];
+    oldOverlay.map = nil;
+    groundOverlayView.overlay = nil;
+  }
+
+  // Load image and create overlay
+  NSURL *url = [NSURL URLWithString:imageUri];
+  if (!url)
+    return;
+
+  __weak __typeof(self) weakSelf = self;
+  __weak LuggGroundOverlayView *weakOverlayView = groundOverlayView;
+  dispatch_async(
+      dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        NSData *data = [NSData dataWithContentsOfURL:url];
+        UIImage *image = data ? [UIImage imageWithData:data] : nil;
+        dispatch_async(dispatch_get_main_queue(), ^{
+          [weakSelf addGroundOverlayToMap:weakOverlayView image:image];
+        });
+      });
+}
+
+- (void)addGroundOverlayToMap:(LuggGroundOverlayView *)groundOverlayView
+                        image:(UIImage *)image {
+  if (!_mapView || !groundOverlayView || !image)
+    return;
+
+  GMSCoordinateBounds *bounds = [[GMSCoordinateBounds alloc]
+      initWithCoordinate:groundOverlayView.southwest
+              coordinate:groundOverlayView.northeast];
+
+  GMSGroundOverlay *overlay = [GMSGroundOverlay groundOverlayWithBounds:bounds
+                                                                   icon:image];
+  overlay.opacity = groundOverlayView.opacity;
+  overlay.bearing = groundOverlayView.bearing;
+  overlay.zIndex = (int)groundOverlayView.zIndex;
+  overlay.tappable = groundOverlayView.tappable;
+  overlay.map = _mapView;
+
+  groundOverlayView.overlay = overlay;
+  [_groundOverlayToViewMap setObject:groundOverlayView forKey:overlay];
+}
+
+- (void)processPendingGroundOverlays {
+  if (!_mapView)
+    return;
+
+  for (LuggGroundOverlayView *view in _pendingGroundOverlayViews) {
+    [self syncGroundOverlayView:view];
+  }
+  [_pendingGroundOverlayViews removeAllObjects];
+}
+
+#pragma mark - Tile Overlay Management
+
+- (void)addTileOverlayView:(LuggTileOverlayView *)tileOverlayView {
+  tileOverlayView.delegate = self;
+  [self syncTileOverlayView:tileOverlayView];
+}
+
+- (void)removeTileOverlayView:(LuggTileOverlayView *)tileOverlayView {
+  tileOverlayView.delegate = nil;
+  GMSTileLayer *tileLayer = (GMSTileLayer *)tileOverlayView.overlay;
+  if (tileLayer) {
+    tileLayer.map = nil;
+    tileOverlayView.overlay = nil;
+  }
+}
+
+- (void)syncTileOverlayView:(LuggTileOverlayView *)tileOverlayView {
+  if (!_mapView) {
+    if (![_pendingTileOverlayViews containsObject:tileOverlayView]) {
+      [_pendingTileOverlayViews addObject:tileOverlayView];
+    }
+    return;
+  }
+
+  NSString *urlTemplate = tileOverlayView.urlTemplate;
+  if (urlTemplate.length == 0)
+    return;
+
+  // Remove old tile layer
+  GMSTileLayer *oldLayer = (GMSTileLayer *)tileOverlayView.overlay;
+  if (oldLayer) {
+    oldLayer.map = nil;
+    tileOverlayView.overlay = nil;
+  }
+
+  BOOL hasBounds = tileOverlayView.hasBounds;
+  CLLocationCoordinate2D sw = tileOverlayView.southwest;
+  CLLocationCoordinate2D ne = tileOverlayView.northeast;
+
+  GMSTileURLConstructor constructor = ^NSURL *(NSUInteger x, NSUInteger y,
+                                               NSUInteger zoom) {
+    if (hasBounds) {
+      double n = pow(2.0, zoom);
+      double tileSW_lat =
+          180.0 / M_PI * atan(sinh(M_PI * (1 - 2.0 * (y + 1) / n)));
+      double tileNE_lat = 180.0 / M_PI * atan(sinh(M_PI * (1 - 2.0 * y / n)));
+      double tileSW_lng = x / n * 360.0 - 180.0;
+      double tileNE_lng = (x + 1) / n * 360.0 - 180.0;
+
+      if (tileNE_lat < sw.latitude || tileSW_lat > ne.latitude ||
+          tileNE_lng < sw.longitude || tileSW_lng > ne.longitude) {
+        return nil;
+      }
+    }
+
+    NSString *urlString =
+        [urlTemplate stringByReplacingOccurrencesOfString:@"{x}"
+                                               withString:[@(x) stringValue]];
+    urlString =
+        [urlString stringByReplacingOccurrencesOfString:@"{y}"
+                                             withString:[@(y) stringValue]];
+    urlString =
+        [urlString stringByReplacingOccurrencesOfString:@"{z}"
+                                             withString:[@(zoom) stringValue]];
+    return [NSURL URLWithString:urlString];
+  };
+
+  GMSURLTileLayer *tileLayer =
+      [GMSURLTileLayer tileLayerWithURLConstructor:constructor];
+  tileLayer.tileSize = tileOverlayView.tileSize;
+  tileLayer.opacity = tileOverlayView.opacity;
+  tileLayer.zIndex = (int)tileOverlayView.zIndex;
+  tileLayer.map = _mapView;
+
+  tileOverlayView.overlay = tileLayer;
+}
+
+- (void)processPendingTileOverlays {
+  if (!_mapView)
+    return;
+
+  for (LuggTileOverlayView *view in _pendingTileOverlayViews) {
+    [self syncTileOverlayView:view];
+  }
+  [_pendingTileOverlayViews removeAllObjects];
+}
+
 #pragma mark - Lifecycle
 
 - (void)pauseAnimations {

package/ios/core/MapProviderDelegate.h

@@ -1,11 +1,15 @@
 #import <CoreLocation/CoreLocation.h>
 #import <UIKit/UIKit.h>
+#import <react/renderer/components/RNMapsSpec/Props.h>
 
 NS_ASSUME_NONNULL_BEGIN
 
 @class LuggMarkerView;
 @class LuggPolylineView;
 @class LuggPolygonView;
+@class LuggCircleView;
+@class LuggGroundOverlayView;
+@class LuggTileOverlayView;
 
 @protocol MapProviderDelegate <NSObject>
 - (void)mapProviderDidReady;
@@ -38,12 +42,15 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)destroy;
 
 // Props
+- (void)setInsetAdjustment:
+    (facebook::react::LuggMapViewInsetAdjustment)insetAdjustment;
 - (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)setMapType:(facebook::react::LuggMapViewMapType)mapType;
+- (void)setTheme:(facebook::react::LuggMapViewTheme)theme;
 - (void)setMinZoom:(double)minZoom;
 - (void)setMaxZoom:(double)maxZoom;
 - (void)setEdgeInsets:(UIEdgeInsets)edgeInsets
@@ -51,6 +58,9 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)setEdgeInsets:(UIEdgeInsets)edgeInsets
         oldEdgeInsets:(UIEdgeInsets)oldEdgeInsets
              duration:(double)duration;
+- (void)setPoiEnabled:(BOOL)enabled;
+- (void)setPoiFilterMode:(facebook::react::LuggMapViewPoiFilterMode)mode;
+- (void)setPoiFilterCategories:(NSArray<NSString *> *)categories;
 
 // Children
 - (void)addMarkerView:(LuggMarkerView *)markerView;
@@ -62,6 +72,15 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)addPolygonView:(LuggPolygonView *)polygonView;
 - (void)removePolygonView:(LuggPolygonView *)polygonView;
 - (void)syncPolygonView:(LuggPolygonView *)polygonView;
+- (void)addCircleView:(LuggCircleView *)circleView;
+- (void)removeCircleView:(LuggCircleView *)circleView;
+- (void)syncCircleView:(LuggCircleView *)circleView;
+- (void)addGroundOverlayView:(LuggGroundOverlayView *)groundOverlayView;
+- (void)removeGroundOverlayView:(LuggGroundOverlayView *)groundOverlayView;
+- (void)syncGroundOverlayView:(LuggGroundOverlayView *)groundOverlayView;
+- (void)addTileOverlayView:(LuggTileOverlayView *)tileOverlayView;
+- (void)removeTileOverlayView:(LuggTileOverlayView *)tileOverlayView;
+- (void)syncTileOverlayView:(LuggTileOverlayView *)tileOverlayView;
 
 // Lifecycle
 - (void)pauseAnimations;

package/ios/events/CirclePressEvent.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#import <react/renderer/components/RNMapsSpec/EventEmitters.h>
+
+namespace luggmaps {
+namespace events {
+
+struct CirclePressEvent {
+  template <typename Emitter>
+  static void emit(const facebook::react::SharedEventEmitter &eventEmitter) {
+    if (!eventEmitter)
+      return;
+    auto emitter = std::static_pointer_cast<Emitter const>(eventEmitter);
+    typename Emitter::OnCirclePress event;
+    emitter->onCirclePress(event);
+  }
+};
+
+} // namespace events
+} // namespace luggmaps

package/ios/events/GroundOverlayPressEvent.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#import <react/renderer/components/RNMapsSpec/EventEmitters.h>
+
+namespace luggmaps {
+namespace events {
+
+struct GroundOverlayPressEvent {
+  template <typename Emitter>
+  static void emit(const facebook::react::SharedEventEmitter &eventEmitter) {
+    if (!eventEmitter)
+      return;
+    auto emitter = std::static_pointer_cast<Emitter const>(eventEmitter);
+    typename Emitter::OnGroundOverlayPress event;
+    emitter->onGroundOverlayPress(event);
+  }
+};
+
+} // namespace events
+} // namespace luggmaps

package/ios/events/TileOverlayPressEvent.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#import <react/renderer/components/RNMapsSpec/EventEmitters.h>
+
+namespace luggmaps {
+namespace events {
+
+struct TileOverlayPressEvent {
+  template <typename Emitter>
+  static void emit(const facebook::react::SharedEventEmitter &eventEmitter) {
+    if (!eventEmitter)
+      return;
+    auto emitter = std::static_pointer_cast<Emitter const>(eventEmitter);
+    typename Emitter::OnTileOverlayPress event;
+    emitter->onTileOverlayPress(event);
+  }
+};
+
+} // namespace events
+} // namespace luggmaps

package/lib/module/MapView.js

@@ -8,11 +8,13 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 export class MapView extends React.Component {
   static defaultProps = {
     provider: Platform.OS === 'ios' ? 'apple' : 'google',
+    mapType: 'standard',
     initialZoom: 10,
     zoomEnabled: true,
     scrollEnabled: true,
     rotateEnabled: true,
     pitchEnabled: true,
+    poiEnabled: true,
     theme: 'system'
   };
   nativeRef = /*#__PURE__*/React.createRef();
@@ -66,6 +68,7 @@ export class MapView extends React.Component {
   render() {
     const {
       provider,
+      mapType,
       mapId,
       initialCoordinate,
       initialZoom,
@@ -78,7 +81,10 @@ export class MapView extends React.Component {
       edgeInsets,
       userLocationEnabled,
       userLocationButtonEnabled,
+      poiEnabled,
+      poiFilter,
       theme,
+      insetAdjustment,
       onPress,
       onLongPress,
       onCameraMove,
@@ -91,6 +97,7 @@ export class MapView extends React.Component {
       ref: this.nativeRef,
       ...rest,
       provider: provider,
+      mapType: mapType,
       mapId: mapId,
       initialCoordinate: initialCoordinate,
       initialZoom: initialZoom,
@@ -103,7 +110,11 @@ export class MapView extends React.Component {
       edgeInsets: edgeInsets,
       userLocationEnabled: userLocationEnabled,
       userLocationButtonEnabled: userLocationButtonEnabled,
+      poiEnabled: poiEnabled,
+      poiFilterMode: poiFilter?.mode,
+      poiFilterCategories: poiFilter?.categories,
       theme: theme,
+      insetAdjustment: insetAdjustment,
       onMapPress: onPress,
       onMapLongPress: onLongPress,
       onCameraMove: onCameraMove,