@lugg/maps 0.2.0-alpha.0 → 0.2.0-alpha.10

package/android/src/main/java/com/luggmaps/{LuggMapsMarkerViewManager.kt → LuggMarkerViewManager.kt}

@@ -7,31 +7,31 @@ import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.ViewGroupManager
 import com.facebook.react.uimanager.ViewManagerDelegate
 import com.facebook.react.uimanager.annotations.ReactProp
-import com.facebook.react.viewmanagers.LuggMapsMarkerViewManagerDelegate
-import com.facebook.react.viewmanagers.LuggMapsMarkerViewManagerInterface
+import com.facebook.react.viewmanagers.LuggMarkerViewManagerDelegate
+import com.facebook.react.viewmanagers.LuggMarkerViewManagerInterface
 
-@ReactModule(name = LuggMapsMarkerViewManager.NAME)
-class LuggMapsMarkerViewManager :
-  ViewGroupManager<LuggMapsMarkerView>(),
-  LuggMapsMarkerViewManagerInterface<LuggMapsMarkerView> {
-  private val delegate: ViewManagerDelegate<LuggMapsMarkerView> = LuggMapsMarkerViewManagerDelegate(this)
+@ReactModule(name = LuggMarkerViewManager.NAME)
+class LuggMarkerViewManager :
+  ViewGroupManager<LuggMarkerView>(),
+  LuggMarkerViewManagerInterface<LuggMarkerView> {
+  private val delegate: ViewManagerDelegate<LuggMarkerView> = LuggMarkerViewManagerDelegate(this)
 
-  override fun getDelegate(): ViewManagerDelegate<LuggMapsMarkerView> = delegate
+  override fun getDelegate(): ViewManagerDelegate<LuggMarkerView> = delegate
   override fun getName(): String = NAME
-  override fun createViewInstance(context: ThemedReactContext): LuggMapsMarkerView = LuggMapsMarkerView(context)
+  override fun createViewInstance(context: ThemedReactContext): LuggMarkerView = LuggMarkerView(context)
 
-  override fun onDropViewInstance(view: LuggMapsMarkerView) {
+  override fun onDropViewInstance(view: LuggMarkerView) {
     super.onDropViewInstance(view)
     view.onDropViewInstance()
   }
 
-  override fun onAfterUpdateTransaction(view: LuggMapsMarkerView) {
+  override fun onAfterUpdateTransaction(view: LuggMarkerView) {
     super.onAfterUpdateTransaction(view)
     view.onAfterUpdateTransaction()
   }
 
   @ReactProp(name = "coordinate")
-  override fun setCoordinate(view: LuggMapsMarkerView, value: ReadableMap?) {
+  override fun setCoordinate(view: LuggMarkerView, value: ReadableMap?) {
     value?.let {
       val latitude = if (it.hasKey("latitude")) it.getDouble("latitude") else 0.0
       val longitude = if (it.hasKey("longitude")) it.getDouble("longitude") else 0.0
@@ -40,22 +40,22 @@ class LuggMapsMarkerViewManager :
   }
 
   @ReactProp(name = "name")
-  override fun setName(view: LuggMapsMarkerView, value: String?) {
+  override fun setName(view: LuggMarkerView, value: String?) {
     view.setName(value)
   }
 
   @ReactProp(name = "title")
-  override fun setTitle(view: LuggMapsMarkerView, value: String?) {
+  override fun setTitle(view: LuggMarkerView, value: String?) {
     view.setTitle(value)
   }
 
   @ReactProp(name = "description")
-  override fun setDescription(view: LuggMapsMarkerView, value: String?) {
+  override fun setDescription(view: LuggMarkerView, value: String?) {
     view.setDescription(value)
   }
 
   @ReactProp(name = "anchor")
-  override fun setAnchor(view: LuggMapsMarkerView, value: ReadableMap?) {
+  override fun setAnchor(view: LuggMarkerView, value: ReadableMap?) {
     value?.let {
       val x = if (it.hasKey("x")) it.getDouble("x") else 0.5
       val y = if (it.hasKey("y")) it.getDouble("y") else 1.0
@@ -63,7 +63,13 @@ class LuggMapsMarkerViewManager :
     }
   }
 
+  @ReactProp(name = "zIndex", defaultFloat = 0f)
+  override fun setZIndex(view: LuggMarkerView, zIndex: Float) {
+    super.setZIndex(view, zIndex)
+    view.setZIndex(zIndex)
+  }
+
   companion object {
-    const val NAME = "LuggMapsMarkerView"
+    const val NAME = "LuggMarkerView"
   }
 }

package/android/src/main/java/com/luggmaps/{LuggMapsPackage.kt → LuggPackage.kt}

@@ -5,9 +5,9 @@ import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.ViewManager
 
-class LuggMapsPackage : ReactPackage {
+class LuggPackage : ReactPackage {
   override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
-    listOf(LuggMapsGoogleMapViewManager(), LuggMapsMarkerViewManager(), LuggMapsWrapperViewManager(), LuggMapsPolylineViewManager())
+    listOf(LuggGoogleMapViewManager(), LuggMarkerViewManager(), LuggMapWrapperViewManager(), LuggPolylineViewManager())
 
   override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> = emptyList()
 }

package/android/src/main/java/com/luggmaps/{LuggMapsPolylineView.kt → LuggPolylineView.kt}

@@ -8,11 +8,11 @@ import com.google.android.gms.maps.model.Polyline
 import com.google.android.gms.maps.model.StrokeStyle
 import com.google.android.gms.maps.model.StyleSpan
 
-interface LuggMapsPolylineViewDelegate {
-  fun polylineViewDidUpdate(polylineView: LuggMapsPolylineView)
+interface LuggPolylineViewDelegate {
+  fun polylineViewDidUpdate(polylineView: LuggPolylineView)
 }
 
-class LuggMapsPolylineView(context: Context) : ReactViewGroup(context) {
+class LuggPolylineView(context: Context) : ReactViewGroup(context) {
   var coordinates: List<LatLng> = emptyList()
     private set
 
@@ -25,10 +25,13 @@ class LuggMapsPolylineView(context: Context) : ReactViewGroup(context) {
   var animated: Boolean = false
     private set
 
+  var zIndex: Float = 0f
+    private set
+
   var cachedSpans: List<StyleSpan>? = null
     private set
 
-  var delegate: LuggMapsPolylineViewDelegate? = null
+  var delegate: LuggPolylineViewDelegate? = null
   var polyline: Polyline? = null
 
   init {
@@ -55,6 +58,10 @@ class LuggMapsPolylineView(context: Context) : ReactViewGroup(context) {
     animated = value
   }
 
+  fun setZIndex(value: Float) {
+    zIndex = value
+  }
+
   fun getOrCreateSpans(): List<StyleSpan> {
     cachedSpans?.let { return it }
 

package/android/src/main/java/com/luggmaps/{LuggMapsPolylineViewManager.kt → LuggPolylineViewManager.kt}

@@ -6,32 +6,32 @@ import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.ViewGroupManager
 import com.facebook.react.uimanager.ViewManagerDelegate
 import com.facebook.react.uimanager.annotations.ReactProp
-import com.facebook.react.viewmanagers.LuggMapsPolylineViewManagerDelegate
-import com.facebook.react.viewmanagers.LuggMapsPolylineViewManagerInterface
+import com.facebook.react.viewmanagers.LuggPolylineViewManagerDelegate
+import com.facebook.react.viewmanagers.LuggPolylineViewManagerInterface
 import com.google.android.gms.maps.model.LatLng
 
-@ReactModule(name = LuggMapsPolylineViewManager.NAME)
-class LuggMapsPolylineViewManager :
-  ViewGroupManager<LuggMapsPolylineView>(),
-  LuggMapsPolylineViewManagerInterface<LuggMapsPolylineView> {
-  private val delegate: ViewManagerDelegate<LuggMapsPolylineView> = LuggMapsPolylineViewManagerDelegate(this)
+@ReactModule(name = LuggPolylineViewManager.NAME)
+class LuggPolylineViewManager :
+  ViewGroupManager<LuggPolylineView>(),
+  LuggPolylineViewManagerInterface<LuggPolylineView> {
+  private val delegate: ViewManagerDelegate<LuggPolylineView> = LuggPolylineViewManagerDelegate(this)
 
-  override fun getDelegate(): ViewManagerDelegate<LuggMapsPolylineView> = delegate
+  override fun getDelegate(): ViewManagerDelegate<LuggPolylineView> = delegate
   override fun getName(): String = NAME
-  override fun createViewInstance(context: ThemedReactContext): LuggMapsPolylineView = LuggMapsPolylineView(context)
+  override fun createViewInstance(context: ThemedReactContext): LuggPolylineView = LuggPolylineView(context)
 
-  override fun onDropViewInstance(view: LuggMapsPolylineView) {
+  override fun onDropViewInstance(view: LuggPolylineView) {
     super.onDropViewInstance(view)
     view.onDropViewInstance()
   }
 
-  override fun onAfterUpdateTransaction(view: LuggMapsPolylineView) {
+  override fun onAfterUpdateTransaction(view: LuggPolylineView) {
     super.onAfterUpdateTransaction(view)
     view.onAfterUpdateTransaction()
   }
 
   @ReactProp(name = "coordinates")
-  override fun setCoordinates(view: LuggMapsPolylineView, value: ReadableArray?) {
+  override fun setCoordinates(view: LuggPolylineView, value: ReadableArray?) {
     value?.let { array ->
       val coords = mutableListOf<LatLng>()
       for (i in 0 until array.size()) {
@@ -45,7 +45,7 @@ class LuggMapsPolylineViewManager :
   }
 
   @ReactProp(name = "strokeColors")
-  override fun setStrokeColors(view: LuggMapsPolylineView, value: ReadableArray?) {
+  override fun setStrokeColors(view: LuggPolylineView, value: ReadableArray?) {
     val colors = mutableListOf<Int>()
     value?.let { array ->
       for (i in 0 until array.size()) {
@@ -56,16 +56,22 @@ class LuggMapsPolylineViewManager :
   }
 
   @ReactProp(name = "strokeWidth", defaultDouble = 1.0)
-  override fun setStrokeWidth(view: LuggMapsPolylineView, value: Double) {
+  override fun setStrokeWidth(view: LuggPolylineView, value: Double) {
     view.setStrokeWidth(value.toFloat())
   }
 
   @ReactProp(name = "animated", defaultBoolean = false)
-  override fun setAnimated(view: LuggMapsPolylineView, value: Boolean) {
+  override fun setAnimated(view: LuggPolylineView, value: Boolean) {
     view.setAnimated(value)
   }
 
+  @ReactProp(name = "zIndex", defaultFloat = 0f)
+  override fun setZIndex(view: LuggPolylineView, value: Float) {
+    super.setZIndex(view, value)
+    view.setZIndex(value)
+  }
+
   companion object {
-    const val NAME = "LuggMapsPolylineView"
+    const val NAME = "LuggPolylineView"
   }
 }

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

@@ -2,18 +2,24 @@ 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 kotlin.math.floor
-import kotlin.math.max
 import kotlin.math.min
 
 class PolylineAnimator {
   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
 
@@ -31,6 +37,8 @@ class PolylineAnimator {
 
   private var animator: ValueAnimator? = null
   private var animationProgress: Float = 0f
+  private var cumulativeDistances: FloatArray = floatArrayOf()
+  private var totalLength: Float = 0f
 
   fun update() {
     if (animated) return
@@ -50,8 +58,10 @@ class PolylineAnimator {
   private fun startAnimation() {
     if (animator != null) return
 
+    computeCumulativeDistances()
+
     animator = ValueAnimator.ofFloat(0f, 2.15f).apply {
-      duration = 3650 // ~1.75s per phase * 2 + pause
+      duration = 2150
       repeatCount = ValueAnimator.INFINITE
       interpolator = LinearInterpolator()
       addUpdateListener { animation ->
@@ -62,6 +72,58 @@ 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 {
+    for (i in 1 until cumulativeDistances.size) {
+      if (cumulativeDistances[i] >= distance) {
+        return i - 1
+      }
+    }
+    return (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]
+
+    return LatLng(
+      c1.latitude + (c2.latitude - c1.latitude) * t,
+      c1.longitude + (c2.longitude - c1.longitude) * t
+    )
+  }
+
   private fun stopAnimation() {
     animator?.cancel()
     animator = null
@@ -69,71 +131,55 @@ class PolylineAnimator {
 
   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 headPos: Float
-    val tailPos: Float
+    val headDist: Float
+    val tailDist: Float
 
     if (progress <= 1f) {
-      tailPos = 0f
-      headPos = progress * segmentCount
+      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()) {
+    if (headDist <= tailDist) {
       poly.setSpans(emptyList())
       poly.points = listOf(coordinates.firstOrNull() ?: LatLng(0.0, 0.0))
       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>()
 
-    for (i in startIndex..minOf(endIndex, coordinates.size - 1)) {
-      var coord = coordinates[i]
-
-      // 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
-        )
-      }
+    points.add(coordinateAtDistance(tailDist))
 
-      // 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
-        )
-      }
+    for (i in (startIndex + 1)..endIndex) {
+      points.add(coordinates[i])
+    }
 
-      points.add(coord)
+    val endCoord = coordinateAtDistance(headDist)
+    val lastAdded = points.lastOrNull()
+    if (lastAdded == null || endCoord.latitude != lastAdded.latitude || endCoord.longitude != lastAdded.longitude) {
+      points.add(endCoord)
+    }
 
-      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()))
-      }
+    for (i in 0 until (points.size - 1)) {
+      val segMidDist = tailDist + visibleLength * (i + 0.5f) / (points.size - 1)
+      val gradientPos = (segMidDist - tailDist) / visibleLength
+      val color = colorAtGradientPosition(gradientPos)
+      spans.add(StyleSpan(StrokeStyle.colorBuilder(color).build()))
     }
 
     poly.points = points

package/android/src/main/java/com/luggmaps/events/CameraIdleEvent.kt

@@ -1,10 +1,17 @@
 package com.luggmaps.events
 
+import android.view.View
 import com.facebook.react.bridge.Arguments
+import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.events.Event
 
-class CameraIdleEvent(surfaceId: Int, viewId: Int, private val latitude: Double, private val longitude: Double, private val zoom: Float) :
-  Event<CameraIdleEvent>(surfaceId, viewId) {
+class CameraIdleEvent(
+  view: View,
+  private val latitude: Double,
+  private val longitude: Double,
+  private val zoom: Float,
+  private val gesture: Boolean
+) : Event<CameraIdleEvent>(UIManagerHelper.getSurfaceId(view), view.id) {
   override fun getEventName() = "topCameraIdle"
 
   override fun getEventData() =
@@ -17,5 +24,6 @@ class CameraIdleEvent(surfaceId: Int, viewId: Int, private val latitude: Double,
         }
       )
       putDouble("zoom", zoom.toDouble())
+      putBoolean("gesture", gesture)
     }
 }

package/android/src/main/java/com/luggmaps/events/CameraMoveEvent.kt

@@ -1,16 +1,17 @@
 package com.luggmaps.events
 
+import android.view.View
 import com.facebook.react.bridge.Arguments
+import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.events.Event
 
 class CameraMoveEvent(
-  surfaceId: Int,
-  viewId: Int,
+  view: View,
   private val latitude: Double,
   private val longitude: Double,
   private val zoom: Float,
-  private val dragging: Boolean
-) : Event<CameraMoveEvent>(surfaceId, viewId) {
+  private val gesture: Boolean
+) : Event<CameraMoveEvent>(UIManagerHelper.getSurfaceId(view), view.id) {
   override fun getEventName() = "topCameraMove"
 
   override fun getEventData() =
@@ -23,6 +24,6 @@ class CameraMoveEvent(
         }
       )
       putDouble("zoom", zoom.toDouble())
-      putBoolean("dragging", dragging)
+      putBoolean("gesture", gesture)
     }
 }

package/android/src/main/java/com/luggmaps/events/ReadyEvent.kt

@@ -0,0 +1,12 @@
+package com.luggmaps.events
+
+import android.view.View
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.Event
+
+class ReadyEvent(view: View) : Event<ReadyEvent>(UIManagerHelper.getSurfaceId(view), view.id) {
+  override fun getEventName() = "topReady"
+
+  override fun getEventData() = Arguments.createMap()
+}

package/android/src/main/java/com/luggmaps/extensions/ViewExtensions.kt

@@ -0,0 +1,14 @@
+package com.luggmaps.extensions
+
+import android.view.View
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.Event
+
+fun View.dispatchEvent(event: Event<*>) {
+  val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(
+    context as ThemedReactContext,
+    id
+  )
+  eventDispatcher?.dispatchEvent(event)
+}

package/ios/{LuggMapsAppleMapView.h → LuggAppleMapView.h}

@@ -4,10 +4,10 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
-@interface LuggMapsAppleMapViewContent : MKMapView
+@interface LuggAppleMapViewContent : MKMapView
 @end
 
-@interface LuggMapsAppleMapView : RCTViewComponentView
+@interface LuggAppleMapView : RCTViewComponentView
 
 - (MKMapView *)mapView;