@lugg/maps 0.2.0-alpha.3 → 0.2.0-alpha.30

package/ios/core/MKPolylineAnimator.m

@@ -1,10 +1,42 @@
 #import "MKPolylineAnimator.h"
 #import <QuartzCore/QuartzCore.h>
 
+@interface MKDisplayLinkProxy : NSObject
+@property(nonatomic, weak) id target;
+@property(nonatomic, assign) SEL selector;
+@end
+
+@implementation MKDisplayLinkProxy
+- (instancetype)initWithTarget:(id)target selector:(SEL)selector {
+  if (self = [super init]) {
+    _target = target;
+    _selector = selector;
+  }
+  return self;
+}
+- (void)tick:(CADisplayLink *)displayLink {
+  if (_target) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+    [_target performSelector:_selector withObject:displayLink];
+#pragma clang diagnostic pop
+  } else {
+    [displayLink invalidate];
+  }
+}
+@end
+
 @implementation MKPolylineAnimator {
   MKPolyline *_polyline;
   CADisplayLink *_displayLink;
-  CGFloat _animationProgress; // 0→1 grow, 1→2 shrink
+  MKDisplayLinkProxy *_displayLinkProxy;
+  CGFloat _animationProgress;
+  CGFloat _delayRemaining;
+  NSArray<NSNumber *> *_cumulativeDistances;
+  CGFloat _totalLength;
+  CGColorSpaceRef _colorSpace;
+  RGBAComponents *_colorCache;
+  NSUInteger _colorCacheCount;
 }
 
 - (id)initWithPolyline:(MKPolyline *)polyline {
@@ -12,13 +44,28 @@
   if (self) {
     _polyline = polyline;
     _animationProgress = 0;
+    _animatedOptions = [PolylineAnimatedOptions defaultOptions];
+    _colorSpace = CGColorSpaceCreateDeviceRGB();
     [self createPath];
   }
   return self;
 }
 
+- (void)setAnimatedOptions:(PolylineAnimatedOptions *)animatedOptions {
+  _animatedOptions = animatedOptions ?: [PolylineAnimatedOptions defaultOptions];
+  if (_animated && _displayLink) {
+    [self stopAnimation];
+    [self startAnimation];
+  }
+}
+
 - (void)dealloc {
   [self stopAnimation];
+  free(_colorCache);
+  if (_colorSpace) {
+    CGColorSpaceRelease(_colorSpace);
+    _colorSpace = NULL;
+  }
 }
 
 - (void)setAnimated:(BOOL)animated {
@@ -38,24 +85,91 @@
   if (_displayLink) {
     return;
   }
+  [self computeCumulativeDistances];
   _animationProgress = 0;
-  _displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(animationTick:)];
+  _delayRemaining = _animatedOptions.delay / 1000.0;
+  _displayLinkProxy = [[MKDisplayLinkProxy alloc] initWithTarget:self selector:@selector(animationTick:)];
+  _displayLink = [CADisplayLink displayLinkWithTarget:_displayLinkProxy selector:@selector(tick:)];
   [_displayLink addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
 }
 
