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

package/android/src/main/java/com/luggmaps/core/MapProviderDelegate.kt

@@ -0,0 +1,55 @@
+package com.luggmaps.core
+
+import android.view.View
+import com.luggmaps.LuggMarkerView
+import com.luggmaps.LuggPolylineView
+
+data class EdgeInsets(val top: Int = 0, val left: Int = 0, val bottom: Int = 0, val right: Int = 0)
+
+interface MapProviderDelegate {
+  fun mapProviderDidReady()
+  fun mapProviderDidMoveCamera(latitude: Double, longitude: Double, zoom: Float, gesture: Boolean)
+  fun mapProviderDidIdleCamera(latitude: Double, longitude: Double, zoom: Float, gesture: Boolean)
+}
+
+interface MapProvider {
+  var delegate: MapProviderDelegate?
+  val isMapReady: Boolean
+
+  fun initializeMap(wrapperView: View, latitude: Double, longitude: Double, zoom: Float)
+  fun destroy()
+
+  // Props
+  fun setZoomEnabled(enabled: Boolean)
+  fun setScrollEnabled(enabled: Boolean)
+  fun setRotateEnabled(enabled: Boolean)
+  fun setPitchEnabled(enabled: Boolean)
+  fun setUserLocationEnabled(enabled: Boolean)
+  fun setUserLocationButtonEnabled(enabled: Boolean)
+  fun setTheme(value: String)
+  fun setMinZoom(zoom: Double)
+  fun setMaxZoom(zoom: Double)
+  fun setEdgeInsets(edgeInsets: EdgeInsets)
+  fun setEdgeInsets(edgeInsets: EdgeInsets, duration: Int)
+
+  // Children
+  fun addMarkerView(markerView: LuggMarkerView)
+  fun removeMarkerView(markerView: LuggMarkerView)
+  fun addPolylineView(polylineView: LuggPolylineView)
+  fun removePolylineView(polylineView: LuggPolylineView)
+
+  // Lifecycle
+  fun pauseAnimations()
+  fun resumeAnimations()
+
+  // Commands
+  fun moveCamera(latitude: Double, longitude: Double, zoom: Double, duration: Int)
+  fun fitCoordinates(
+    coordinates: List<Any>,
+    edgeInsetsTop: Int,
+    edgeInsetsLeft: Int,
+    edgeInsetsBottom: Int,
+    edgeInsetsRight: Int,
+    duration: Int
+  )
+}

package/android/src/main/java/com/luggmaps/core/PolylineAnimator.kt

@@ -2,20 +2,39 @@ package com.luggmaps.core
 
 import android.animation.ValueAnimator
 import android.graphics.Color
+import android.location.Location
 import android.view.animation.LinearInterpolator
 import com.google.android.gms.maps.model.LatLng
 import com.google.android.gms.maps.model.Polyline
 import com.google.android.gms.maps.model.StrokeStyle
 import com.google.android.gms.maps.model.StyleSpan
+import com.luggmaps.AnimatedOptions
 import kotlin.math.floor
