@lugg/maps 1.0.0-beta.2 → 1.0.0-beta.20

package/ios/LuggMapView.mm

@@ -1,10 +1,15 @@
 #import "LuggMapView.h"
+#import "LuggCircleView.h"
+#import "LuggGroundOverlayView.h"
 #import "LuggMapWrapperView.h"
 #import "LuggMarkerView.h"
 #import "LuggPolygonView.h"
 #import "LuggPolylineView.h"
+#import "LuggTileOverlayView.h"
 #import "core/AppleMapProvider.h"
+#import "core/AppleStaticMapProvider.h"
 #import "core/GoogleMapProvider.h"
+#import "core/GoogleStaticMapProvider.h"
 #import "core/MapProviderDelegate.h"
 #import "events/CameraIdleEvent.h"
 #import "events/CameraMoveEvent.h"
@@ -22,6 +27,19 @@
 using namespace facebook::react;
 using namespace luggmaps::events;
 
+// Static snapshots cached across view recycling, keyed by the user-provided
+// staticKey plus the map settings that affect appearance.
+static NSCache<NSString *, UIImage *> *StaticSnapshotCache(void) {
+  static NSCache<NSString *, UIImage *> *cache;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    cache = [[NSCache alloc] init];
+    cache.countLimit = 100;
+    cache.totalCostLimit = 64 * 1024 * 1024; // bytes
+  });
+  return cache;
+}
+
 @interface LuggMapView () <RCTLuggMapViewViewProtocol, MapProviderDelegate>
 @end
 
@@ -36,12 +54,21 @@ using namespace luggmaps::events;
   BOOL _scrollEnabled;
   BOOL _rotateEnabled;
   BOOL _pitchEnabled;
+  BOOL _compassEnabled;
+  BOOL _staticMode;
+  NSString *_staticKey;
+  BOOL _staticSnapshotDone;
   BOOL _userLocationEnabled;
+  LuggMapViewMapType _mapType;
   LuggMapViewTheme _theme;
+  BOOL _poiEnabled;
+  LuggMapViewPoiFilterMode _poiFilterMode;
+  NSArray<NSString *> *_poiFilterCategories;
   double _minZoom;
   double _maxZoom;
   UIEdgeInsets _edgeInsets;
   UIEdgeInsets _oldEdgeInsets;
+  LuggMapViewInsetAdjustment _insetAdjustment;
 }
 
 + (ComponentDescriptorProvider)componentDescriptorProvider {
@@ -60,9 +87,17 @@ using namespace luggmaps::events;
     _scrollEnabled = YES;
     _rotateEnabled = YES;
     _pitchEnabled = YES;
+    _compassEnabled = YES;
+    _staticMode = NO;
+    _staticKey = @"";
     _userLocationEnabled = NO;
+    _poiEnabled = NO;
+    _poiFilterMode = LuggMapViewPoiFilterMode::Including;
+    _poiFilterCategories = @[];
+    _mapType = LuggMapViewMapType::Standard;
     _theme = LuggMapViewTheme::System;
     _edgeInsets = UIEdgeInsetsZero;
+    _insetAdjustment = LuggMapViewInsetAdjustment::Never;
   }
   return self;
 }
@@ -91,6 +126,23 @@ using namespace luggmaps::events;
     if (_provider) {
       [_provider addPolygonView:polygonView];
     }
+  } else if ([childComponentView isKindOfClass:[LuggCircleView class]]) {
+    LuggCircleView *circleView = (LuggCircleView *)childComponentView;
+    if (_provider) {
+      [_provider addCircleView:circleView];
+    }
+  } else if ([childComponentView isKindOfClass:[LuggGroundOverlayView class]]) {
+    LuggGroundOverlayView *groundOverlayView =
+        (LuggGroundOverlayView *)childComponentView;
+    if (_provider) {
+      [_provider addGroundOverlayView:groundOverlayView];
+    }
+  } else if ([childComponentView isKindOfClass:[LuggTileOverlayView class]]) {
+    LuggTileOverlayView *tileOverlayView =
+        (LuggTileOverlayView *)childComponentView;
+    if (_provider) {
+      [_provider addTileOverlayView:tileOverlayView];
+    }
   }
 }
 
@@ -112,6 +164,23 @@ using namespace luggmaps::events;
     if (_provider) {
       [_provider removePolygonView:polygonView];
     }