+- (void)computeCumulativeDistances {
+  NSMutableArray<NSNumber *> *distances = [NSMutableArray array];
+  CGFloat total = 0;
+  [distances addObject:@(0)];
+
+  for (NSUInteger i = 1; i < _polyline.pointCount; i++) {
+    MKMapPoint p1 = _polyline.points[i - 1];
+    MKMapPoint p2 = _polyline.points[i];
+    total += MKMetersBetweenMapPoints(p1, p2);
+    [distances addObject:@(total)];
+  }
+
+  _cumulativeDistances = [distances copy];
+  _totalLength = total;
+}
+
 - (void)stopAnimation {
   [_displayLink invalidate];
   _displayLink = nil;
+  _displayLinkProxy = nil;
+}
+
+- (void)pause {
+  _displayLink.paused = YES;
+}
+
+- (void)resume {
+  _displayLink.paused = NO;
+}
+
+- (NSUInteger)indexForDistance:(CGFloat)distance {
+  NSUInteger left = 0;
+  NSUInteger right = _cumulativeDistances.count - 1;
+
+  while (left < right) {
+    NSUInteger mid = (left + right + 1) / 2;
+    if (_cumulativeDistances[mid].doubleValue <= distance) {
+      left = mid;
+    } else {
+      right = mid - 1;
+    }
+  }
+
+  return MIN(left, _cumulativeDistances.count - 2);
+}
+
+- (CGFloat)applyEasing:(CGFloat)t {
+  NSString *easing = _animatedOptions.easing ?: @"linear";
+
+  if ([easing isEqualToString:@"easeIn"]) {
+    return t * t;
+  } else if ([easing isEqualToString:@"easeOut"]) {
+    return t * (2 - t);
+  } else if ([easing isEqualToString:@"easeInOut"]) {
+    return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+  }
+  return t;
 }
 
 - (void)animationTick:(CADisplayLink *)displayLink {
-  // ~1.75s per phase (grow or shrink), matching JS duration
-  CGFloat speed = displayLink.duration / 1.75;
+  if (_delayRemaining > 0) {
+    _delayRemaining -= displayLink.duration;
+    return;
+  }
+
+  CGFloat duration = _animatedOptions.duration / 1000.0;
+  if (duration <= 0) duration = 2.15;
+
+  CGFloat trailLength = MAX(0.01, MIN(1.0, _animatedOptions.trailLength));
+  CGFloat maxProgress = (trailLength < 1.0) ? 1.0 : 2.15;
+
+  CGFloat speed = displayLink.duration / duration;
   _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)
+  if (_animationProgress >= maxProgress) {
     _animationProgress = 0;
+    _delayRemaining = _animatedOptions.delay / 1000.0;
   }
 
   MKMapRect bounds = _polyline.boundingMapRect;
@@ -67,6 +181,9 @@
   _polyline = polyline;
   [self invalidatePath];
   [self createPath];
+  if (_animated) {
+    [self computeCumulativeDistances];
+  }
   [self setNeedsDisplay];
 }
 
@@ -85,34 +202,60 @@
   self.path = path;
 }
 
