@lugg/maps 1.0.0-beta.9 → 1.1.0

package/ios/core/AppleMapProvider.mm

@@ -15,6 +15,7 @@ using facebook::react::LuggMapViewTheme;
 #import "../extensions/MKMapView+Zoom.h"
 #import "LuggAnnotationView.h"
 #import "MKPolylineAnimator.h"
+#import "MapEdgeInsets.h"
 
 @interface AppleMarkerAnnotation : NSObject <MKAnnotation>
 @property(nonatomic, assign) CLLocationCoordinate2D coordinate;
@@ -145,6 +146,7 @@ static double tileToLng(NSInteger x, NSInteger z) {
 }
 
 @synthesize delegate = _delegate;
+@synthesize staticMode = _staticMode;
 
 - (instancetype)init {
   if (self = [super init]) {
@@ -182,6 +184,10 @@ static double tileToLng(NSInteger x, NSInteger z) {
   _mapView.delegate = self;
   _mapView.insetsLayoutMarginsFromSafeArea = NO;
 
+  if (_staticMode) {
+    _mapView.userInteractionEnabled = NO;
+  }
+
   [self applyZoomRange];
 
   _tapGesture =
@@ -212,6 +218,19 @@ static double tileToLng(NSInteger x, NSInteger z) {
 }
 
 - (void)destroy {
+  [self destroyMapView];
+  _isMapReady = NO;
+}
+
+- (CLLocationCoordinate2D)coordinate {
+  return _mapView.centerCoordinate;
+}
+
+- (double)zoom {
+  return _mapView.zoomLevel;
+}
+
+- (void)destroyMapView {
   [self dismissNonBubbledCallout];
   [self stopEdgeInsetsAnimation];
   if (_tapGesture) {
@@ -222,9 +241,9 @@ static double tileToLng(NSInteger x, NSInteger z) {
     [_mapView removeGestureRecognizer:_longPressGesture];
     _longPressGesture = nil;
   }
+  _mapView.delegate = nil;
   [_mapView removeFromSuperview];
   _mapView = nil;
-  _isMapReady = NO;
 }
 
 #pragma mark - Props
@@ -245,6 +264,10 @@ static double tileToLng(NSInteger x, NSInteger z) {
   _mapView.pitchEnabled = enabled;
 }
 
+- (void)setCompassEnabled:(BOOL)enabled {
+  _mapView.showsCompass = enabled;
+}
+
 - (void)setUserLocationEnabled:(BOOL)enabled {
   _mapView.showsUserLocation = enabled;
 }
@@ -338,33 +361,36 @@ static MKPointOfInterestCategory poiCategoryFromString(NSString *string) {
   return map[string];
 }
 
-- (void)applyPoiFilter {
-  if (!_poiEnabled) {
-    _mapView.pointOfInterestFilter =
-        MKPointOfInterestFilter.filterExcludingAllCategories;
-    return;
+MKPointOfInterestFilter *_Nullable LuggPointOfInterestFilter(
+    BOOL poiEnabled, LuggMapViewPoiFilterMode filterMode,
+    NSArray<NSString *> *filterCategories) {
+  if (!poiEnabled) {
+    return MKPointOfInterestFilter.filterExcludingAllCategories;
   }
-  if (_poiFilterCategories.count > 0) {
+  if (filterCategories.count > 0) {
     NSMutableArray<MKPointOfInterestCategory> *categories =
         [NSMutableArray array];
-    for (NSString *name in _poiFilterCategories) {
+    for (NSString *name in filterCategories) {
       MKPointOfInterestCategory category = poiCategoryFromString(name);
       if (category) {
         [categories addObject:category];
       }
     }
     if (categories.count > 0) {
-      if (_poiFilterMode == LuggMapViewPoiFilterMode::Excluding) {
-        _mapView.pointOfInterestFilter = [[MKPointOfInterestFilter alloc]
+      if (filterMode == LuggMapViewPoiFilterMode::Excluding) {
+        return [[MKPointOfInterestFilter alloc]
             initExcludingCategories:categories];
-      } else {
-        _mapView.pointOfInterestFilter = [[MKPointOfInterestFilter alloc]
-            initIncludingCategories:categories];
       }
-      return;
+      return
+          [[MKPointOfInterestFilter alloc] initIncludingCategories:categories];
     }
   }
-  _mapView.pointOfInterestFilter = nil;
+  return nil;
+}
+
+- (void)applyPoiFilter {
+  _mapView.pointOfInterestFilter = LuggPointOfInterestFilter(
+      _poiEnabled, _poiFilterMode, _poiFilterCategories);
 }
 
 - (void)setInsetAdjustment:(LuggMapViewInsetAdjustment)insetAdjustment {
@@ -395,26 +421,25 @@ static MKPointOfInterestCategory poiCategoryFromString(NSString *string) {
   [self applyPoiFilter];
 }
 
-- (void)setMapType:(LuggMapViewMapType)mapType {
+MKMapType LuggMKMapTypeFromMapType(LuggMapViewMapType mapType) {
   switch (mapType) {
   case LuggMapViewMapType::Satellite:
-    _mapView.mapType = MKMapTypeSatellite;
-    break;
+    return MKMapTypeSatellite;
   case LuggMapViewMapType::Terrain:
-    _mapView.mapType = MKMapTypeStandard;
-    break;
+    return MKMapTypeStandard;
   case LuggMapViewMapType::Hybrid:
-    _mapView.mapType = MKMapTypeHybrid;
-    break;
+    return MKMapTypeHybrid;
   case LuggMapViewMapType::MutedStandard:
-    _mapView.mapType = MKMapTypeMutedStandard;
-    break;
+    return MKMapTypeMutedStandard;
   default:
-    _mapView.mapType = MKMapTypeStandard;
-    break;
+    return MKMapTypeStandard;
   }
 }
 
+- (void)setMapType:(LuggMapViewMapType)mapType {
+  _mapView.mapType = LuggMKMapTypeFromMapType(mapType);
+}
+
 - (void)setTheme:(LuggMapViewTheme)theme {
   switch (theme) {
   case LuggMapViewTheme::Dark:
@@ -441,13 +466,11 @@ static MKPointOfInterestCategory poiCategoryFromString(NSString *string) {
 
 - (void)setEdgeInsets:(UIEdgeInsets)edgeInsets
         oldEdgeInsets:(UIEdgeInsets)oldEdgeInsets {
-  CGFloat oldOffsetX = (oldEdgeInsets.left - oldEdgeInsets.right) / 2.0;
-  CGFloat oldOffsetY = (oldEdgeInsets.top - oldEdgeInsets.bottom) / 2.0;
-  CGFloat newOffsetX = (edgeInsets.left - edgeInsets.right) / 2.0;
-  CGFloat newOffsetY = (edgeInsets.top - edgeInsets.bottom) / 2.0;
+  CGPoint oldOffset = LuggMapInsetOffset(oldEdgeInsets);
+  CGPoint newOffset = LuggMapInsetOffset(edgeInsets);
 
-  CGFloat deltaX = newOffsetX - oldOffsetX;
-  CGFloat deltaY = newOffsetY - oldOffsetY;
+  CGFloat deltaX = newOffset.x - oldOffset.x;
+  CGFloat deltaY = newOffset.y - oldOffset.y;
 
   _mapView.layoutMargins = edgeInsets;
   _edgeInsetsCurrent = edgeInsets;
@@ -490,16 +513,8 @@ static MKPointOfInterestCategory poiCategoryFromString(NSString *string) {
   CFTimeInterval elapsed = CACurrentMediaTime() - _edgeInsetsAnimationStart;
   CGFloat progress = MIN(elapsed / _edgeInsetsAnimationDuration, 1.0);
 
-  // Ease out cubic
-  CGFloat t = 1.0 - (1.0 - progress) * (1.0 - progress) * (1.0 - progress);
-
-  UIEdgeInsets current = UIEdgeInsetsMake(
-      _edgeInsetsFrom.top + (_edgeInsetsTo.top - _edgeInsetsFrom.top) * t,
-      _edgeInsetsFrom.left + (_edgeInsetsTo.left - _edgeInsetsFrom.left) * t,
-      _edgeInsetsFrom.bottom +
-          (_edgeInsetsTo.bottom - _edgeInsetsFrom.bottom) * t,
-      _edgeInsetsFrom.right +
-          (_edgeInsetsTo.right - _edgeInsetsFrom.right) * t);
+  UIEdgeInsets current =
+      LuggMapInsetsAtProgress(_edgeInsetsFrom, _edgeInsetsTo, progress);
 
   [self setEdgeInsets:current oldEdgeInsets:_edgeInsetsCurrent];
 
@@ -832,7 +847,8 @@ static MKPointOfInterestCategory poiCategoryFromString(NSString *string) {
         renderer.strokeColors = colors;
       }
       renderer.animatedOptions = polylineView.animatedOptions;
-      renderer.animated = polylineView.animated;
+      // Static maps snapshot an arbitrary frame; render the full polyline
+      renderer.animated = polylineView.animated && !_staticMode;
       polylineView.renderer = renderer;
       return renderer;
     }
@@ -1361,7 +1377,7 @@ static MKPointOfInterestCategory poiCategoryFromString(NSString *string) {
     renderer.strokeColors =
         polylineView.strokeColors.count > 1 ? polylineView.strokeColors : nil;
     renderer.animatedOptions = polylineView.animatedOptions;
-    renderer.animated = polylineView.animated;
+    renderer.animated = polylineView.animated && !_staticMode;
     return;
   }
 
@@ -1774,11 +1790,11 @@ static MKPointOfInterestCategory poiCategoryFromString(NSString *string) {
   } else if (duration > 0) {
     CLLocationCoordinate2D center =
         CLLocationCoordinate2DMake(latitude, longitude);
-    MKCoordinateRegion region = [_mapView regionForCenterCoordinate:center
-                                                          zoomLevel:targetZoom];
+    MKMapCamera *camera = [_mapView cameraForCenterCoordinate:center
+                                                    zoomLevel:targetZoom];
     [UIView animateWithDuration:duration / 1000.0
                      animations:^{
-                       [self->_mapView setRegion:region animated:NO];
+                       [self->_mapView setCamera:camera animated:NO];
                      }];
   } else {
     [_mapView

package/ios/core/AppleStaticMapProvider.h

@@ -0,0 +1,14 @@
+#import "StaticMapProviderBase.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Static Apple map rendered with MKMapSnapshotter. The base map renders
+ * fully asynchronously (no live MKMapView is ever created), so static maps
+ * keep loading while the user scrolls without blocking the main thread.
+ */
+@interface AppleStaticMapProvider : StaticMapProviderBase
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/core/AppleStaticMapProvider.mm

@@ -0,0 +1,233 @@
+#import "AppleStaticMapProvider.h"
+
+using facebook::react::LuggMapViewPoiFilterMode;
+using facebook::react::LuggMapViewTheme;
+
+#import "../extensions/MKMapView+Zoom.h"
+#import "../extensions/UIView+Snapshot.h"
+#import "AppleMapProvider.h"
+#import "LuggAnnotationView.h"
+
+// Standard MKMarkerAnnotationView balloon size; standalone (off-map) views
+// don't size themselves
+static const CGSize kDefaultMarkerSize = {28, 33};
+
+// The rect the snapshot renders: the region for the requested zoom, expanded
+// on the short axis to the view's aspect ratio - the same fit MKMapView
+// applies in setRegion, so static and live maps frame alike. Passing this
+// exact rect to MKMapSnapshotter makes the projection exact.
+static MKMapRect LuggStaticFittedMapRect(CLLocationCoordinate2D center,
+                                         double zoom, CGSize size) {
+  MKCoordinateSpan span = LuggCoordinateSpanForZoomLevel(MIN(zoom, 28), center);
+  MKMapPoint topLeft = MKMapPointForCoordinate(CLLocationCoordinate2DMake(
+      MIN(center.latitude + span.latitudeDelta / 2, 90.0),
+      center.longitude - span.longitudeDelta / 2));
+  MKMapPoint bottomRight = MKMapPointForCoordinate(CLLocationCoordinate2DMake(
+      MAX(center.latitude - span.latitudeDelta / 2, -90.0),
+      center.longitude + span.longitudeDelta / 2));
+  MKMapRect rect =
+      MKMapRectMake(topLeft.x, topLeft.y, bottomRight.x - topLeft.x,
+                    bottomRight.y - topLeft.y);
+
+  double viewAspect = size.width / size.height;
+  double rectAspect = rect.size.width / rect.size.height;
+  if (rectAspect > viewAspect) {
+    double height = rect.size.width / viewAspect;
+    rect.origin.y -= (height - rect.size.height) / 2;
+    rect.size.height = height;
+  } else {
+    double width = rect.size.height * viewAspect;
+    rect.origin.x -= (width - rect.size.width) / 2;
+    rect.size.width = width;
+  }
+  return rect;
+}
+
+@interface AppleStaticMapProvider () <MKMapViewDelegate>
+@end
+
+@implementation AppleStaticMapProvider {
+  MKMapSnapshotter *_snapshotter;
+  MKMapView *_warmupMapView;
+  BOOL _snapshotReady;
+
+  BOOL _poiEnabled;
+  LuggMapViewPoiFilterMode _poiFilterMode;
+  NSArray<NSString *> *_poiFilterCategories;
+}
+
+- (instancetype)init {
+  if (self = [super init]) {
+    _poiEnabled = YES;
+    _poiFilterMode = LuggMapViewPoiFilterMode::Including;
+    _poiFilterCategories = @[];
+  }
+  return self;
+}
+
+#pragma mark - StaticMapProviderBase
+
+- (MKMapRect)mapRectForSize:(CGSize)size {
+  return LuggStaticFittedMapRect(self.coordinate, self.zoom, size);
+}
+
+- (UIView *)newDefaultMarkerOverlayView {
+  MKAnnotationView *pin =
+      [[LuggMarkerAnnotationView alloc] initWithAnnotation:nil
+                                           reuseIdentifier:nil];
+  pin.bounds =
+      CGRectMake(0, 0, kDefaultMarkerSize.width, kDefaultMarkerSize.height);
+  return pin;
+}
+
+// Inverse of LuggStaticFittedMapRect: the pre-fit rect is square in map
+// points with side latitudeDelta * worldHeight / (360 * cos(lat)), and the
+// aspect fit scales it to the view's short side
+- (double)zoomForMapPointsPerPoint:(double)mapPointsPerPoint {
+  CGSize size = self.projectedSize;
+  double side = mapPointsPerPoint * MIN(size.width, size.height);
+  double latitudeDelta = side * 360.0 *
+                         cos(self.coordinate.latitude * M_PI / 180.0) /
+                         MKMapSizeWorld.height;
+  double zoom = 0.5 + log2(360.0 / latitudeDelta);
+  return MAX(MIN(zoom, 28.0), 0.0);
+}
+
+- (UITraitCollection *)snapshotTraitCollection {
+  UITraitCollection *base = self.wrapperView.traitCollection;
+  UIUserInterfaceStyle style;
+  switch (self.theme) {
+  case LuggMapViewTheme::Dark:
+    style = UIUserInterfaceStyleDark;
+    break;
+  case LuggMapViewTheme::Light:
+    style = UIUserInterfaceStyleLight;
+    break;
+  default:
+    return base;
+  }
+  return [UITraitCollection traitCollectionWithTraitsFromCollections:@[
+    base, [UITraitCollection traitCollectionWithUserInterfaceStyle:style]
+  ]];
+}
+
+- (void)renderBaseMap {
+  // MKMapSnapshotter bakes attribution into the image without inset control.
+  if (!UIEdgeInsetsEqualToEdgeInsets(self.edgeInsets, UIEdgeInsetsZero)) {
+    [self renderInsetBaseMap];
+    return;
+  }
+
+  if (_snapshotter)
+    return;
+
+  MKMapSnapshotOptions *options = [[MKMapSnapshotOptions alloc] init];
+  options.mapRect = self.mapRect;
+  options.size = self.projectedSize;
+  options.mapType = LuggMKMapTypeFromMapType(self.mapType);
+  options.pointOfInterestFilter = LuggPointOfInterestFilter(
+      _poiEnabled, _poiFilterMode, _poiFilterCategories);
+  options.traitCollection = [self snapshotTraitCollection];
+
+  MKMapSnapshotter *snapshotter =
+      [[MKMapSnapshotter alloc] initWithOptions:options];
+  _snapshotter = snapshotter;
+
+  __weak AppleStaticMapProvider *weakSelf = self;
+  [snapshotter startWithQueue:dispatch_get_main_queue()
+            completionHandler:^(MKMapSnapshot *snapshot, NSError *error) {
+              AppleStaticMapProvider *strongSelf = weakSelf;
+              if (!strongSelf || strongSelf->_snapshotter != snapshotter)
+                return;
+              strongSelf->_snapshotter = nil;
+              if (error || !snapshot) {
+                // Keep the placeholder; resumeAnimations retries (e.g. back
+                // online)
+                return;
+              }
+              [strongSelf displayBaseImage:snapshot.image fromCache:NO];
+            }];
+}
+
+- (void)cancelBaseRender {
+  [_snapshotter cancel];
+  _snapshotter = nil;
+  _warmupMapView.delegate = nil;
+  [_warmupMapView removeFromSuperview];
+  _warmupMapView = nil;
+  _snapshotReady = NO;
+}
+
+#pragma mark - Inset snapshots
+
+- (void)renderInsetBaseMap {
+  if (_warmupMapView) {
+    if (!_snapshotReady || !_warmupMapView.window)
+      return;
+
+    UIImageView *imageView = [_warmupMapView lugg_snapshotImageView];
+    if (!imageView)
+      return;
+
+    [self displayBaseImage:imageView.image fromCache:NO];
+    [self cancelBaseRender];
+    return;
+  }
+
+  MKMapView *mapView =
+      [[MKMapView alloc] initWithFrame:self.wrapperView.bounds];
+  mapView.userInteractionEnabled = NO;
+  mapView.showsCompass = NO;
+  mapView.insetsLayoutMarginsFromSafeArea = NO;
+  mapView.layoutMargins = self.edgeInsets;
+  mapView.mapType = LuggMKMapTypeFromMapType(self.mapType);
+  mapView.pointOfInterestFilter = LuggPointOfInterestFilter(
+      _poiEnabled, _poiFilterMode, _poiFilterCategories);
+  mapView.overrideUserInterfaceStyle =
+      [self snapshotTraitCollection].userInterfaceStyle;
+  [mapView setVisibleMapRect:self.mapRect
+                 edgePadding:UIEdgeInsetsZero
+                    animated:NO];
+  _warmupMapView = mapView;
+  mapView.delegate = self;
+  [self.wrapperView insertSubview:mapView atIndex:0];
+}
+
+- (void)mapViewWillStartRenderingMap:(MKMapView *)mapView {
+  _snapshotReady = NO;
+}
+
+- (void)mapViewDidFinishRenderingMap:(MKMapView *)mapView
+                       fullyRendered:(BOOL)fullyRendered {
+  _snapshotReady = fullyRendered;
+  [self revealOverlays];
+  if (!fullyRendered)
+    return;
+
+  __weak AppleStaticMapProvider *weakSelf = self;
+  __weak MKMapView *weakMapView = mapView;
+  [[NSRunLoop mainRunLoop]
+      performInModes:@[ NSDefaultRunLoopMode ]
+               block:^{
+                 AppleStaticMapProvider *strongSelf = weakSelf;
+                 if (strongSelf && weakMapView &&
+                     strongSelf->_warmupMapView == weakMapView)
+                   [strongSelf renderInsetBaseMap];
+               }];
+}
+
+#pragma mark - Props
+
+- (void)setPoiEnabled:(BOOL)enabled {
+  _poiEnabled = enabled;
+}
+
+- (void)setPoiFilterMode:(LuggMapViewPoiFilterMode)mode {
+  _poiFilterMode = mode;
+}
+
+- (void)setPoiFilterCategories:(NSArray<NSString *> *)categories {
+  _poiFilterCategories = categories;
+}
+
+@end

package/ios/core/GMSPolylineAnimator.m

@@ -148,13 +148,25 @@ static const NSUInteger kMaxGradientSpans = 512;
   }
 
   GMSMutablePath *path = [GMSMutablePath path];
-  for (CLLocation *location in self.coordinates) {
-    [path addCoordinate:location.coordinate];
+  CLLocationCoordinate2D lastCoord = self.coordinates.firstObject.coordinate;
+  [path addCoordinate:lastCoord];
+  for (NSUInteger i = 1; i < self.coordinates.count; i++) {
+    CLLocationCoordinate2D coord = self.coordinates[i].coordinate;
+    if (coord.latitude == lastCoord.latitude && coord.longitude == lastCoord.longitude) {
+      continue;
+    }
+    [path addCoordinate:coord];
+    lastCoord = coord;
   }
+
+  // Clear stale spans before swapping the path so Google Maps never rebuilds
+  // span models against a path with fewer segments (GMSModelStyleBuilder
+  // couldNotInstantiate -> EXC_BAD_ACCESS). Reassign spans once the new path is set.
+  _polyline.spans = nil;
   _polyline.path = path;
 
-  if (self.strokeColors.count > 1) {
-    _polyline.spans = [self createGradientSpans];
+  if (path.count > 1 && self.strokeColors.count > 1) {
+    _polyline.spans = [self createGradientSpansForSegmentCount:path.count - 1];
   } else {
     _polyline.strokeColor = self.strokeColors.firstObject ?: [UIColor blackColor];
   }
@@ -222,35 +234,44 @@ static const NSUInteger kMaxGradientSpans = 512;
   }
 
   if (headDist <= tailDist) {
+    _polyline.spans = nil;
     _polyline.path = [GMSMutablePath path];
     return;
   }
 
-  CGFloat visibleLength = headDist - tailDist;
   NSUInteger startIndex = [self indexForDistance:tailDist];
   NSUInteger endIndex = [self indexForDistance:headDist];
 
   GMSMutablePath *path = [GMSMutablePath path];
-  NSMutableArray<GMSStyleSpan *> *spans = [NSMutableArray array];
 
-  CLLocationCoordinate2D startCoord = [self coordinateAtDistance:tailDist];
-  [path addCoordinate:startCoord];
+  CLLocationCoordinate2D lastCoord = [self coordinateAtDistance:tailDist];
+  [path addCoordinate:lastCoord];
 
   for (NSUInteger i = startIndex + 1; i <= endIndex; i++) {
-    [path addCoordinate:self.coordinates[i].coordinate];
+    CLLocationCoordinate2D coord = self.coordinates[i].coordinate;
+    if (coord.latitude == lastCoord.latitude && coord.longitude == lastCoord.longitude) {
+      continue;
+    }
+    [path addCoordinate:coord];
+    lastCoord = coord;
   }
 
   CLLocationCoordinate2D endCoord = [self coordinateAtDistance:headDist];
-  CLLocationCoordinate2D lastAdded =
-      (endIndex < self.coordinates.count) ? self.coordinates[endIndex].coordinate : endCoord;
-  if (endCoord.latitude != lastAdded.latitude || endCoord.longitude != lastAdded.longitude) {
+  if (endCoord.latitude != lastCoord.latitude || endCoord.longitude != lastCoord.longitude) {
     [path addCoordinate:endCoord];
   }
 
   NSUInteger pathCount = path.count;
-  NSUInteger segmentCount = pathCount - 1;
+  NSUInteger segmentCount = (pathCount > 1) ? pathCount - 1 : 0;
+
+  if (segmentCount == 0) {
+    _polyline.spans = nil;
+    _polyline.path = path;
+    return;
+  }
 
   if (self.strokeColors.count <= 1) {
+    _polyline.spans = nil;
     _polyline.path = path;
     _polyline.strokeColor = self.strokeColors.firstObject ?: [UIColor blackColor];
     return;
@@ -259,6 +280,7 @@ static const NSUInteger kMaxGradientSpans = 512;
   NSUInteger spanCount = MIN(segmentCount, kMaxAnimationSpans);
   double segmentsPerSpan = (double)segmentCount / spanCount;
 
+  NSMutableArray<GMSStyleSpan *> *spans = [NSMutableArray array];
   for (NSUInteger i = 0; i < spanCount; i++) {
     CGFloat gradientPos = ((CGFloat)i + 0.5) / spanCount;
     UIColor *color = [self colorAtGradientPosition:gradientPos];
@@ -266,13 +288,16 @@ static const NSUInteger kMaxGradientSpans = 512;
     [spans addObject:[GMSStyleSpan spanWithStyle:style segments:segmentsPerSpan]];
   }
 
+  // Clear stale spans before swapping the path so Google Maps never rebuilds
+  // span models against a path with fewer segments (GMSModelStyleBuilder
+  // couldNotInstantiate -> EXC_BAD_ACCESS). Reassign spans once the new path is set.
+  _polyline.spans = nil;
   _polyline.path = path;
   _polyline.spans = spans;
 }
 
-- (NSArray<GMSStyleSpan *> *)createGradientSpans {
+- (NSArray<GMSStyleSpan *> *)createGradientSpansForSegmentCount:(NSUInteger)segmentCount {
   NSMutableArray<GMSStyleSpan *> *spans = [NSMutableArray array];
-  NSUInteger segmentCount = self.coordinates.count - 1;
   NSUInteger spanCount = MIN(segmentCount, kMaxGradientSpans);
   double segmentsPerSpan = (double)segmentCount / spanCount;
 

package/ios/core/GoogleMapProvider.h

@@ -3,6 +3,16 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
+/// Resolves a mapId prop value ("" or "DEMO_MAP_ID" -> demo map ID),
+/// shared by the live and static Google providers.
+GMSMapID *LuggGMSMapIDFromString(NSString *_Nullable mapId);
+
+GMSMapViewType
+LuggGMSMapTypeFromMapType(facebook::react::LuggMapViewMapType mapType);
+
+UIUserInterfaceStyle
+LuggInterfaceStyleFromTheme(facebook::react::LuggMapViewTheme theme);
+
 @interface GoogleMapProvider : NSObject <MapProvider, GMSMapViewDelegate>
 
 @property(nonatomic, copy, nullable) NSString *mapId;