+  } else if ([childComponentView isKindOfClass:[LuggCircleView class]]) {
+    LuggCircleView *circleView = (LuggCircleView *)childComponentView;
+    if (_provider) {
+      [_provider removeCircleView:circleView];
+    }
+  } else if ([childComponentView isKindOfClass:[LuggGroundOverlayView class]]) {
+    LuggGroundOverlayView *groundOverlayView =
+        (LuggGroundOverlayView *)childComponentView;
+    if (_provider) {
+      [_provider removeGroundOverlayView:groundOverlayView];
+    }
+  } else if ([childComponentView isKindOfClass:[LuggTileOverlayView class]]) {
+    LuggTileOverlayView *tileOverlayView =
+        (LuggTileOverlayView *)childComponentView;
+    if (_provider) {
+      [_provider removeTileOverlayView:tileOverlayView];
+    }
   }
 
   [super unmountChildComponentView:childComponentView index:index];
@@ -121,17 +190,118 @@ using namespace luggmaps::events;
   [super didMoveToWindow];
   if (self.window) {
     if (!_provider && _mapWrapperView) {
-      [self initializeProvider];
+      if (_staticMode) {
+        [self startStaticContent];
+      } else {
+        [self initializeProvider];
+      }
     }
     [_provider resumeAnimations];
   } else {
+    // A static map mid-warmup may hold an expensive live map view. Destroy
+    // it off-window and re-render on return instead of letting paused maps
+    // pile up across screen switches and all resume at once
+    if (_staticMode && _provider && !_staticSnapshotDone) {
+      [_provider destroy];
+      _provider = nil;
+      _initialized = NO;
+    }
     [_provider pauseAnimations];
   }
 }
 
