@maydon_tech/react-native-nitro-maps 0.1.0

package/ios/NitroMap.swift

@@ -0,0 +1,332 @@
+import Foundation
+import NitroModules
+import UIKit
+
+/// HybridNitroMap - Google Maps powered map view.
+///
+/// Threading contract:
+/// - All UI/SDK operations are dispatched to main thread HERE.
+/// - GoogleMapProvider assumes it is ALWAYS called from main thread.
+/// - Props are stored locally; forwarded to provider via optional chaining
+///   (no-op if provider isn't initialized yet). `afterUpdate()` ensures
+///   provider is created and settings applied.
+class HybridNitroMap: HybridNitroMapSpec {
+
+  // MARK: - Provider
+
+  private let containerView: UIView = {
+    let view = UIView()
+    view.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+    return view
+  }()
+
+  /// The provider is created lazily on first `afterUpdate()` or first
+  /// imperative method call. This avoids premature init before the view
+  /// has valid bounds.
+  private var _provider: GoogleMapProvider?
+
+  /// Returns the provider, initializing it if needed.
+  /// Must be called from the main thread.
+  private var mapProvider: GoogleMapProvider {
+    if _provider == nil {
+      initializeProvider()
+    }
+    return _provider!
+  }
+
+  private func initializeProvider() {
+    let provider = GoogleMapProvider()
+    provider.setup()
+
+    let providerView = provider.mapView
+    providerView.frame = containerView.bounds
+    providerView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+    containerView.addSubview(providerView)
+
+    _provider = provider
+    applyCurrentSettings(to: provider)
+  }
+
+  private func applyCurrentSettings(to provider: GoogleMapProvider) {
+    provider.initialRegion = initialRegion
+    provider.showsUserLocation = showsUserLocation
+    provider.zoomEnabled = zoomEnabled
+    provider.scrollEnabled = scrollEnabled
+    provider.rotateEnabled = rotateEnabled
+    provider.pitchEnabled = pitchEnabled
+    provider.mapType = mapType
+    provider.showsMyLocationButton = showsMyLocationButton
+    provider.clusterConfig = clusterConfig
+    provider.customMapStyle = customMapStyle
+    provider.darkMode = darkMode
+
+    provider.onPress = onPress
+    provider.onLongPress = onLongPress
+    provider.onMapReady = onMapReady
+    provider.onRegionChange = onRegionChange
+    provider.onRegionChangeComplete = onRegionChangeComplete
+    provider.onMarkerPress = onMarkerPress
+    provider.onMarkerDragStart = onMarkerDragStart
+    provider.onMarkerDrag = onMarkerDrag
+    provider.onMarkerDragEnd = onMarkerDragEnd
+    provider.onClusterPress = onClusterPress
+    provider.onError = onError
+  }
+
+  var view: UIView { return containerView }
+
+  // Provider prop from JS — currently only Google is supported
+  var provider: MapProvider? {
+    didSet {
+      // Only Google Maps is supported — ignored for now
+    }
+  }
+
+  // MARK: - Properties
+  // Stored locally. Forwarded to provider via optional chaining so
+  // setting a prop before the provider is ready is a no-op (the values
+  // are pushed in bulk via applyCurrentSettings when provider inits).
+
+  var initialRegion: Region? {
+    didSet { _provider?.initialRegion = initialRegion }
+  }
+
+  var showsUserLocation: Bool? {
+    didSet { _provider?.showsUserLocation = showsUserLocation }
+  }
+
+  var zoomEnabled: Bool? {
+    didSet { _provider?.zoomEnabled = zoomEnabled }
+  }
+
+  var scrollEnabled: Bool? {
+    didSet { _provider?.scrollEnabled = scrollEnabled }
+  }
+
+  var rotateEnabled: Bool? {
+    didSet { _provider?.rotateEnabled = rotateEnabled }
+  }
+
+  var pitchEnabled: Bool? {
+    didSet { _provider?.pitchEnabled = pitchEnabled }
+  }
+
+  var mapType: MapType? {
+    didSet { _provider?.mapType = mapType }
+  }
+
+  var showsMyLocationButton: Bool? {
+    didSet { _provider?.showsMyLocationButton = showsMyLocationButton }
+  }
+
+  var clusterConfig: ClusterConfig? {
+    didSet { _provider?.clusterConfig = clusterConfig }
+  }
+
+  var customMapStyle: [MapStyleElement]? {
+    didSet { _provider?.customMapStyle = customMapStyle }
+  }
+
+  var darkMode: Bool? {
+    didSet { _provider?.darkMode = darkMode }
+  }
+
+  // MARK: - Callbacks
+
+  var onPress: ((MapPressEvent) -> Void)? {
+    didSet { _provider?.onPress = onPress }
+  }
+
+  var onLongPress: ((MapPressEvent) -> Void)? {
+    didSet { _provider?.onLongPress = onLongPress }
+  }
+
+  var onMapReady: (() -> Void)? {
+    didSet { _provider?.onMapReady = onMapReady }
+  }
+
+  var onRegionChange: ((RegionChangeEvent) -> Void)? {
+    didSet { _provider?.onRegionChange = onRegionChange }
+  }
+
+  var onRegionChangeComplete: ((RegionChangeEvent) -> Void)? {
+    didSet { _provider?.onRegionChangeComplete = onRegionChangeComplete }
+  }
+
+  var onMarkerPress: ((_ event: MarkerPressEvent) -> Void)? {
+    didSet { _provider?.onMarkerPress = onMarkerPress }
+  }
+
+  var onMarkerDragStart: ((_ event: MarkerDragEvent) -> Void)? {
+    didSet { _provider?.onMarkerDragStart = onMarkerDragStart }
+  }
+
+  var onMarkerDrag: ((_ event: MarkerDragEvent) -> Void)? {
+    didSet { _provider?.onMarkerDrag = onMarkerDrag }
+  }
+
+  var onMarkerDragEnd: ((_ event: MarkerDragEvent) -> Void)? {
+    didSet { _provider?.onMarkerDragEnd = onMarkerDragEnd }
+  }
+
+  var onClusterPress: ((_ event: ClusterPressEvent) -> Void)? {
+    didSet { _provider?.onClusterPress = onClusterPress }
+  }
+
+  var onError: ((_ error: MapError) -> Void)? {
+    didSet { _provider?.onError = onError }
+  }
+
+  // MARK: - Initialization
+
+  override init() {
+    super.init()
+  }
+
+  // MARK: - Lifecycle
+
+  func beforeUpdate() {}
+
+  func afterUpdate() {
+    // Ensure provider is initialized on first render
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.updateSettings()
+    }
+  }
+
+  // MARK: - Camera Methods
+
+  func animateToRegion(region: Region, duration: Double?) throws {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.animateToRegion(region, duration: duration)
+    }
+  }
+
+  func fitToCoordinates(
+    coordinates: [Coordinate],
+    edgePadding: EdgePadding?,
+    animated: Bool?
+  ) throws {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.fitToCoordinates(
+        coordinates,
+        edgePadding: edgePadding,
+        animated: animated
+      )
+    }
+  }
+
+  func animateCamera(camera: Camera, duration: Double?) throws {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.animateCamera(camera, duration: duration)
+    }
+  }
+
+  func setCamera(camera: Camera) throws {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.setCamera(camera)
+    }
+  }
+
+  func getCamera() throws -> NitroModules.Promise<Camera> {
+    // Called from JS thread — provider access is safe because
+    // GMSMapView.camera is a stored property (thread-safe read)
+    return .resolved(withResult: mapProvider.getCamera())
+  }
+
+  func getMapBoundaries() throws -> NitroModules.Promise<MapBoundaries> {
+    // projection.visibleRegion() must be called on the main thread.
+    // Use DispatchQueue.main.sync when called from a background thread,
+    // or call directly if already on main.
+    let result: MapBoundaries?
+    if Thread.isMainThread {
+      result = mapProvider.getMapBoundaries()
+    } else {
+      result = DispatchQueue.main.sync {
+        return self.mapProvider.getMapBoundaries()
+      }
+    }
+    guard let boundaries = result else {
+      return .rejected(withError: RuntimeError.error(withMessage: "Map boundaries not available"))
+    }
+    return .resolved(withResult: boundaries)
+  }
+
+  // MARK: - Marker Methods
+
+  func addMarker(marker: MarkerData) throws {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.addMarker(marker)
+    }
+  }
+
+  func addMarkers(markers: [MarkerData]) throws {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.addMarkers(markers)
+    }
+  }
+
+  func updateMarker(marker: MarkerData) throws {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.updateMarker(marker)
+    }
+  }
+
+  func removeMarker(id: String) throws {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.removeMarker(id)
+    }
+  }
+
+  func clearMarkers() throws {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.clearMarkers()
+    }
+  }
+
+  func selectMarker(id: String) {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.selectMarker(id)
+    }
+  }
+
+  // MARK: - Clustering
+
+  func setClusteringEnabled(enabled: Bool) throws {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.setClusteringEnabled(enabled)
+    }
+  }
+
+  func refreshClusters() throws {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.refreshClusters()
+    }
+  }
+
+  // MARK: - Map Style
+
+  func setMapStyle(style: [MapStyleElement]?) throws {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.setMapStyle(style)
+    }
+  }
+
+  func setIsDarkMode(enabled isDark: Bool) {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.setDarkMode(isDark)
+    }
+  }
+
+  // MARK: - Clustering & Region
+
+  func performClustering() {
+    DispatchQueue.main.async { [weak self] in
+      self?.mapProvider.performClustering()
+    }
+  }
+
+  func getCurrentRegion() -> Region {
+    return mapProvider.getCurrentRegion()
+  }
+}