-- (UIColor *)colorAtGradientPosition:(CGFloat)position {
-  if (!_strokeColors || _strokeColors.count == 0) {
-    return self.strokeColor;
+- (void)setStrokeColors:(NSArray<UIColor *> *)strokeColors {
+  _strokeColors = strokeColors;
+  [self rebuildColorCache];
+}
+
+- (void)rebuildColorCache {
+  free(_colorCache);
+  _colorCache = NULL;
+  _colorCacheCount = _strokeColors.count;
+  if (_colorCacheCount == 0) return;
+
+  _colorCache = (RGBAComponents *)malloc(sizeof(RGBAComponents) * _colorCacheCount);
+  for (NSUInteger i = 0; i < _colorCacheCount; i++) {
+    [_strokeColors[i] getRed:&_colorCache[i].r
+                       green:&_colorCache[i].g
+                        blue:&_colorCache[i].b
+                       alpha:&_colorCache[i].a];
   }
-  if (_strokeColors.count == 1) {
-    return _strokeColors[0];
+}
+
+- (void)colorAtGradientPosition:(CGFloat)position rgba:(RGBAComponents *)out {
+  if (_colorCacheCount == 0) {
+    CGFloat r, g, b, a;
+    [self.strokeColor getRed:&r green:&g blue:&b alpha:&a];
+    *out = (RGBAComponents){r, g, b, a};
+    return;
+  }
+  if (_colorCacheCount == 1) {
+    *out = _colorCache[0];
+    return;
   }
 
   position = MAX(0, MIN(1, position));
-  CGFloat scaledPos = position * (_strokeColors.count - 1);
-  NSUInteger index = (NSUInteger)floor(scaledPos);
+  CGFloat scaledPos = position * (_colorCacheCount - 1);
+  NSUInteger index = (NSUInteger)scaledPos;
   CGFloat t = scaledPos - index;
 
-  if (index >= _strokeColors.count - 1) {
-    return _strokeColors.lastObject;
+  if (index >= _colorCacheCount - 1) {
+    *out = _colorCache[_colorCacheCount - 1];
+    return;
   }
 
-  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];
+  RGBAComponents c1 = _colorCache[index];
+  RGBAComponents c2 = _colorCache[index + 1];
+  out->r = c1.r + (c2.r - c1.r) * t;
+  out->g = c1.g + (c2.g - c1.g) * t;
+  out->b = c1.b + (c2.b - c1.b) * t;
+  out->a = c1.a + (c2.a - c1.a) * t;
+}
 
-  return [UIColor colorWithRed:r1 + (r2 - r1) * t
-                         green:g1 + (g2 - g1) * t
-                          blue:b1 + (b2 - b1) * t
-                         alpha:a1 + (a2 - a1) * t];
+- (UIColor *)colorAtGradientPosition:(CGFloat)position {
+  RGBAComponents rgba;
+  [self colorAtGradientPosition:position rgba:&rgba];
+  return [UIColor colorWithRed:rgba.r green:rgba.g blue:rgba.b alpha:rgba.a];
 }
 
 - (void)drawMapRect:(MKMapRect)mapRect
@@ -135,65 +278,77 @@
   }
 
   // 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;
+  if (_animated && _polyline.pointCount > 1 && _totalLength > 0) {
+    CGFloat trailLength = MAX(0.01, MIN(1.0, _animatedOptions.trailLength));
+    CGFloat maxProgress = (trailLength < 1.0) ? 1.0 : 2.0;
+    CGFloat progress = MIN(_animationProgress, maxProgress);
+    CGFloat easedProgress = [self applyEasing:progress / maxProgress] * maxProgress;
+
+    CGFloat headDist, tailDist;
+
+    if (trailLength < 1.0) {
+      headDist = easedProgress * _totalLength;
+      tailDist = MAX(0, headDist - _totalLength * trailLength);
+    } else if (easedProgress <= 1.0) {
+      tailDist = 0;
+      headDist = easedProgress * _totalLength;
     } else {
-      // Phase 2: shrink from start
-      CGFloat shrinkProgress = progress - 1.0;
-      tailPos = shrinkProgress * segmentCount;
-      headPos = segmentCount;
+      CGFloat shrinkProgress = easedProgress - 1.0;
+      tailDist = shrinkProgress * _totalLength;
+      headDist = _totalLength;
     }
 
-    if (headPos <= tailPos) {
+    if (headDist <= tailDist) {
       return;
     }
 
-    NSUInteger startIndex = (NSUInteger)floor(tailPos);
-    NSUInteger endIndex = (NSUInteger)ceil(headPos);
-    CGFloat visibleLength = headPos - tailPos;
+    CGFloat visibleLength = headDist - tailDist;
+    NSUInteger startIndex = [self indexForDistance:tailDist];
+    NSUInteger endIndex = [self indexForDistance:headDist];
+
+    for (NSUInteger i = startIndex; i <= endIndex && i < segmentCount; i++) {
+      CGFloat segStartDist = _cumulativeDistances[i].doubleValue;
+      CGFloat segEndDist = _cumulativeDistances[i + 1].doubleValue;
+
+      if (segEndDist <= tailDist || segStartDist >= headDist) {
+        continue;
+      }
 
-    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);
+      CGFloat drawStartDist = segStartDist;
+      CGFloat drawEndDist = segEndDist;
+      CGFloat segLength = segEndDist - segStartDist;
 
-      // Interpolate tail (partial segment at start)
-      if (segStartPos < tailPos) {
-        CGFloat t = tailPos - segStartPos;
+      if (segStartDist < tailDist && segLength > 0) {
+        CGFloat t = (tailDist - segStartDist) / segLength;
         drawStart.x = segStart.x + (segEnd.x - segStart.x) * t;
         drawStart.y = segStart.y + (segEnd.y - segStart.y) * t;
-        segStartPos = tailPos;
+        drawStartDist = tailDist;
       }
 
-      // Interpolate head (partial segment at end)
-      if (segEndPos > headPos) {
-        CGFloat t = headPos - (CGFloat)i;
+      if (segEndDist > headDist && segLength > 0) {
+        CGFloat t = (headDist - segStartDist) / segLength;
         drawEnd.x = segStart.x + (segEnd.x - segStart.x) * t;
         drawEnd.y = segStart.y + (segEnd.y - segStart.y) * t;
-        segEndPos = headPos;
+        drawEndDist = headDist;
       }
 
-      // Calculate gradient position (0-1) within visible portion
-      CGFloat gradientStart = (segStartPos - tailPos) / visibleLength;
-      CGFloat gradientEnd = (segEndPos - tailPos) / visibleLength;
+      CGFloat gradientStart = (drawStartDist - tailDist) / visibleLength;
+      CGFloat gradientEnd = (drawEndDist - tailDist) / visibleLength;
 
-      UIColor *startColor = [self colorAtGradientPosition:gradientStart];
-      UIColor *endColor = [self colorAtGradientPosition:gradientEnd];
+      RGBAComponents startRGBA, endRGBA;
+      [self colorAtGradientPosition:gradientStart rgba:&startRGBA];
+      [self colorAtGradientPosition:gradientEnd rgba:&endRGBA];
 
-      // 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);
+      CGFloat components[] = {
+        startRGBA.r, startRGBA.g, startRGBA.b, startRGBA.a,
+        endRGBA.r, endRGBA.g, endRGBA.b, endRGBA.a
+      };
+      CGGradientRef gradient = CGGradientCreateWithColorComponents(_colorSpace, components, NULL, 2);
 
       CGContextSaveGState(context);
       CGContextBeginPath(context);
@@ -206,7 +361,6 @@
 
       CGContextRestoreGState(context);
       CGGradientRelease(gradient);
-      CGColorSpaceRelease(colorSpace);
     }
     return;
   }
@@ -220,12 +374,15 @@
       CGFloat gradientStart = (CGFloat)i / segmentCount;
       CGFloat gradientEnd = (CGFloat)(i + 1) / segmentCount;
 
-      UIColor *startColor = [self colorAtGradientPosition:gradientStart];
-      UIColor *endColor = [self colorAtGradientPosition:gradientEnd];
+      RGBAComponents startRGBA, endRGBA;
+      [self colorAtGradientPosition:gradientStart rgba:&startRGBA];
+      [self colorAtGradientPosition:gradientEnd rgba:&endRGBA];
 
-      CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
-      NSArray *colors = @[(__bridge id)startColor.CGColor, (__bridge id)endColor.CGColor];
-      CGGradientRef gradient = CGGradientCreateWithColors(colorSpace, (__bridge CFArrayRef)colors, NULL);
+      CGFloat components[] = {
+        startRGBA.r, startRGBA.g, startRGBA.b, startRGBA.a,
+        endRGBA.r, endRGBA.g, endRGBA.b, endRGBA.a
+      };
+      CGGradientRef gradient = CGGradientCreateWithColorComponents(_colorSpace, components, NULL, 2);
 
       CGContextSaveGState(context);
       CGContextBeginPath(context);
@@ -238,7 +395,6 @@
 
       CGContextRestoreGState(context);
       CGGradientRelease(gradient);
-      CGColorSpaceRelease(colorSpace);
     }
     return;
   }

package/ios/core/MapProviderDelegate.h

@@ -0,0 +1,72 @@
+#import <CoreLocation/CoreLocation.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class LuggMarkerView;
+@class LuggPolylineView;
+
+@protocol MapProviderDelegate <NSObject>
+- (void)mapProviderDidReady;
+- (void)mapProviderDidMoveCamera:(double)latitude
+                       longitude:(double)longitude
+                            zoom:(double)zoom
+                         gesture:(BOOL)gesture;
+- (void)mapProviderDidIdleCamera:(double)latitude
+                       longitude:(double)longitude
+                            zoom:(double)zoom
+                         gesture:(BOOL)gesture;
+@end
+
+@protocol MapProvider <NSObject>
+
+@property(nonatomic, weak, nullable) id<MapProviderDelegate> delegate;
+@property(nonatomic, readonly) BOOL isMapReady;
+
+- (void)initializeMapInView:(UIView *)wrapperView
+          initialCoordinate:(CLLocationCoordinate2D)coordinate
+                initialZoom:(double)zoom;
+- (void)destroy;
+
+// Props
+- (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)setMinZoom:(double)minZoom;
+- (void)setMaxZoom:(double)maxZoom;
+- (void)setEdgeInsets:(UIEdgeInsets)edgeInsets
+        oldEdgeInsets:(UIEdgeInsets)oldEdgeInsets;
+- (void)setEdgeInsets:(UIEdgeInsets)edgeInsets
+        oldEdgeInsets:(UIEdgeInsets)oldEdgeInsets
+             duration:(double)duration;
+
+// Children
+- (void)addMarkerView:(LuggMarkerView *)markerView;
+- (void)removeMarkerView:(LuggMarkerView *)markerView;
+- (void)syncMarkerView:(LuggMarkerView *)markerView;
+- (void)addPolylineView:(LuggPolylineView *)polylineView;
+- (void)removePolylineView:(LuggPolylineView *)polylineView;
+- (void)syncPolylineView:(LuggPolylineView *)polylineView;
+
+// Lifecycle
+- (void)pauseAnimations;
+- (void)resumeAnimations;
+
+// Commands
+- (void)moveCamera:(double)latitude
+         longitude:(double)longitude
+              zoom:(double)zoom
+          duration:(double)duration;
+- (void)fitCoordinates:(NSArray *)coordinates
+         edgeInsetsTop:(double)edgeInsetsTop
+        edgeInsetsLeft:(double)edgeInsetsLeft
+      edgeInsetsBottom:(double)edgeInsetsBottom
+       edgeInsetsRight:(double)edgeInsetsRight
+              duration:(double)duration;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/core/PolylineAnimatorBase.h

@@ -2,21 +2,44 @@
 #import <Foundation/Foundation.h>
 #import <UIKit/UIKit.h>
 
+@interface PolylineAnimatedOptions : NSObject
+
+@property(nonatomic, assign) NSTimeInterval duration;
+@property(nonatomic, copy) NSString *easing;
+@property(nonatomic, assign) CGFloat trailLength;
+@property(nonatomic, assign) NSTimeInterval delay;
+
++ (instancetype)defaultOptions;
+
+@end
+
 @protocol PolylineAnimator <NSObject>
 
 @property(nonatomic, strong) NSArray<CLLocation *> *coordinates;
 @property(nonatomic, strong) NSArray<UIColor *> *strokeColors;
 @property(nonatomic, assign) BOOL animated;
+@property(nonatomic, strong) PolylineAnimatedOptions *animatedOptions;
 
 - (void)update;
 
 @end
 
-@interface PolylineAnimatorBase : NSObject
+typedef struct {
+  CGFloat r, g, b, a;
+} RGBAComponents;
+
+@interface PolylineAnimatorBase : NSObject {
+@protected
+  RGBAComponents *_colorCache;
+  NSUInteger _colorCacheCount;
+}
 
 @property(nonatomic, strong) NSArray<CLLocation *> *coordinates;
 @property(nonatomic, strong) NSArray<UIColor *> *strokeColors;
+@property(nonatomic, strong) PolylineAnimatedOptions *animatedOptions;
 
 - (UIColor *)colorAtGradientPosition:(CGFloat)position;
+- (void)colorAtGradientPosition:(CGFloat)position rgba:(RGBAComponents *)out;
+- (CGFloat)applyEasing:(CGFloat)t;
 
 @end

package/ios/core/PolylineAnimatorBase.m

@@ -1,35 +1,98 @@
 #import "PolylineAnimatorBase.h"
 
+@implementation PolylineAnimatedOptions
+
++ (instancetype)defaultOptions {
+  PolylineAnimatedOptions *options = [[PolylineAnimatedOptions alloc] init];
+  options.duration = 2.15;
+  options.easing = @"linear";
+  options.trailLength = 1.0;
+  options.delay = 0;
+  return options;
+}
+
+@end
+
 @implementation PolylineAnimatorBase
 
-- (UIColor *)colorAtGradientPosition:(CGFloat)position {
-  if (!_strokeColors || _strokeColors.count == 0) {
-    return [UIColor blackColor];
+- (instancetype)init {
+  if (self = [super init]) {
+    _animatedOptions = [PolylineAnimatedOptions defaultOptions];
+    _colorCache = NULL;
+    _colorCacheCount = 0;
+  }
+  return self;
+}
+
+- (void)dealloc {
+  free(_colorCache);
+}
+
+- (void)setStrokeColors:(NSArray<UIColor *> *)strokeColors {
+  _strokeColors = strokeColors;
+  [self rebuildColorCache];
+}
+
+- (void)rebuildColorCache {
+  free(_colorCache);
+  _colorCache = NULL;
+  _colorCacheCount = _strokeColors.count;
+  if (_colorCacheCount == 0) return;
+
+  _colorCache = (RGBAComponents *)malloc(sizeof(RGBAComponents) * _colorCacheCount);
+  for (NSUInteger i = 0; i < _colorCacheCount; i++) {
+    [_strokeColors[i] getRed:&_colorCache[i].r
+                       green:&_colorCache[i].g
+                        blue:&_colorCache[i].b
+                       alpha:&_colorCache[i].a];
+  }
+}
+
+- (CGFloat)applyEasing:(CGFloat)t {
+  NSString *easing = self.animatedOptions.easing ?: @"linear";
+
+  if ([easing isEqualToString:@"easeIn"]) {
+    return t * t;
+  } else if ([easing isEqualToString:@"easeOut"]) {
+    return t * (2 - t);
+  } else if ([easing isEqualToString:@"easeInOut"]) {
+    return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
   }
-  if (_strokeColors.count == 1) {
-    return _strokeColors[0];
+  return t;
+}
+
+- (void)colorAtGradientPosition:(CGFloat)position rgba:(RGBAComponents *)out {
+  if (_colorCacheCount == 0) {
+    *out = (RGBAComponents){0, 0, 0, 1};
+    return;
+  }
+  if (_colorCacheCount == 1) {
+    *out = _colorCache[0];
+    return;
   }
 
   position = MAX(0, MIN(1, position));
-  CGFloat scaledPos = position * (_strokeColors.count - 1);
-  NSUInteger index = (NSUInteger)floor(scaledPos);
+  CGFloat scaledPos = position * (_colorCacheCount - 1);
+  NSUInteger index = (NSUInteger)scaledPos;
   CGFloat t = scaledPos - index;
 
-  if (index >= _strokeColors.count - 1) {
-    return _strokeColors.lastObject;
+  if (index >= _colorCacheCount - 1) {
+    *out = _colorCache[_colorCacheCount - 1];
+    return;
   }
 
-  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];
+  RGBAComponents c1 = _colorCache[index];
+  RGBAComponents c2 = _colorCache[index + 1];
+  out->r = c1.r + (c2.r - c1.r) * t;
+  out->g = c1.g + (c2.g - c1.g) * t;
+  out->b = c1.b + (c2.b - c1.b) * t;
+  out->a = c1.a + (c2.a - c1.a) * t;
+}
 
-  return [UIColor colorWithRed:r1 + (r2 - r1) * t
-                         green:g1 + (g2 - g1) * t
-                          blue:b1 + (b2 - b1) * t
-                         alpha:a1 + (a2 - a1) * t];
+- (UIColor *)colorAtGradientPosition:(CGFloat)position {
+  RGBAComponents rgba;
+  [self colorAtGradientPosition:position rgba:&rgba];
+  return [UIColor colorWithRed:rgba.r green:rgba.g blue:rgba.b alpha:rgba.a];
 }
 
 @end

package/ios/extensions/MKMapView+Zoom.h

@@ -12,6 +12,8 @@ NS_ASSUME_NONNULL_BEGIN
                           (CLLocationCoordinate2D)centerCoordinate
                                       zoomLevel:(double)zoomLevel;
 
+/// Returns the zoom level based on the full map region, not affected by
+/// layoutMargins
 - (double)zoomLevel;
 
 @end