+// Shown while the map warms up, until the live map or snapshot covers it
+- (void)applyStaticPlaceholderBackground {
+  const auto &viewProps =
+      *std::static_pointer_cast<LuggMapViewProps const>(_props);
+  if (viewProps.backgroundColor) {
+    // A user-provided background acts as the placeholder
+    return;
+  }
+
+  switch (_theme) {
+  case LuggMapViewTheme::Dark:
+    _mapWrapperView.overrideUserInterfaceStyle = UIUserInterfaceStyleDark;
+    break;
+  case LuggMapViewTheme::Light:
+    _mapWrapperView.overrideUserInterfaceStyle = UIUserInterfaceStyleLight;
+    break;
+  default:
+    _mapWrapperView.overrideUserInterfaceStyle =
+        UIUserInterfaceStyleUnspecified;
+    break;
+  }
+  _mapWrapperView.backgroundColor = UIColor.secondarySystemBackgroundColor;
+}
+
+- (nullable NSString *)staticSnapshotCacheKey {
+  if (_staticKey.length == 0 || !_mapWrapperView)
+    return nil;
+
+  CGSize size = _mapWrapperView.bounds.size;
+  if (size.width <= 0 || size.height <= 0)
+    return nil;
+
+  // 'system' theme snapshots depend on the current appearance
+  NSInteger style = _theme == LuggMapViewTheme::System
+                        ? (NSInteger)self.traitCollection.userInterfaceStyle
+                        : -(NSInteger)_theme;
+
+  // Camera is part of the key so a reused staticKey with a different
+  // location/zoom can't serve a stale snapshot. The provider's camera (when
+  // available) reflects imperative camera changes, so a re-rendered
+  // snapshot is keyed on what it actually shows.
+  const auto &viewProps =
+      *std::static_pointer_cast<LuggMapViewProps const>(_props);
+  double latitude = viewProps.initialCoordinate.latitude;
+  double longitude = viewProps.initialCoordinate.longitude;
+  double zoom = viewProps.initialZoom;
+  if ([_provider isKindOfClass:[StaticMapProviderBase class]]) {
+    StaticMapProviderBase *staticProvider = (StaticMapProviderBase *)_provider;
+    latitude = staticProvider.coordinate.latitude;
+    longitude = staticProvider.coordinate.longitude;
+    zoom = staticProvider.zoom;
+  }
+
+  return [NSString
+      stringWithFormat:@"%@|%d|%@|%d|%ld|%.0fx%.0f|%.6f,%.6f,%.2f|%@",
+                       _staticKey, (int)_providerType, _mapId, (int)_mapType,
+                       (long)style, size.width, size.height, latitude,
+                       longitude, zoom, NSStringFromUIEdgeInsets(_edgeInsets)];
+}
+
+- (void)startStaticContent {
+  [self applyStaticPlaceholderBackground];
+
+  // Both static providers render fully async: the placeholder shows until
+  // the snapshotter (Apple) or a brief live-map warmup (Google) delivers
+  // the base map, which reveals together with the marker/shape overlays
+  [self initializeProvider];
+}
+
+// staticKey identifies the map's content; when it changes (e.g. a recycled
+// list row bound to a new item), any live warmup or displayed snapshot is
+// stale and the static lifecycle restarts. Without this, an in-flight
+// warmup caches the old item's map under the new key.
+- (void)resetStaticContent {
+  _staticSnapshotDone = NO;
+
+  if (_provider) {
+    [_provider destroy];
+    _provider = nil;
+    _initialized = NO;
+  }
+
+  if (self.window) {
+    [self startStaticContent];
+  }
+}
+
 - (void)prepareForRecycle {
   [super prepareForRecycle];
 
+  _staticSnapshotDone = NO;
+
   [_provider destroy];
   _provider = nil;
   _mapWrapperView = nil;
@@ -148,7 +318,12 @@ using namespace luggmaps::events;
       *std::static_pointer_cast<LuggMapViewProps const>(_props);
 
   if (_providerType == LuggMapViewProvider::Apple) {
-    _provider = [[AppleMapProvider alloc] init];
+    _provider = _staticMode ? [[AppleStaticMapProvider alloc] init]
+                            : [[AppleMapProvider alloc] init];
+  } else if (_staticMode) {
+    GoogleStaticMapProvider *google = [[GoogleStaticMapProvider alloc] init];
+    google.mapId = _mapId;
+    _provider = google;
   } else {
     GoogleMapProvider *google = [[GoogleMapProvider alloc] init];
     google.mapId = _mapId;
@@ -156,6 +331,7 @@ using namespace luggmaps::events;
   }
 
   _provider.delegate = self;
+  _provider.staticMode = _staticMode;
 
   CLLocationCoordinate2D coordinate =
       CLLocationCoordinate2DMake(viewProps.initialCoordinate.latitude,
@@ -165,6 +341,16 @@ using namespace luggmaps::events;
                initialCoordinate:coordinate
                      initialZoom:viewProps.initialZoom];
 
+  // After initializeMapInView so the cache key reads the provider's camera;
+  // the base render is async and picks up the cached image
+  if (_staticMode) {
+    NSString *cacheKey = [self staticSnapshotCacheKey];
+    if (cacheKey) {
+      ((StaticMapProviderBase *)_provider).cachedBaseImage =
+          [StaticSnapshotCache() objectForKey:cacheKey];
+    }
+  }
+
   // Apply cached props after map view is created
   [self applyProps];
   [_provider setEdgeInsets:_edgeInsets oldEdgeInsets:UIEdgeInsetsZero];
@@ -179,6 +365,12 @@ using namespace luggmaps::events;
       [_provider addPolylineView:(LuggPolylineView *)subview];
     } else if ([subview isKindOfClass:[LuggPolygonView class]]) {
       [_provider addPolygonView:(LuggPolygonView *)subview];
+    } else if ([subview isKindOfClass:[LuggCircleView class]]) {
+      [_provider addCircleView:(LuggCircleView *)subview];
+    } else if ([subview isKindOfClass:[LuggGroundOverlayView class]]) {
+      [_provider addGroundOverlayView:(LuggGroundOverlayView *)subview];
+    } else if ([subview isKindOfClass:[LuggTileOverlayView class]]) {
+      [_provider addTileOverlayView:(LuggTileOverlayView *)subview];
     }
   }
 }
@@ -189,6 +381,19 @@ using namespace luggmaps::events;
   ReadyEvent::emit<LuggMapViewEventEmitter>(_eventEmitter);
 }
 
+- (void)mapProviderDidFinishStaticSnapshot {
+  _staticSnapshotDone = YES;
+}
+
+- (void)mapProviderDidCaptureStaticImage:(UIImage *)image {
+  NSString *key = [self staticSnapshotCacheKey];
+  if (key) {
+    NSUInteger cost = (NSUInteger)(image.size.width * image.scale *
+                                   image.size.height * image.scale * 4);
+    [StaticSnapshotCache() setObject:image forKey:key cost:cost];
+  }
+}
+
 - (void)mapProviderDidMoveCamera:(double)latitude
                        longitude:(double)longitude
                             zoom:(double)zoom
@@ -228,10 +433,16 @@ using namespace luggmaps::events;
   [_provider setScrollEnabled:_scrollEnabled];
   [_provider setRotateEnabled:_rotateEnabled];
   [_provider setPitchEnabled:_pitchEnabled];
