@maydon_tech/react-native-nitro-maps 0.1.4 → 0.2.1

package/ios/Providers/{GoogleMapDelegate.swift → Google/GoogleMapDelegate.swift}

@@ -5,6 +5,13 @@ import GoogleMapsUtils
 /// GMSMapViewDelegate implementation for GoogleMapProvider
 class GoogleMapDelegate: NSObject, GMSMapViewDelegate {
 
+  // MARK: - Overlay UserData Keys
+  static let overlayTypeKey = "type"
+  static let overlayIdKey = "id"
+  static let overlayTypePolyline = "polyline"
+  static let overlayTypePolygon = "polygon"
+  static let overlayTypeCircle = "circle"
+
   weak var provider: GoogleMapProvider?
   private var isGesture: Bool = false
   private var lastGestureWasZoom: Bool = false
@@ -171,9 +178,13 @@ class GoogleMapDelegate: NSObject, GMSMapViewDelegate {
   func mapView(_ mapView: GMSMapView, willMove gesture: Bool) {
     isGesture = gesture
     zoomAtWillMove = mapView.camera.zoom
-    #if DEBUG
-    NSLog("[GestureDebug] willMove gesture=%d zoom=%.4f", gesture, mapView.camera.zoom)
-    #endif
+
+    // Auto-break follow/heading mode when user interacts with the map
+    if gesture, let provider = provider,
+       let mode = provider.userTrackingMode, mode != .none {
+      provider.userTrackingMode = .none
+      provider.onUserTrackingModeChange?(.none)
+    }
   }
   
   func mapView(_ mapView: GMSMapView, didChange position: GMSCameraPosition) {
@@ -199,25 +210,6 @@ class GoogleMapDelegate: NSObject, GMSMapViewDelegate {
   func mapView(_ mapView: GMSMapView, idleAt position: GMSCameraPosition) {
     guard let provider = provider else { return }
     
-    #if DEBUG
-    let gestureType = lastGestureWasZoom ? "ZOOM" : "PAN"
-    NSLog("[GestureDebug] idleAt zoom=%.4f gestureType=%@ cameraZoom=%.4f",
-          position.zoom, gestureType, mapView.camera.zoom)
-    
-    // Schedule a check to compare zoom at idle vs zoom when clustering fires
-    let idleZoom = mapView.camera.zoom
-    DispatchQueue.main.asyncAfter(deadline: .now() + 0.11) {
-      let clusterZoom = mapView.camera.zoom
-      if abs(idleZoom - clusterZoom) > 0.001 {
-        NSLog("[GestureDebug] ⚠️ ZOOM DRIFT: idle=%.4f clustering=%.4f delta=%.4f",
-              idleZoom, clusterZoom, clusterZoom - idleZoom)
-      } else {
-        NSLog("[GestureDebug] ✅ Zoom stable: idle=%.4f clustering=%.4f",
-              idleZoom, clusterZoom)
-      }
-    }
-    #endif
-    
     let event = RegionChangeEvent(
       region: provider.getCurrentRegion(),
       isGesture: isGesture
@@ -226,6 +218,28 @@ class GoogleMapDelegate: NSObject, GMSMapViewDelegate {
     isGesture = false
     lastGestureWasZoom = false
     provider.performClustering()
+    provider.refreshDashedPolylines()
+    provider.onMapIdle?()
+  }
+  
+  // MARK: - Overlay Tap Handler
+  
+  func mapView(_ mapView: GMSMapView, didTap overlay: GMSOverlay) {
+    guard let provider = provider,
+          let userData = overlay.userData as? [String: String],
+          let type = userData[Self.overlayTypeKey],
+          let id = userData[Self.overlayIdKey] else { return }
+
+    switch type {
+    case Self.overlayTypePolyline:
+      provider.onPolylinePress?(id)
+    case Self.overlayTypePolygon:
+      provider.onPolygonPress?(id)
+    case Self.overlayTypeCircle:
+      provider.onCirclePress?(id)
+    default:
+      break
+    }
   }
   
   // MARK: - Marker Methods
@@ -247,7 +261,9 @@ class GoogleMapDelegate: NSObject, GMSMapViewDelegate {
       )
       return true
     }
-    // Regular marker
+    // Regular marker — fire callback and return true to prevent
+    // the default info window. Consumers use selectMarker() to
+    // show info windows programmatically when desired.
     if let markerId = marker.userData as? String {
       provider.onMarkerPress?(
         MarkerPressEvent(
@@ -307,4 +323,13 @@ class GoogleMapDelegate: NSObject, GMSMapViewDelegate {
     // FIX #10: Removed dead NitroClusterItem check — only String IDs are used.
     return marker.userData as? String
   }
+
+  // MARK: - Info Window
+
+  func mapView(_ mapView: GMSMapView, didCloseInfoWindowOf marker: GMSMarker) {
+    // SDK auto-dismisses the info window when user taps elsewhere.
+    // didTapAt may NOT fire for that tap — SDK consumes it.
+    // This is the correct place to revert the marker's selection state.
+    provider?.deselectCurrentMarker()
+  }
 }

package/ios/Providers/Google/GoogleMapProvider+Camera.swift

@@ -0,0 +1,180 @@
+import Foundation
+import GoogleMaps
+
+// MARK: - Camera Methods (SRP: Camera control only)
+
+extension GoogleMapProvider {
+
+  func animateToRegion(_ region: Region, duration: Double?) {
+    let camera = GMSCameraPosition.camera(
+      withLatitude: region.latitude,
+      longitude: region.longitude,
+      zoom: calculateZoom(for: region)
+    )
+
+    let durationSeconds = (duration ?? 300) / 1000.0
+
+    CATransaction.begin()
+    CATransaction.setAnimationDuration(durationSeconds)
+    gmsMapView.animate(to: camera)
+    CATransaction.commit()
+  }
+
+  func fitToCoordinates(
+    _ coordinates: [Coordinate],
+    edgePadding: EdgePadding?,
+    animated: Bool?
+  ) {
+    guard coordinates.count >= 2 else {
+      if let first = coordinates.first {
+        animateToRegion(
+          Region(
+            latitude: first.latitude,
+            longitude: first.longitude,
+            latitudeDelta: 0.05,
+            longitudeDelta: 0.05
+          ),
+          duration: animated ?? true ? 300 : 0
+        )
+      }
+      return
+    }
+
+    let clCoordinates = coordinates.map {
+      CLLocationCoordinate2D(latitude: $0.latitude, longitude: $0.longitude)
+    }
+
+    var bounds = GMSCoordinateBounds(
+      coordinate: clCoordinates[0],
+      coordinate: clCoordinates[1]
+    )
+
+    for coord in clCoordinates.dropFirst(2) {
+      bounds = bounds.includingCoordinate(coord)
+    }
+
+    guard bounds.isValid else { return }
+
+    let padding = UIEdgeInsets(
+      top: CGFloat(edgePadding?.top ?? 50),
+      left: CGFloat(edgePadding?.left ?? 50),
+      bottom: CGFloat(edgePadding?.bottom ?? 50),
+      right: CGFloat(edgePadding?.right ?? 50)
+    )
+
+    let cameraUpdate = GMSCameraUpdate.fit(bounds, with: padding)
+
+    if animated ?? true {
+      gmsMapView.animate(with: cameraUpdate)
+    } else {
+      gmsMapView.moveCamera(cameraUpdate)
+    }
+  }
+
+  func fitToSuppliedMarkers(
+    _ markerIds: [String],
+    edgePadding: EdgePadding?,
+    animated: Bool?
+  ) {
+    let coordinates = markerIds.compactMap { id -> Coordinate? in
+      guard let data = clusterableMarkerData[id] else { return nil }
+      return Coordinate(latitude: data.coordinate.latitude, longitude: data.coordinate.longitude)
+    }
+    guard !coordinates.isEmpty else { return }
+    fitToCoordinates(coordinates, edgePadding: edgePadding, animated: animated)
+  }
+
+  func animateCamera(_ camera: Camera, duration: Double?) {
+    let gmsCamera = GMSCameraPosition.camera(
+      withLatitude: camera.center.latitude,
+      longitude: camera.center.longitude,
+      zoom: Float(camera.zoom),
+      bearing: camera.heading,
+      viewingAngle: camera.pitch
+    )
+
+    let durationSeconds = (duration ?? 300) / 1000.0
+
+    CATransaction.begin()
+    CATransaction.setAnimationDuration(durationSeconds)
+    gmsMapView.animate(to: gmsCamera)
+    CATransaction.commit()
+  }
+
+  func setCamera(_ camera: Camera) {
+    let gmsCamera = GMSCameraPosition.camera(
+      withLatitude: camera.center.latitude,
+      longitude: camera.center.longitude,
+      zoom: Float(camera.zoom),
+      bearing: camera.heading,
+      viewingAngle: camera.pitch
+    )
+    gmsMapView.camera = gmsCamera
+  }
+
+  func getCamera() -> Camera {
+    let cam = gmsMapView.camera
+    return Camera(
+      center: Coordinate(
+        latitude: cam.target.latitude,
+        longitude: cam.target.longitude
+      ),
+      pitch: cam.viewingAngle,
+      heading: cam.bearing,
+      altitude: MapStyleProvider.shared.altitudeFromZoom(Double(cam.zoom)),
+      zoom: Double(cam.zoom)
+    )
+  }
+
+  func getMapBoundaries() -> MapBoundaries? {
+    guard gmsMapView.frame.size.width > 0,
+      gmsMapView.frame.size.height > 0
+    else {
+      return nil
+    }
+
+    let visibleRegion = gmsMapView.projection.visibleRegion()
+    let bounds = GMSCoordinateBounds(region: visibleRegion)
+
+    guard bounds.isValid else { return nil }
+
+    return MapBoundaries(
+      northEast: Coordinate(
+        latitude: bounds.northEast.latitude,
+        longitude: bounds.northEast.longitude
+      ),
+      southWest: Coordinate(
+        latitude: bounds.southWest.latitude,
+        longitude: bounds.southWest.longitude
+      )
+    )
+  }
+
+  func getCurrentRegion() -> Region {
+    let cam = gmsMapView.camera
+    let visibleRegion = gmsMapView.projection.visibleRegion()
+    let bounds = GMSCoordinateBounds(region: visibleRegion)
+
+    return Region(
+      latitude: cam.target.latitude,
+      longitude: cam.target.longitude,
+      latitudeDelta: bounds.northEast.latitude - bounds.southWest.latitude,
+      longitudeDelta: bounds.northEast.longitude - bounds.southWest.longitude
+    )
+  }
+
+  func pointForCoordinate(_ coordinate: Coordinate) -> Point {
+    let clCoord = CLLocationCoordinate2D(
+      latitude: coordinate.latitude,
+      longitude: coordinate.longitude
+    )
+    let cgPoint = gmsMapView.projection.point(for: clCoord)
+    return Point(x: Double(cgPoint.x), y: Double(cgPoint.y))
+  }
+
+  func coordinateForPoint(_ point: Point) -> Coordinate {
+    let cgPoint = CGPoint(x: point.x, y: point.y)
+    let clCoord = gmsMapView.projection.coordinate(for: cgPoint)
+    return Coordinate(latitude: clCoord.latitude, longitude: clCoord.longitude)
+  }
+}