package/ios/NitroMapConfig/HybridNitroMapConfig.swift

@@ -0,0 +1,33 @@
+import Foundation
+import GoogleMaps
+import NitroModules
+
+class HybridNitroMapConfig: HybridNitroMapConfigSpec {
+
+  // Static flag to track initialization across all instances
+  private static var isInitialized = false
+
+  func NitroMapInitialize(apiKey: String, provider: MapProvider) {
+    // Use static flag to prevent duplicate initialization
+    guard !HybridNitroMapConfig.isInitialized else {
+      #if DEBUG
+      print("[NitroMap] Already initialized, skipping...")
+      #endif
+      return
+    }
+    
+    // Set initialized BEFORE async dispatch to prevent race conditions
+    HybridNitroMapConfig.isInitialized = true
+    
+    DispatchQueue.main.async {
+      GMSServices.provideAPIKey(apiKey)
+      #if DEBUG
+      print("[NitroMap] Google Maps initialized")
+      #endif
+    }
+  }
+
+  func IsNitroMapInitialized() -> Bool {
+    return HybridNitroMapConfig.isInitialized
+  }
+}

package/ios/Providers/GoogleMapDelegate.swift

@@ -0,0 +1,310 @@
+import Foundation
+import GoogleMaps
+import GoogleMapsUtils
+
+/// GMSMapViewDelegate implementation for GoogleMapProvider
+class GoogleMapDelegate: NSObject, GMSMapViewDelegate {
+
+  weak var provider: GoogleMapProvider?
+  private var isGesture: Bool = false
+  private var lastGestureWasZoom: Bool = false
+  private var zoomAtWillMove: Float = 0
+  private var isMapReady: Bool = false
+  private var hasPerformedInitialClustering: Bool = false
+  private var fallbackClusteringTimer: Timer?
+
+  init(provider: GoogleMapProvider) {
+    self.provider = provider
+    super.init()
+
+    // Fallback timer for real devices where tile rendering callback may be delayed
+    // This ensures clustering happens even if mapViewDidFinishTileRendering is slow
+    fallbackClusteringTimer = Timer.scheduledTimer(withTimeInterval: 0.5, repeats: false) { [weak self] _ in
+      self?.triggerInitialClusteringIfNeeded()
+    }
+  }
+
+  deinit {
+    fallbackClusteringTimer?.invalidate()
+  }
+
+  /// Triggers initial clustering if it hasn't happened yet and the view is ready
+  private func triggerInitialClusteringIfNeeded() {
+    guard !hasPerformedInitialClustering else { return }
+    guard let provider = provider else { return }
+
+    // Check if map view has valid dimensions
+    let mapView = provider.mapView
+    guard mapView.frame.size.width > 0 && mapView.frame.size.height > 0 else {
+      // Retry after a short delay if view isn't laid out yet
+      fallbackClusteringTimer?.invalidate()
+      fallbackClusteringTimer = Timer.scheduledTimer(withTimeInterval: 0.3, repeats: false) { [weak self] _ in
+        self?.triggerInitialClusteringIfNeeded()
+      }
+      return
+    }
+
+    hasPerformedInitialClustering = true
+    if !isMapReady {
+      isMapReady = true
+      provider.onMapReady?()
+    }
+    provider.performClustering()
+  }
+
+  func mapViewDidFinishTileRendering(_ mapView: GMSMapView) {
+    fallbackClusteringTimer?.invalidate()
+    guard !isMapReady else { return }
+    isMapReady = true
+    hasPerformedInitialClustering = true
+    provider?.onMapReady?()
+    provider?.performClustering()
+  }
+
+  /// Called when map snapshot is ready - another reliable trigger point
+  func mapViewSnapshotReady(_ mapView: GMSMapView) {
+    triggerInitialClusteringIfNeeded()
+  }
+
+  // MARK: - Proximity Cluster Detection
+  
+  /// Check if a coordinate is near any rendered cluster marker.
+  private func findNearbyCluster(
+    at coordinate: CLLocationCoordinate2D,
+    in mapView: GMSMapView
+  ) -> GMSMarker? {
+    guard let provider = provider else { return nil }
+    
+    let tapPoint = mapView.projection.point(for: coordinate)
+    let proximityThreshold: CGFloat = 60.0
+    
+    var closestMarker: GMSMarker?
+    var closestDistance: CGFloat = .greatestFiniteMagnitude
+    
+    for clusterMarker in provider.renderedClusterMarkers {
+      let markerPoint = mapView.projection.point(for: clusterMarker.position)
+      let dx = tapPoint.x - markerPoint.x
+      let dy = tapPoint.y - markerPoint.y
+      let distance = sqrt(dx * dx + dy * dy)
+      if distance < proximityThreshold && distance < closestDistance {
+        closestDistance = distance
+        closestMarker = clusterMarker
+      }
+    }
+    
+    return closestMarker
+  }
+  
+  private func fireClusterPress(for marker: GMSMarker) {
+    guard let clusterData = marker.userData as? ClusterUserData else { return }
+    provider?.onClusterPress?(
+      ClusterPressEvent(
+        coordinate: Coordinate(
+          latitude: marker.position.latitude,
+          longitude: marker.position.longitude
+        ),
+        markerIds: clusterData.markerIds,
+        count: Double(clusterData.count)
+      )
+    )
+  }
+
+  // MARK: - Map Tap Handlers
+  
+  func mapView(_ mapView: GMSMapView, didTapAt coordinate: CLLocationCoordinate2D) {
+    // Proximity-based cluster tap fallback
+    if let clusterMarker = findNearbyCluster(at: coordinate, in: mapView) {
+      fireClusterPress(for: clusterMarker)
+      return
+    }
+    
+    let point = mapView.projection.point(for: coordinate)
+    let event = MapPressEvent(
+      coordinate: Coordinate(
+        latitude: coordinate.latitude,
+        longitude: coordinate.longitude
+      ),
+      position: Point(
+        x: Double(point.x),
+        y: Double(point.y)
+      )
+    )
+    provider?.onPress?(event)
+  }
+  
+  /// POI labels (city names, landmarks) intercept taps before markers.
+  func mapView(_ mapView: GMSMapView, didTapPOIWithPlaceID placeID: String, name: String, location: CLLocationCoordinate2D) {
+    if let clusterMarker = findNearbyCluster(at: location, in: mapView) {
+      fireClusterPress(for: clusterMarker)
+      return
+    }
+    
+    let point = mapView.projection.point(for: location)
+    let event = MapPressEvent(
+      coordinate: Coordinate(
+        latitude: location.latitude,
+        longitude: location.longitude
+      ),
+      position: Point(
+        x: Double(point.x),
+        y: Double(point.y)
+      )
+    )
+    provider?.onPress?(event)
+  }
+  
+  func mapView(_ mapView: GMSMapView, didLongPressAt coordinate: CLLocationCoordinate2D) {
+    let point = mapView.projection.point(for: coordinate)
+    let event = MapPressEvent(
+      coordinate: Coordinate(
+        latitude: coordinate.latitude,
+        longitude: coordinate.longitude
+      ),
+      position: Point(
+        x: Double(point.x),
+        y: Double(point.y)
+      )
+    )
+    provider?.onLongPress?(event)
+  }
+  
+  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
+  }
+  
+  func mapView(_ mapView: GMSMapView, didChange position: GMSCameraPosition) {
+    guard let provider = provider else { return }
+    
+    // Track if zoom changed during this gesture
+    if isGesture && abs(position.zoom - zoomAtWillMove) > 0.01 {
+      lastGestureWasZoom = true
+    }
+    
+    let event = RegionChangeEvent(
+      region: provider.getCurrentRegion(),
+      isGesture: isGesture
+    )
+    provider.onRegionChange?(event)
+
+    // Live clustering during gestures (throttled)
+    if provider.clusterConfig?.realtimeClustering == true {
+      provider.performClusteringThrottled()
+    }
+  }
+  
+  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
+    )
+    provider.onRegionChangeComplete?(event)
+    isGesture = false
+    lastGestureWasZoom = false
+    provider.performClustering()
+  }
+  
+  // MARK: - Marker Methods
+  
+  func mapView(_ mapView: GMSMapView, didTap marker: GMSMarker) -> Bool {
+    guard let provider = provider else { return false }
+    
+    // Check if it's a C++ cluster
+    if let clusterData = marker.userData as? ClusterUserData {
+      provider.onClusterPress?(
+        ClusterPressEvent(
+          coordinate: Coordinate(
+            latitude: marker.position.latitude,
+            longitude: marker.position.longitude
+          ),
+          markerIds: clusterData.markerIds,
+          count: Double(clusterData.count)
+        )
+      )
+      return true
+    }
+    // Regular marker
+    if let markerId = marker.userData as? String {
+      provider.onMarkerPress?(
+        MarkerPressEvent(
+          id: markerId,
+          coordinate: Coordinate(
+            latitude: marker.position.latitude,
+            longitude: marker.position.longitude
+          )
+        )
+      )
+      return true
+    }
+    
+    return false
+  }
+  
+  func mapView(_ mapView: GMSMapView, didBeginDragging marker: GMSMarker) {
+    guard let provider = provider, let markerId = getMarkerId(from: marker) else { return }
+    provider.onMarkerDragStart?(
+      MarkerDragEvent(
+        id: markerId,
+        coordinate: Coordinate(
+          latitude: marker.position.latitude,
+          longitude: marker.position.longitude
+        )
+      )
+    )
+  }
+  
+  func mapView(_ mapView: GMSMapView, didDrag marker: GMSMarker) {
+    guard let provider = provider, let markerId = getMarkerId(from: marker) else { return }
+    provider.onMarkerDrag?(
+      MarkerDragEvent(
+        id: markerId,
+        coordinate: Coordinate(
+          latitude: marker.position.latitude,
+          longitude: marker.position.longitude
+        )
+      )
+    )
+  }
+  
+  func mapView(_ mapView: GMSMapView, didEndDragging marker: GMSMarker) {
+    guard let provider = provider, let markerId = getMarkerId(from: marker) else { return }
+    provider.onMarkerDragEnd?(
+      MarkerDragEvent(
+        id: markerId,
+        coordinate: Coordinate(
+          latitude: marker.position.latitude,
+          longitude: marker.position.longitude
+        )
+      )
+    )
+  }
+  
+  private func getMarkerId(from marker: GMSMarker) -> String? {
+    // FIX #10: Removed dead NitroClusterItem check — only String IDs are used.
+    return marker.userData as? String
+  }
+}