+  [_provider setCompassEnabled:_compassEnabled];
   [_provider setUserLocationEnabled:_userLocationEnabled];
-  [_provider setTheme:(NSInteger)_theme];
+  [_provider setMapType:_mapType];
+  [_provider setTheme:_theme];
+  [_provider setPoiEnabled:_poiEnabled];
+  [_provider setPoiFilterMode:_poiFilterMode];
+  [_provider setPoiFilterCategories:_poiFilterCategories];
   [_provider setMinZoom:_minZoom];
   [_provider setMaxZoom:_maxZoom];
+  [_provider setInsetAdjustment:_insetAdjustment];
 }
 
 - (void)updateProps:(Props::Shared const &)props
@@ -242,6 +453,12 @@ using namespace luggmaps::events;
       *std::static_pointer_cast<LuggMapViewProps const>(_props);
 
   _providerType = newViewProps.provider;
+  _staticMode = newViewProps.staticMode;
+
+  NSString *newStaticKey =
+      [NSString stringWithUTF8String:newViewProps.staticKey.c_str()];
+  BOOL staticKeyChanged = ![newStaticKey isEqualToString:_staticKey];
+  _staticKey = newStaticKey;
 
   NSString *newMapId =
       [NSString stringWithUTF8String:newViewProps.mapId.c_str()];
@@ -265,10 +482,34 @@ using namespace luggmaps::events;
     _pitchEnabled = newViewProps.pitchEnabled;
     [_provider setPitchEnabled:_pitchEnabled];
   }
+  if (newViewProps.compassEnabled != prevViewProps.compassEnabled) {
+    _compassEnabled = newViewProps.compassEnabled;
+    [_provider setCompassEnabled:_compassEnabled];
+  }
   if (newViewProps.userLocationEnabled != prevViewProps.userLocationEnabled) {
     _userLocationEnabled = newViewProps.userLocationEnabled;
     [_provider setUserLocationEnabled:_userLocationEnabled];
   }
+  if (newViewProps.poiEnabled != prevViewProps.poiEnabled) {
+    _poiEnabled = newViewProps.poiEnabled;
+    [_provider setPoiEnabled:_poiEnabled];
+  }
+  if (newViewProps.poiFilterMode != prevViewProps.poiFilterMode) {
+    _poiFilterMode = newViewProps.poiFilterMode;
+    [_provider setPoiFilterMode:_poiFilterMode];
+  }
+  if (newViewProps.poiFilterCategories != prevViewProps.poiFilterCategories) {
+    NSMutableArray<NSString *> *categories = [NSMutableArray array];
+    for (const auto &category : newViewProps.poiFilterCategories) {
+      [categories addObject:[NSString stringWithUTF8String:category.c_str()]];
+    }
+    _poiFilterCategories = [categories copy];
+    [_provider setPoiFilterCategories:_poiFilterCategories];
+  }
+  if (newViewProps.mapType != prevViewProps.mapType) {
+    _mapType = newViewProps.mapType;
+    [_provider setMapType:_mapType];
+  }
   if (newViewProps.minZoom != prevViewProps.minZoom) {
     _minZoom = newViewProps.minZoom;
     [_provider setMinZoom:_minZoom];
@@ -279,7 +520,11 @@ using namespace luggmaps::events;
   }
   if (newViewProps.theme != prevViewProps.theme) {
     _theme = newViewProps.theme;
-    [_provider setTheme:(NSInteger)_theme];
+    [_provider setTheme:_theme];
+  }
+  if (newViewProps.insetAdjustment != prevViewProps.insetAdjustment) {
+    _insetAdjustment = newViewProps.insetAdjustment;
+    [_provider setInsetAdjustment:_insetAdjustment];
   }
 
   UIEdgeInsets newEdgeInsets = UIEdgeInsetsMake(
@@ -292,6 +537,11 @@ using namespace luggmaps::events;
   }
 
   [super updateProps:props oldProps:oldProps];
+
+  // After super so the snapshot cache key sees the new camera props
+  if (staticKeyChanged && _staticMode && _mapWrapperView) {
+    [self resetStaticContent];
+  }
 }
 
 #pragma mark - Commands

package/ios/LuggMapWrapperView.h

@@ -4,6 +4,11 @@
 NS_ASSUME_NONNULL_BEGIN
 
 @interface LuggMapWrapperView : RCTViewComponentView
+
+/// Called after layout; lets the static snapshotter start (or restart)
+/// once the wrapper has a real size, since a snapshot can't autoresize
+@property(nonatomic, copy, nullable) void (^layoutHandler)(void);
+
 @end
 
 NS_ASSUME_NONNULL_END