-import kotlin.math.max
 import kotlin.math.min
 
 class PolylineAnimator {
+  companion object {
+    private const val MAX_ANIMATION_SPANS = 16
+  }
+
   var polyline: Polyline? = null
   var coordinates: List<LatLng> = emptyList()
+    set(value) {
+      field = value
+      if (animated && animator != null) {
+        computeCumulativeDistances()
+      }
+    }
   var strokeColors: List<Int> = listOf(Color.BLACK)
   var strokeWidth: Float = 1f
+  var animatedOptions: AnimatedOptions = AnimatedOptions()
+    set(value) {
+      if (field == value) return
+      field = value
+      if (animated) {
+        restartAnimation()
+      }
+    }
 
   var animated: Boolean = false
     set(value) {
@@ -31,6 +50,25 @@ class PolylineAnimator {
 
   private var animator: ValueAnimator? = null
   private var animationProgress: Float = 0f
+  private var cumulativeDistances: FloatArray = floatArrayOf()
+  private var totalLength: Float = 0f
+
+  // Reusable collections to avoid per-frame allocations
+  private val reusablePoints = ArrayList<LatLng>()
+  private val reusableSpans = ArrayList<StyleSpan>()
+
+  private fun restartAnimation() {
+    stopAnimation()
+    startAnimation()
+  }
+
+  private fun applyEasing(t: Float): Float =
+    when (animatedOptions.easing) {
+      "easeIn" -> t * t
+      "easeOut" -> t * (2 - t)
+      "easeInOut" -> if (t < 0.5f) 2 * t * t else -1 + (4 - 2 * t) * t
+      else -> t
+    }
 
   fun update() {
     if (animated) return
@@ -50,8 +88,14 @@ class PolylineAnimator {
   private fun startAnimation() {
     if (animator != null) return
 
-    animator = ValueAnimator.ofFloat(0f, 2.15f).apply {
-      duration = 3650 // ~1.75s per phase * 2 + pause
+    computeCumulativeDistances()
+
+    val trailLength = animatedOptions.trailLength.coerceIn(0.01f, 1f)
+    val maxProgress = if (trailLength < 1f) 1f else 2.15f
+
+    animator = ValueAnimator.ofFloat(0f, maxProgress).apply {
+      duration = (animatedOptions.duration * maxProgress).toLong()
+      startDelay = animatedOptions.delay
       repeatCount = ValueAnimator.INFINITE
       interpolator = LinearInterpolator()
       addUpdateListener { animation ->
@@ -62,83 +106,150 @@ class PolylineAnimator {
     }
   }
 
+  private fun computeCumulativeDistances() {
+    if (coordinates.size < 2) {
+      cumulativeDistances = floatArrayOf(0f)
+      totalLength = 0f
+      return
+    }
+
+    val distances = FloatArray(coordinates.size)
+    distances[0] = 0f
+    var total = 0f
+
+    for (i in 1 until coordinates.size) {
+      val prev = coordinates[i - 1]
+      val curr = coordinates[i]
+      val results = FloatArray(1)
+      Location.distanceBetween(prev.latitude, prev.longitude, curr.latitude, curr.longitude, results)
+      total += results[0]
+      distances[i] = total
+    }
+
+    cumulativeDistances = distances
+    totalLength = total
+  }
+
+  private fun indexForDistance(distance: Float): Int {
+    var left = 0
+    var right = cumulativeDistances.size - 1
+
+    while (left < right) {
+      val mid = (left + right + 1) / 2
+      if (cumulativeDistances[mid] <= distance) {
+        left = mid
+      } else {
+        right = mid - 1
+      }
+    }
+
+    return left.coerceAtMost(cumulativeDistances.size - 2).coerceAtLeast(0)
+  }
+
+  private fun coordinateAtDistance(distance: Float): LatLng {
+    if (distance <= 0f) return coordinates.first()
+    if (distance >= totalLength) return coordinates.last()
+
+    val idx = indexForDistance(distance)
+    val segStart = cumulativeDistances[idx]
+    val segEnd = cumulativeDistances[idx + 1]
+    val segLength = segEnd - segStart
+
+    val t = if (segLength > 0) (distance - segStart) / segLength else 0f
+    val c1 = coordinates[idx]
+    val c2 = coordinates[idx + 1]
+
+    // Reuse existing coordinate if no interpolation needed
+    if (t == 0f) return c1
+
+    return LatLng(
+      c1.latitude + (c2.latitude - c1.latitude) * t,
+      c1.longitude + (c2.longitude - c1.longitude) * t
+    )
+  }
+
   private fun stopAnimation() {
     animator?.cancel()
     animator = null
   }
 
+  fun pause() {
+    animator?.pause()
+  }
+
+  fun resume() {
+    animator?.resume()
+  }
+
   private fun updateAnimatedPolyline() {
     val poly = polyline ?: return
-    if (coordinates.size < 2) {
+    if (coordinates.size < 2 || totalLength <= 0f) {
       poly.points = coordinates
       return
     }
 
-    val segmentCount = coordinates.size - 1
-    val progress = min(animationProgress, 2f)
+    val trailLength = animatedOptions.trailLength.coerceIn(0.01f, 1f)
+    val maxProgress = if (trailLength < 1f) 1f else 2f
+    val rawProgress = min(animationProgress, maxProgress)
+    val progress = applyEasing(rawProgress / maxProgress) * maxProgress
 
-    val headPos: Float
-    val tailPos: Float
+    val headDist: Float
+    val tailDist: Float
 
-    if (progress <= 1f) {
-      tailPos = 0f
-      headPos = progress * segmentCount
+    if (trailLength < 1f) {
+      headDist = progress * totalLength
+      tailDist = maxOf(0f, headDist - totalLength * trailLength)
+    } else if (progress <= 1f) {
+      tailDist = 0f
+      headDist = progress * totalLength
     } else {
       val shrinkProgress = progress - 1f
-      tailPos = shrinkProgress * segmentCount
-      headPos = segmentCount.toFloat()
+      tailDist = shrinkProgress * totalLength
+      headDist = totalLength
     }
 
-    if (headPos <= tailPos || coordinates.isEmpty()) {
-      poly.setSpans(emptyList())
+    if (headDist <= tailDist) {
       poly.points = listOf(coordinates.firstOrNull() ?: LatLng(0.0, 0.0))
+      poly.color = strokeColors.firstOrNull() ?: Color.BLACK
       return
     }
 
-    val startIndex = floor(tailPos).toInt()
-    val endIndex = kotlin.math.ceil(headPos.toDouble()).toInt()
-    val visibleLength = headPos - tailPos
+    val visibleLength = headDist - tailDist
+    val startIndex = indexForDistance(tailDist)
+    val endIndex = indexForDistance(headDist)
 
-    val points = mutableListOf<LatLng>()
-    val spans = mutableListOf<StyleSpan>()
+    reusablePoints.clear()
 
-    for (i in startIndex..minOf(endIndex, coordinates.size - 1)) {
-      var coord = coordinates[i]
+    reusablePoints.add(coordinateAtDistance(tailDist))
 
-      // Interpolate tail
-      if (i == startIndex && tailPos > startIndex.toFloat() && i + 1 < coordinates.size) {
-        val t = tailPos - startIndex
-        val next = coordinates[i + 1]
-        coord = LatLng(
-          coord.latitude + (next.latitude - coord.latitude) * t,
-          coord.longitude + (next.longitude - coord.longitude) * t
-        )
-      }
+    for (i in (startIndex + 1)..endIndex) {
+      reusablePoints.add(coordinates[i])
+    }
 
-      // Interpolate head
-      if (i == endIndex && headPos < endIndex.toFloat() && i > 0) {
-        val t = headPos - (endIndex - 1)
-        val prev = coordinates[i - 1]
-        coord = LatLng(
-          prev.latitude + (coordinates[i].latitude - prev.latitude) * t,
-          prev.longitude + (coordinates[i].longitude - prev.longitude) * t
-        )
-      }
+    val endCoord = coordinateAtDistance(headDist)
+    val lastAdded = reusablePoints.lastOrNull()
+    if (lastAdded == null || endCoord.latitude != lastAdded.latitude || endCoord.longitude != lastAdded.longitude) {
+      reusablePoints.add(endCoord)
+    }
 
-      points.add(coord)
+    if (reusablePoints.size < 2) return
 
-      if (i < endIndex && i < segmentCount) {
-        val segStartPos = max(i.toFloat(), tailPos)
-        val segEndPos = min((i + 1).toFloat(), headPos)
-        val gradientMid = ((segStartPos + segEndPos) / 2f - tailPos) / visibleLength
-        val color = colorAtGradientPosition(gradientMid)
-        spans.add(StyleSpan(StrokeStyle.colorBuilder(color).build()))
-      }
-    }
+    poly.points = ArrayList(reusablePoints)
 
-    poly.points = points
-    if (spans.isNotEmpty()) {
-      poly.setSpans(spans)
+    if (strokeColors.size <= 1) {
+      poly.color = strokeColors.firstOrNull() ?: Color.BLACK
+    } else {
+      val segmentCount = reusablePoints.size - 1
+      val spanCount = min(segmentCount, MAX_ANIMATION_SPANS)
+      val segmentsPerSpan = segmentCount.toDouble() / spanCount
+
+      reusableSpans.clear()
+      for (i in 0 until spanCount) {
+        val gradientPos = (i + 0.5f) / spanCount
+        val color = colorAtGradientPosition(gradientPos)
+        reusableSpans.add(StyleSpan(StrokeStyle.colorBuilder(color).build(), segmentsPerSpan))
+      }
+      poly.setSpans(reusableSpans)
     }
   }
 

package/ios/LuggMapView.h

@@ -0,0 +1,9 @@
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface LuggMapView : RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/LuggMapView.mm

@@ -0,0 +1,312 @@
+#import "LuggMapView.h"
+#import "LuggMapWrapperView.h"
+#import "LuggMarkerView.h"
+#import "LuggPolylineView.h"
+#import "core/AppleMapProvider.h"
+#import "core/GoogleMapProvider.h"
+#import "core/MapProviderDelegate.h"
+#import "events/CameraIdleEvent.h"
+#import "events/CameraMoveEvent.h"
+#import "events/ReadyEvent.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 LuggMapView () <RCTLuggMapViewViewProtocol, MapProviderDelegate>
+@end
+
+@implementation LuggMapView {
+  id<MapProvider> _provider;
+  LuggMapWrapperView *_mapWrapperView;
+  LuggMapViewProvider _providerType;
+  NSString *_mapId;
+  BOOL _initialized;
+  // Cached props to apply after content creation
+  BOOL _zoomEnabled;
+  BOOL _scrollEnabled;
+  BOOL _rotateEnabled;
+  BOOL _pitchEnabled;
+  BOOL _userLocationEnabled;
+  LuggMapViewTheme _theme;
+  double _minZoom;
+  double _maxZoom;
+  UIEdgeInsets _edgeInsets;
+  UIEdgeInsets _oldEdgeInsets;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<LuggMapViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const LuggMapViewProps>();
+    _props = defaultProps;
+
+    _initialized = NO;
+    _mapId = @"";
+    _providerType = LuggMapViewProvider::Google;
+    _zoomEnabled = YES;
+    _scrollEnabled = YES;
+    _rotateEnabled = YES;
+    _pitchEnabled = YES;
+    _userLocationEnabled = NO;
+    _theme = LuggMapViewTheme::System;
+    _edgeInsets = UIEdgeInsetsZero;
+  }
+  return self;
+}
+
+#pragma mark - View Lifecycle
+
+- (void)mountChildComponentView:
+            (UIView<RCTComponentViewProtocol> *)childComponentView
+                          index:(NSInteger)index {
+  [super mountChildComponentView:childComponentView index:index];
+
+  if ([childComponentView isKindOfClass:[LuggMapWrapperView class]]) {
+    _mapWrapperView = (LuggMapWrapperView *)childComponentView;
+  } else if ([childComponentView isKindOfClass:[LuggMarkerView class]]) {
+    LuggMarkerView *markerView = (LuggMarkerView *)childComponentView;
+    if (_provider) {
+      [_provider addMarkerView:markerView];
+    }
+  } else if ([childComponentView isKindOfClass:[LuggPolylineView class]]) {
+    LuggPolylineView *polylineView = (LuggPolylineView *)childComponentView;
+    if (_provider) {
+      [_provider addPolylineView:polylineView];
+    }
+  }
+}
+
+- (void)unmountChildComponentView:
+            (UIView<RCTComponentViewProtocol> *)childComponentView
+                            index:(NSInteger)index {
+  if ([childComponentView isKindOfClass:[LuggMarkerView class]]) {
+    LuggMarkerView *markerView = (LuggMarkerView *)childComponentView;
+    if (_provider) {
+      [_provider removeMarkerView:markerView];
+    }
+  } else if ([childComponentView isKindOfClass:[LuggPolylineView class]]) {
+    LuggPolylineView *polylineView = (LuggPolylineView *)childComponentView;
+    if (_provider) {
+      [_provider removePolylineView:polylineView];
+    }
+  }
+
+  [super unmountChildComponentView:childComponentView index:index];
+}
+
+- (void)didMoveToWindow {
+  [super didMoveToWindow];
+  if (self.window) {
+    if (!_provider && _mapWrapperView) {
+      [self initializeProvider];
+    }
+    [_provider resumeAnimations];
+  } else {
+    [_provider pauseAnimations];
+  }
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+
+  [_provider destroy];
+  _provider = nil;
+  _mapWrapperView = nil;
+  _initialized = NO;
+}
+
+#pragma mark - Provider Initialization
+
+- (void)initializeProvider {
+  if (_provider || !_mapWrapperView)
+    return;
+
+  const auto &viewProps =
+      *std::static_pointer_cast<LuggMapViewProps const>(_props);
+
+  if (_providerType == LuggMapViewProvider::Apple) {
+    _provider = [[AppleMapProvider alloc] init];
+  } else {
+    GoogleMapProvider *google = [[GoogleMapProvider alloc] init];
+    google.mapId = _mapId;
+    _provider = google;
+  }
+
+  _provider.delegate = self;
+
+  CLLocationCoordinate2D coordinate =
+      CLLocationCoordinate2DMake(viewProps.initialCoordinate.latitude,
+                                 viewProps.initialCoordinate.longitude);
+
+  [_provider initializeMapInView:_mapWrapperView
+               initialCoordinate:coordinate
+                     initialZoom:viewProps.initialZoom];
+
+  // Apply cached props after map view is created
+  [self applyProps];
+  [_provider setEdgeInsets:_edgeInsets oldEdgeInsets:UIEdgeInsetsZero];
+
+  _initialized = YES;
+
+  // Flush any children that were mounted before content was created
+  for (UIView *subview in self.subviews) {
+    if ([subview isKindOfClass:[LuggMarkerView class]]) {
+      [_provider addMarkerView:(LuggMarkerView *)subview];
+    } else if ([subview isKindOfClass:[LuggPolylineView class]]) {
+      [_provider addPolylineView:(LuggPolylineView *)subview];
+    }
+  }
+}
+
+#pragma mark - MapProviderDelegate
+
+- (void)mapProviderDidReady {
+  ReadyEvent::emit<LuggMapViewEventEmitter>(_eventEmitter);
+}
+
+- (void)mapProviderDidMoveCamera:(double)latitude
+                       longitude:(double)longitude
+                            zoom:(double)zoom
+                         gesture:(BOOL)gesture {
+  CameraMoveEvent{latitude, longitude, zoom, static_cast<bool>(gesture)}
+      .emit<LuggMapViewEventEmitter>(_eventEmitter);
+}
+
+- (void)mapProviderDidIdleCamera:(double)latitude
+                       longitude:(double)longitude
+                            zoom:(double)zoom
+                         gesture:(BOOL)gesture {
+  CameraIdleEvent{latitude, longitude, zoom, static_cast<bool>(gesture)}
+      .emit<LuggMapViewEventEmitter>(_eventEmitter);
+}
+
+#pragma mark - Property Setters
+
+- (void)applyProps {
+  [_provider setZoomEnabled:_zoomEnabled];
+  [_provider setScrollEnabled:_scrollEnabled];
+  [_provider setRotateEnabled:_rotateEnabled];
+  [_provider setPitchEnabled:_pitchEnabled];
+  [_provider setUserLocationEnabled:_userLocationEnabled];
+  [_provider setTheme:(NSInteger)_theme];
+  [_provider setMinZoom:_minZoom];
+  [_provider setMaxZoom:_maxZoom];
+}
+
+- (void)updateProps:(Props::Shared const &)props
+           oldProps:(Props::Shared const &)oldProps {
+  const auto &newViewProps =
+      *std::static_pointer_cast<LuggMapViewProps const>(props);
+  const auto &prevViewProps =
+      *std::static_pointer_cast<LuggMapViewProps const>(_props);
+
+  _providerType = newViewProps.provider;
+
+  NSString *newMapId =
+      [NSString stringWithUTF8String:newViewProps.mapId.c_str()];
+  if (newMapId.length > 0) {
+    _mapId = newMapId;
+  }
+
+  if (newViewProps.zoomEnabled != prevViewProps.zoomEnabled) {
+    _zoomEnabled = newViewProps.zoomEnabled;
+    [_provider setZoomEnabled:_zoomEnabled];
+  }
+  if (newViewProps.scrollEnabled != prevViewProps.scrollEnabled) {
+    _scrollEnabled = newViewProps.scrollEnabled;
+    [_provider setScrollEnabled:_scrollEnabled];
+  }
+  if (newViewProps.rotateEnabled != prevViewProps.rotateEnabled) {
+    _rotateEnabled = newViewProps.rotateEnabled;
+    [_provider setRotateEnabled:_rotateEnabled];
+  }
+  if (newViewProps.pitchEnabled != prevViewProps.pitchEnabled) {
+    _pitchEnabled = newViewProps.pitchEnabled;
+    [_provider setPitchEnabled:_pitchEnabled];
+  }
+  if (newViewProps.userLocationEnabled != prevViewProps.userLocationEnabled) {
+    _userLocationEnabled = newViewProps.userLocationEnabled;
+    [_provider setUserLocationEnabled:_userLocationEnabled];
+  }
+  if (newViewProps.minZoom != prevViewProps.minZoom) {
+    _minZoom = newViewProps.minZoom;
+    [_provider setMinZoom:_minZoom];
+  }
+  if (newViewProps.maxZoom != prevViewProps.maxZoom) {
+    _maxZoom = newViewProps.maxZoom;
+    [_provider setMaxZoom:_maxZoom];
+  }
+  if (newViewProps.theme != prevViewProps.theme) {
+    _theme = newViewProps.theme;
+    [_provider setTheme:(NSInteger)_theme];
+  }
+
+  UIEdgeInsets newEdgeInsets = UIEdgeInsetsMake(
+      newViewProps.edgeInsets.top, newViewProps.edgeInsets.left,
+      newViewProps.edgeInsets.bottom, newViewProps.edgeInsets.right);
+  if (!UIEdgeInsetsEqualToEdgeInsets(newEdgeInsets, _edgeInsets)) {
+    _oldEdgeInsets = _edgeInsets;
+    _edgeInsets = newEdgeInsets;
+    [_provider setEdgeInsets:_edgeInsets oldEdgeInsets:_oldEdgeInsets];
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+#pragma mark - Commands
+
+- (void)moveCamera:(double)latitude
+         longitude:(double)longitude
+              zoom:(double)zoom
+          duration:(double)duration {
+  [_provider moveCamera:latitude
+              longitude:longitude
+                   zoom:zoom
+               duration:duration];
+}
+
+- (void)fitCoordinates:(NSArray *)coordinates
+         edgeInsetsTop:(double)edgeInsetsTop
+        edgeInsetsLeft:(double)edgeInsetsLeft
+      edgeInsetsBottom:(double)edgeInsetsBottom
+       edgeInsetsRight:(double)edgeInsetsRight
+              duration:(double)duration {
+  [_provider fitCoordinates:coordinates
+              edgeInsetsTop:edgeInsetsTop
+             edgeInsetsLeft:edgeInsetsLeft
+           edgeInsetsBottom:edgeInsetsBottom
+            edgeInsetsRight:edgeInsetsRight
+                   duration:duration];
+}
+
+- (void)setEdgeInsets:(double)top
+                 left:(double)left
+               bottom:(double)bottom
+                right:(double)right
+             duration:(double)duration {
+  UIEdgeInsets oldInsets = _edgeInsets;
+  _edgeInsets = UIEdgeInsetsMake(top, left, bottom, right);
+  [_provider setEdgeInsets:_edgeInsets
+             oldEdgeInsets:oldInsets
+                  duration:duration];
+}
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args {
+  RCTLuggMapViewHandleCommand(self, commandName, args);
+}
+
+Class<RCTComponentViewProtocol> LuggMapViewCls(void) {
+  return LuggMapView.class;
+}
+
+@end

package/ios/LuggMarkerView.h

@@ -14,16 +14,25 @@ NS_ASSUME_NONNULL_BEGIN
 
 @interface LuggMarkerView : RCTViewComponentView
 
+@property(nonatomic, readonly, nullable) NSString *name;
 @property(nonatomic, readonly) CLLocationCoordinate2D coordinate;
 @property(nonatomic, readonly, nullable) NSString *title;
 @property(nonatomic, readonly, nullable) NSString *markerDescription;
 @property(nonatomic, readonly) CGPoint anchor;
+@property(nonatomic, readonly) NSInteger zIndex;
+@property(nonatomic, readonly) CLLocationDegrees rotate;
+@property(nonatomic, readonly) CGFloat scale;
+@property(nonatomic, readonly) BOOL rasterize;
 @property(nonatomic, readonly) BOOL hasCustomView;
 @property(nonatomic, readonly) BOOL didLayout;
 @property(nonatomic, readonly) UIView *iconView;
 @property(nonatomic, weak, nullable) id<LuggMarkerViewDelegate> delegate;
 @property(nonatomic, strong, nullable) NSObject *marker;
 
+- (nullable UIImage *)createIconImage;
+- (nullable UIImage *)createScaledIconImage;
+- (void)resetIconViewTransform;
+
 @end
 
 NS_ASSUME_NONNULL_END