package/ios/LuggMapWrapperView.mm

@@ -29,6 +29,24 @@ using namespace facebook::react;
   return self;
 }
 
+- (void)layoutSubviews {
+  [super layoutSubviews];
+  if (self.layoutHandler) {
+    self.layoutHandler();
+  }
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+
+  // Static placeholder styling is applied outside of props
+  // (LuggMapView applyStaticPlaceholderBackground) and would otherwise
+  // leak into the next map that reuses this recycled view
+  self.backgroundColor = nil;
+  self.overrideUserInterfaceStyle = UIUserInterfaceStyleUnspecified;
+  self.layoutHandler = nil;
+}
+
 Class<RCTComponentViewProtocol> LuggMapWrapperViewCls(void) {
   return LuggMapWrapperView.class;
 }

package/ios/LuggMarkerView.h

@@ -11,6 +11,8 @@ NS_ASSUME_NONNULL_BEGIN
 @optional
 - (void)markerViewDidLayout:(LuggMarkerView *)markerView;
 - (void)markerViewDidUpdate:(LuggMarkerView *)markerView;
+- (void)showCalloutForMarkerView:(LuggMarkerView *)markerView;
+- (void)hideCalloutForMarkerView:(LuggMarkerView *)markerView;
 @end
 
 @interface LuggMarkerView : RCTViewComponentView
@@ -24,6 +26,7 @@ NS_ASSUME_NONNULL_BEGIN
 @property(nonatomic, readonly) CLLocationDegrees rotate;
 @property(nonatomic, readonly) CGFloat scale;
 @property(nonatomic, readonly) BOOL rasterize;
+@property(nonatomic, readonly) BOOL centerOnPress;
 @property(nonatomic, readonly) BOOL draggable;
 @property(nonatomic, readonly) BOOL hasCustomView;
 @property(nonatomic, readonly) BOOL didLayout;

package/ios/LuggMarkerView.mm

@@ -26,6 +26,7 @@ using namespace luggmaps::events;
   CLLocationDegrees _rotate;
   CGFloat _scale;
   BOOL _rasterize;
+  BOOL _centerOnPress;
   BOOL _draggable;
   BOOL _didLayout;
   UIView *_iconView;
@@ -49,6 +50,7 @@ using namespace luggmaps::events;
     _rotate = 0;
     _scale = 1;
     _rasterize = YES;
+    _centerOnPress = YES;
     _didLayout = NO;
 
     _iconView = [[UIView alloc] init];
@@ -78,6 +80,7 @@ using namespace luggmaps::events;
   _rotate = newViewProps.rotate;
   _scale = newViewProps.scale;
   _rasterize = newViewProps.rasterize;
+  _centerOnPress = newViewProps.centerOnPress;
   _draggable = newViewProps.draggable;
 }
 
@@ -174,6 +177,10 @@ using namespace luggmaps::events;
   return _rasterize;
 }
 
+- (BOOL)centerOnPress {
+  return _centerOnPress;
+}
+
 - (BOOL)draggable {
   return _draggable;
 }
@@ -280,6 +287,24 @@ using namespace luggmaps::events;
   _iconView.layer.anchorPoint = CGPointMake(0.5, 0.5);
   _iconView.frame = CGRectMake(0, 0, _iconView.bounds.size.width,
                                _iconView.bounds.size.height);
+  // Static providers hide the icon view until positioned
+  _iconView.hidden = NO;
+}
+
+- (void)showCallout {
+  if ([self.delegate respondsToSelector:@selector(showCalloutForMarkerView:)]) {
+    [self.delegate showCalloutForMarkerView:self];
+  }
+}
+
+- (void)hideCallout {
+  if ([self.delegate respondsToSelector:@selector(hideCalloutForMarkerView:)]) {
+    [self.delegate hideCalloutForMarkerView:self];
+  }
+}
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args {
+  RCTLuggMarkerViewHandleCommand(self, commandName, args);
 }
 
 - (void)prepareForRecycle {

package/ios/LuggTileOverlayView.h

@@ -0,0 +1,31 @@
+#import <CoreLocation/CoreLocation.h>
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class LuggTileOverlayView;
+
+@protocol LuggTileOverlayViewDelegate <NSObject>
+@optional
+- (void)tileOverlayViewDidUpdate:(LuggTileOverlayView *)tileOverlayView;
+@end
+
+@interface LuggTileOverlayView : RCTViewComponentView
+
+@property(nonatomic, readonly) NSString *urlTemplate;
+@property(nonatomic, readonly) NSInteger tileSize;
+@property(nonatomic, readonly) CGFloat opacity;
+@property(nonatomic, readonly) BOOL hasBounds;
+@property(nonatomic, readonly) CLLocationCoordinate2D northeast;
+@property(nonatomic, readonly) CLLocationCoordinate2D southwest;
+@property(nonatomic, readonly) NSInteger zIndex;
+@property(nonatomic, readonly) BOOL tappable;
+@property(nonatomic, weak, nullable) id<LuggTileOverlayViewDelegate> delegate;
+@property(nonatomic, strong, nullable) NSObject *overlay;
+
+- (void)emitPressEvent;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/LuggTileOverlayView.mm

@@ -0,0 +1,130 @@
+#import "LuggTileOverlayView.h"
+#import "events/TileOverlayPressEvent.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;
+using namespace luggmaps::events;
+
+@interface LuggTileOverlayView () <RCTLuggTileOverlayViewViewProtocol>
+@end
+
+@implementation LuggTileOverlayView {
+  NSString *_urlTemplate;
+  NSInteger _tileSize;
+  CGFloat _opacity;
+  BOOL _hasBounds;
+  CLLocationCoordinate2D _northeast;
+  CLLocationCoordinate2D _southwest;
+  NSInteger _zIndex;
+  BOOL _tappable;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<
+      LuggTileOverlayViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps =
+        std::make_shared<const LuggTileOverlayViewProps>();
+    _props = defaultProps;
+
+    _urlTemplate = @"";
+    _tileSize = 256;
+    _opacity = 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<LuggTileOverlayViewProps const>(props);
+
+  _urlTemplate =
+      [NSString stringWithUTF8String:newViewProps.urlTemplate.c_str()];
+  _tileSize = newViewProps.tileSize;
+  _opacity = newViewProps.opacity;
+
+  auto ne = newViewProps.bounds.northeast;
+  auto sw = newViewProps.bounds.southwest;
+  _hasBounds = (ne.latitude != 0 || ne.longitude != 0 || sw.latitude != 0 ||
+                sw.longitude != 0);
+  if (_hasBounds) {
+    _northeast = CLLocationCoordinate2DMake(ne.latitude, ne.longitude);
+    _southwest = CLLocationCoordinate2DMake(sw.latitude, sw.longitude);
+  }
+
+  _zIndex = newViewProps.zIndex.value_or(0);
+  _tappable = newViewProps.tappable;
+}
+
+- (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask {
+  [super finalizeUpdates:updateMask];
+
+  if (updateMask & RNComponentViewUpdateMaskProps) {
+    if ([self.delegate
+            respondsToSelector:@selector(tileOverlayViewDidUpdate:)]) {
+      [self.delegate tileOverlayViewDidUpdate:self];
+    }
+  }
+}
+
+- (NSString *)urlTemplate {
+  return _urlTemplate;
+}
+
+- (NSInteger)tileSize {
+  return _tileSize;
+}
+
+- (CGFloat)opacity {
+  return _opacity;
+}
+
+- (BOOL)hasBounds {
+  return _hasBounds;
+}
+
+- (CLLocationCoordinate2D)northeast {
+  return _northeast;
+}
+
+- (CLLocationCoordinate2D)southwest {
+  return _southwest;
+}
+
+- (NSInteger)zIndex {
+  return _zIndex;
+}
+
+- (BOOL)tappable {
+  return _tappable;
+}
+
+- (void)emitPressEvent {
+  TileOverlayPressEvent::emit<LuggTileOverlayViewEventEmitter>(_eventEmitter);
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+  self.overlay = nil;
+  self.delegate = nil;
+}
+
+Class<RCTComponentViewProtocol> LuggTileOverlayViewCls(void) {
+  return LuggTileOverlayView.class;
+}
+
+@end

package/ios/core/AppleMapProvider.h

@@ -3,6 +3,14 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
+/// POI filter for the given props, shared by the live map view and the
+/// static snapshotter. Returns nil for "show everything".
+MKPointOfInterestFilter *_Nullable LuggPointOfInterestFilter(
+    BOOL poiEnabled, facebook::react::LuggMapViewPoiFilterMode filterMode,
+    NSArray<NSString *> *filterCategories);
+
+MKMapType LuggMKMapTypeFromMapType(facebook::react::LuggMapViewMapType mapType);
+
 @interface LuggAppleMapViewContent : MKMapView
 @end