@maydon_tech/react-native-nitro-maps 0.1.0

package/ios/Clustering/ClusterIconRenderer.swift

@@ -0,0 +1,80 @@
+import UIKit
+
+/// Shared cluster icon renderer — single source of truth for cluster icon rendering.
+/// Eliminates duplication across NitroClusterIconGenerator, ClusterAnnotationView,
+/// and NitroClusterAnnotationView (DRY).
+enum ClusterIconRenderer {
+
+  /// Renders a cluster icon with the given count and optional config.
+  ///
+  /// - Parameters:
+  ///   - count: Number of markers in the cluster
+  ///   - config: Optional cluster configuration for colors/border
+  ///   - size: Override diameter. If nil, auto-selects based on count.
+  /// - Returns: Rendered cluster icon image
+  static func renderIcon(
+    count: Int,
+    config: ClusterConfig?,
+    size: CGFloat? = nil
+  ) -> UIImage {
+    let diameter = size ?? clusterDiameter(for: count)
+
+    let bgColor = resolveColor(config?.backgroundColor.toMarkerColor(),
+                               fallback: MarkerColor(r: 0, g: 122, b: 255, a: 255))
+    let textColor = resolveColor(config?.textColor.toMarkerColor(),
+                                 fallback: MarkerColor(r: 255, g: 255, b: 255, a: 255))
+    let borderWidth = CGFloat(config?.borderWidth ?? 2)
+    let borderUIColor = resolveColor(config?.borderColor.toMarkerColor(),
+                                     fallback: MarkerColor(r: 255, g: 255, b: 255, a: 255))
+
+    let renderer = UIGraphicsImageRenderer(
+      size: CGSize(width: diameter, height: diameter)
+    )
+    return renderer.image { context in
+      let fullRect = CGRect(x: 0, y: 0, width: diameter, height: diameter)
+      let insetRect = fullRect.insetBy(dx: borderWidth, dy: borderWidth)
+
+      // Border circle
+      borderUIColor.setFill()
+      context.cgContext.fillEllipse(in: fullRect)
+
+      // Background circle
+      bgColor.setFill()
+      context.cgContext.fillEllipse(in: insetRect)
+
+      // Text
+      let text = "\(count)"
+      let font = UIFont.boldSystemFont(ofSize: diameter * 0.35)
+      let attributes: [NSAttributedString.Key: Any] = [
+        .font: font,
+        .foregroundColor: textColor,
+      ]
+      let textSize = text.size(withAttributes: attributes)
+      let textRect = CGRect(
+        x: (diameter - textSize.width) / 2,
+        y: (diameter - textSize.height) / 2,
+        width: textSize.width,
+        height: textSize.height
+      )
+      text.draw(in: textRect, withAttributes: attributes)
+    }
+  }
+
+  /// Standard cluster diameter based on count (Apple HIG: minimum 44pt tap targets).
+  static func clusterDiameter(for count: Int) -> CGFloat {
+    return count < 10 ? 44 : (count < 100 ? 52 : 60)
+  }
+
+  // MARK: - Private
+
+  private static func resolveColor(_ markerColor: MarkerColor?,
+                                   fallback: MarkerColor) -> UIColor {
+    let c = markerColor ?? fallback
+    return UIColor(
+      red: CGFloat(c.r) / 255,
+      green: CGFloat(c.g) / 255,
+      blue: CGFloat(c.b) / 255,
+      alpha: CGFloat(c.a) / 255
+    )
+  }
+}

package/ios/Clustering/NitroClusterEngine.swift

@@ -0,0 +1,117 @@
+import Foundation
+import CoreLocation
+
+/// Swift wrapper for C++ ClusterEngine via Objective-C++ bridge.
+/// Pure spatial grouping — no icon dimensions.
+/// Caller (GoogleMapProvider) handles visual collision with real rendered sizes.
+class NitroClusterEngine {
+
+    private let engine: ClusterEngineWrapper
+
+    init() {
+        engine = ClusterEngineWrapper()
+    }
+
+    // MARK: - Configuration
+
+    func setClusterRadius(_ radius: Double) {
+        engine.setClusterRadius(radius)
+    }
+
+    func setMinClusterSize(_ size: Int) {
+        engine.setMinClusterSize(size)
+    }
+
+    func setMaxZoom(_ zoom: Double) {
+        engine.setMaxZoom(zoom)
+    }
+
+    // MARK: - Marker Management
+
+    /// Add a marker for clustering. Only geographic data is stored;
+    /// icon dimensions are handled by the Swift collision resolver.
+    func addMarker(_ markerData: MarkerData) {
+        engine.addMarker(
+            withId: markerData.id,
+            latitude: markerData.coordinate.latitude,
+            longitude: markerData.coordinate.longitude
+        )
+    }
+
+    func removeMarker(_ id: String) {
+        engine.removeMarker(withId: id)
+    }
+
+    func clearMarkers() {
+        engine.clearMarkers()
+    }
+
+    // MARK: - Result Types
+
+    /// Single marker returned from clustering (not merged into a cluster).
+    struct SingleMarkerResult {
+        var markerId: String
+        var latitude: Double
+        var longitude: Double
+    }
+
+    struct ClusteringResult {
+        var clusters: [ClusterDataResult]
+        var singleMarkers: [SingleMarkerResult]
+    }
+
+    struct ClusterDataResult {
+        var coordinate: CLLocationCoordinate2D
+        var markerIds: [String]
+        var count: Int
+        var iconSize: Double  // Hint from C++; collision uses real rendered size
+    }
+
+    // MARK: - Clustering
+
+    /// Provider-agnostic clustering method — returns spatial groups.
+    /// Caller resolves IDs to MarkerData and measures real icon sizes.
+    func clusterWithBounds(
+        minLat: Double,
+        maxLat: Double,
+        minLon: Double,
+        maxLon: Double,
+        zoom: Double,
+        mapSize: CGSize
+    ) -> ClusteringResult {
+        let objcResult = engine.cluster(
+            withMinLat: minLat,
+            maxLat: maxLat,
+            minLon: minLon,
+            maxLon: maxLon,
+            zoom: zoom,
+            mapWidth: Double(mapSize.width),
+            mapHeight: Double(mapSize.height)
+        )
+
+        var clusters: [ClusterDataResult] = []
+        var singleMarkers: [SingleMarkerResult] = []
+
+        for clusterData in objcResult.clusters {
+            clusters.append(ClusterDataResult(
+                coordinate: CLLocationCoordinate2D(
+                    latitude: clusterData.latitude,
+                    longitude: clusterData.longitude
+                ),
+                markerIds: clusterData.markerIds as [String],
+                count: clusterData.count,
+                iconSize: clusterData.iconSize
+            ))
+        }
+
+        for point in objcResult.singleMarkers {
+            singleMarkers.append(SingleMarkerResult(
+                markerId: point.markerId,
+                latitude: point.latitude,
+                longitude: point.longitude
+            ))
+        }
+
+        return ClusteringResult(clusters: clusters, singleMarkers: singleMarkers)
+    }
+}

package/ios/Clustering/NitroClusterIconGenerator.swift

@@ -0,0 +1,35 @@
+import Foundation
+import UIKit
+
+/// Generates and caches cluster icons.
+/// Uses ClusterIconRenderer for the actual rendering.
+///
+/// FIX #6: No longer extends GMUDefaultClusterIconGenerator — the GMU
+/// clustering pipeline is gone. This is now a plain Swift class.
+final class NitroClusterIconGenerator {
+
+  private var config: ClusterConfig?
+
+  /// Cache cluster icons to avoid re-rendering identical icons on every cluster() call
+  private let iconCache = NSCache<NSNumber, UIImage>()
+
+  func updateConfig(_ config: ClusterConfig?) {
+    self.config = config
+    iconCache.removeAllObjects()
+  }
+
+  func icon(forSize size: UInt) -> UIImage {
+    let cacheKey = NSNumber(value: size)
+    if let cached = iconCache.object(forKey: cacheKey) {
+      return cached
+    }
+
+    let image = ClusterIconRenderer.renderIcon(
+      count: Int(size),
+      config: config
+    )
+
+    iconCache.setObject(image, forKey: cacheKey)
+    return image
+  }
+}

package/ios/MarkerRenderer/MarkerIconFactory.swift

@@ -0,0 +1,322 @@
+import UIKit
+
+/// Global marker icon cache with aggressive texture reuse
+final class MarkerIconCache {
+  static let shared = MarkerIconCache()
+
+  // Use NSCache for automatic memory management
+  private let cache = NSCache<NSString, UIImage>()
+
+  // Separate cache for URL image data to avoid repeated network calls
+  private let urlImageCache = NSCache<NSString, UIImage>()
+
+  // Track unique icon count for debugging
+  private var uniqueIconCount = 0
+  private var cacheHits = 0
+  private var cacheMisses = 0
+
+  private init() {
+    // Increased limits to handle more markers without texture exhaustion
+    cache.countLimit = 500 // Max 500 unique icons (was 200)
+    cache.totalCostLimit = 100 * 1024 * 1024 // 100MB max (was 50MB)
+
+    urlImageCache.countLimit = 200
+    urlImageCache.totalCostLimit = 50 * 1024 * 1024
+
+    // Listen for memory warnings to clear caches
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(handleMemoryWarning),
+      name: UIApplication.didReceiveMemoryWarningNotification,
+      object: nil
+    )
+  }
+
+  @objc private func handleMemoryWarning() {
+    // Clear half the cache on memory warning instead of all
+    // This keeps frequently used icons while freeing memory
+    #if DEBUG
+    print("[MarkerIconCache] Memory warning received, clearing caches")
+    #endif
+    cache.removeAllObjects()
+    urlImageCache.removeAllObjects()
+    uniqueIconCount = 0
+  }
+
+  func getIcon(forKey key: String) -> UIImage? {
+    if let cached = cache.object(forKey: key as NSString) {
+      cacheHits += 1
+      logStatsIfNeeded()
+      return cached
+    }
+    cacheMisses += 1
+    logStatsIfNeeded()
+    return nil
+  }
+
+  func setIcon(_ image: UIImage, forKey key: String) {
+    // Calculate cost based on image size for better memory management
+    let cost = Int(image.size.width * image.size.height * image.scale * image.scale * 4)
+    cache.setObject(image, forKey: key as NSString, cost: cost)
+    uniqueIconCount += 1
+
+    if uniqueIconCount % 100 == 0 {
+      #if DEBUG
+      print("[MarkerIconCache] Cached \(uniqueIconCount) unique icons")
+      #endif
+    }
+  }
+  
+  private func logStatsIfNeeded() {
+    let total = cacheHits + cacheMisses
+    if total > 0 && total % 500 == 0 {
+      let hitRate = Double(cacheHits) / Double(total) * 100
+      #if DEBUG
+      print("[MarkerIconCache] Stats: hits=\(cacheHits), misses=\(cacheMisses), hitRate=\(String(format: "%.1f", hitRate))%, unique=\(uniqueIconCount)")
+      #endif
+    }
+  }
+
+  func getURLImage(forKey key: String) -> UIImage? {
+    return urlImageCache.object(forKey: key as NSString)
+  }
+
+  func setURLImage(_ image: UIImage, forKey key: String) {
+    let cost = Int(image.size.width * image.size.height * image.scale * image.scale * 4)
+    urlImageCache.setObject(image, forKey: key as NSString, cost: cost)
+  }
+
+  func clear() {
+    cache.removeAllObjects()
+    urlImageCache.removeAllObjects()
+    uniqueIconCount = 0
+  }
+
+  /// Generate a simplified cache key for price markers
+  /// Reduces texture diversity by bucketing similar configurations
+  static func priceMarkerKey(
+    price: String,
+    currency: String,
+    selected: Bool
+  ) -> String {
+    // Normalize price to reduce unique textures
+    return "price_\(price)_\(currency)_\(selected)"
+  }
+
+  /// Generate cache key for image markers
+  static func imageMarkerKey(
+    source: String,
+    width: Double,
+    height: Double,
+    cornerRadius: Double
+  ) -> String {
+    // Round dimensions to reduce unique keys
+    let w = Int(width / 5) * 5  // Round to nearest 5
+    let h = Int(height / 5) * 5
+    let r = Int(cornerRadius / 5) * 5
+    // Use stable hash for cache key
+    let sourceHash = stableHash(source)
+    return "image_\(sourceHash)_\(w)_\(h)_\(r)"
+  }
+
+  /// Stable hash that doesn't change between app launches
+  private static func stableHash(_ string: String) -> Int {
+    var hash = 5381
+    for char in string.utf8 {
+      hash = ((hash << 5) &+ hash) &+ Int(char)
+    }
+    return abs(hash)
+  }
+}
+
+class MarkerIconFactory {
+  
+  static func createIcon(for markerData: MarkerData) -> UIImage? {
+    switch markerData.config.style {
+    case .image:
+      return createImageMarkerIcon(markerData.config.image)
+    case .pricemarker:
+      return createPriceMarkerIcon(markerData.config.priceMarker)
+    case .default:
+      return nil
+    }
+  }
+  
+  // MARK: - Price Marker Icon
+  private static func createPriceMarkerIcon(_ config: PriceMarkerStyle?) -> UIImage? {
+    guard let config = config else { return nil }
+    
+    // Generate normalized cache key
+    let cacheKey = MarkerIconCache.priceMarkerKey(
+      price: config.price,
+      currency: config.currency,
+      selected: config.selected
+    )
+    
+    // Check cache first
+    if let cachedImage = MarkerIconCache.shared.getIcon(forKey: cacheKey) {
+      return cachedImage
+    }
+    
+    // Generate new icon
+    let image = PriceMarkerRenderer.render(config: config)
+    
+    // Cache the result
+    MarkerIconCache.shared.setIcon(image, forKey: cacheKey)
+    
+    return image
+  }
+  
+  // MARK: - Image Marker Icon
+  private static func createImageMarkerIcon(_ config: ImageMarkerConfig?) -> UIImage? {
+    guard let config = config else { return nil }
+
+    let imageSource = config.imageBase64 ?? config.imageUrl ?? ""
+
+    // Generate normalized cache key
+    let cacheKey = MarkerIconCache.imageMarkerKey(
+      source: imageSource,
+      width: config.width,
+      height: config.height,
+      cornerRadius: config.cornerRadius
+    )
+
+    // Check cache first
+    if let cachedImage = MarkerIconCache.shared.getIcon(forKey: cacheKey) {
+      return cachedImage
+    }
+
+    var sourceImage: UIImage?
+
+    if let base64 = config.imageBase64,
+       let data = Data(base64Encoded: base64)
+    {
+      sourceImage = UIImage(data: data)
+    } else if let urlString = config.imageUrl {
+      // Check URL image cache first
+      if let cachedURLImage = MarkerIconCache.shared.getURLImage(forKey: urlString) {
+        sourceImage = cachedURLImage
+      } else {
+        // Load URL image on background thread to avoid blocking
+        // Return placeholder and trigger async load
+        loadURLImageAsync(urlString: urlString, cacheKey: cacheKey, config: config)
+        // Return a placeholder image for now
+        sourceImage = createPlaceholderImage(
+          width: CGFloat(config.width),
+          height: CGFloat(config.height)
+        )
+      }
+    }
+
+    let image = renderImageMarker(sourceImage: sourceImage, config: config)
+
+    // Cache the result (will be replaced when async image loads)
+    MarkerIconCache.shared.setIcon(image, forKey: cacheKey)
+
+    return image
+  }
+
+  /// Load URL image asynchronously using URLSession (proper HTTP handling)
+  private static func loadURLImageAsync(urlString: String, cacheKey: String, config: ImageMarkerConfig) {
+    guard let url = URL(string: urlString) else { return }
+
+    var request = URLRequest(url: url)
+    request.timeoutInterval = 10 // 10 second timeout
+    request.cachePolicy = .returnCacheDataElseLoad
+
+    URLSession.shared.dataTask(with: request) { data, response, error in
+      if let error = error {
+        #if DEBUG
+        print("[MarkerIconFactory] Failed to load image from \(urlString): \(error.localizedDescription)")
+        #endif
+        return
+      }
+
+      // Validate HTTP response
+      if let httpResponse = response as? HTTPURLResponse,
+         !(200...299).contains(httpResponse.statusCode) {
+        #if DEBUG
+        print("[MarkerIconFactory] HTTP \(httpResponse.statusCode) for image \(urlString)")
+        #endif
+        return
+      }
+
+      guard let data = data, let image = UIImage(data: data) else {
+        return
+      }
+
+      // Cache and render on main thread
+      DispatchQueue.main.async {
+        MarkerIconCache.shared.setURLImage(image, forKey: urlString)
+
+        // Render the final marker icon with the loaded image
+        let finalIcon = renderImageMarker(sourceImage: image, config: config)
+        MarkerIconCache.shared.setIcon(finalIcon, forKey: cacheKey)
+
+        // Post notification for markers to refresh their icons
+        NotificationCenter.default.post(
+          name: Notification.Name("MarkerIconLoaded"),
+          object: nil,
+          userInfo: ["cacheKey": cacheKey, "icon": finalIcon]
+        )
+      }
+    }.resume()
+  }
+
+  /// Create a placeholder image while URL image loads
+  private static func createPlaceholderImage(width: CGFloat, height: CGFloat) -> UIImage {
+    let renderer = UIGraphicsImageRenderer(size: CGSize(width: width, height: height))
+    return renderer.image { context in
+      let rect = CGRect(x: 0, y: 0, width: width, height: height)
+      UIColor.lightGray.withAlphaComponent(0.3).setFill()
+      UIBezierPath(roundedRect: rect, cornerRadius: width * 0.1).fill()
+    }
+  }
+
+  /// Render image marker with given source image
+  private static func renderImageMarker(sourceImage: UIImage?, config: ImageMarkerConfig) -> UIImage {
+    let width = CGFloat(config.width)
+    let height = CGFloat(config.height)
+    let cornerRadius = CGFloat(config.cornerRadius)
+    let borderWidth = CGFloat(config.borderWidth)
+
+    let borderColorValue = config.borderColor.toMarkerColor()
+    let borderColor = UIColor(
+      red: CGFloat(borderColorValue.r) / 255,
+      green: CGFloat(borderColorValue.g) / 255,
+      blue: CGFloat(borderColorValue.b) / 255,
+      alpha: CGFloat(borderColorValue.a) / 255
+    )
+
+    let renderer = UIGraphicsImageRenderer(
+      size: CGSize(width: width, height: height)
+    )
+    return renderer.image { context in
+      let rect = CGRect(x: 0, y: 0, width: width, height: height)
+      let path = UIBezierPath(roundedRect: rect, cornerRadius: cornerRadius)
+
+      // Clip to rounded rect
+      path.addClip()
+
+      // Draw image
+      if let image = sourceImage {
+        image.draw(in: rect)
+      } else {
+        UIColor.lightGray.setFill()
+        UIRectFill(rect)
+      }
+
+      // Draw border
+      if borderWidth > 0 {
+        borderColor.setStroke()
+        path.lineWidth = borderWidth
+        path.stroke()
+      }
+    }
+  }
+  
+  // MARK: - Cache Management
+  static func clearCache() {
+    MarkerIconCache.shared.clear()
+  }
+}

package/ios/MarkerRenderer/PriceMarkerRenderer.swift

@@ -0,0 +1,140 @@
+// ios/MarkerRenderer/PriceMarkerRenderer.swift
+import UIKit
+
+class PriceMarkerRenderer {
+  
+  struct Style {
+    var price: String
+    var currency: String
+    var selected: Bool
+    var backgroundColor: UIColor
+    var selectedBackgroundColor: UIColor
+    var textColor: UIColor
+    var selectedTextColor: UIColor
+    var fontSize: CGFloat
+    var paddingHorizontal: CGFloat
+    var paddingVertical: CGFloat
+    var shadowOpacity: Float
+    
+    static func fromConfig(_ config: PriceMarkerStyle?) -> Style {
+      guard let config = config else {
+        return Style(
+          price: "0",
+          currency: "UZS",
+          selected: false,
+          backgroundColor: .white,
+          selectedBackgroundColor: UIColor(red: 255/255, green: 59/255, blue: 48/255, alpha: 1),
+          textColor: UIColor(red: 51/255, green: 51/255, blue: 51/255, alpha: 1),
+          selectedTextColor: .white,
+          fontSize: 10,
+          paddingHorizontal: 8,
+          paddingVertical: 6,
+          shadowOpacity: 0.12
+        )
+      }
+      
+      return Style(
+        price: config.price,
+        currency: config.currency,
+        selected: config.selected,
+        backgroundColor: PriceMarkerRenderer.variantToUIColor(config.backgroundColor) ?? .white,
+        selectedBackgroundColor: PriceMarkerRenderer.variantToUIColor(config.selectedBackgroundColor)
+          ?? UIColor(red: 255/255, green: 59/255, blue: 48/255, alpha: 1),
+        textColor: PriceMarkerRenderer.variantToUIColor(config.textColor)
+          ?? UIColor(red: 51/255, green: 51/255, blue: 51/255, alpha: 1),
+        selectedTextColor: PriceMarkerRenderer.variantToUIColor(config.selectedTextColor) ?? .white,
+        fontSize: CGFloat(config.fontSize ?? 10),
+        paddingHorizontal: CGFloat(config.paddingHorizontal ?? 8),
+        paddingVertical: CGFloat(config.paddingVertical ?? 6),
+        shadowOpacity: Float(config.shadowOpacity ?? 0.12)
+      )
+    }
+  }
+  
+  /// Converts a Variant_String_MarkerColor (Nitro generated type) to UIColor.
+  private static func variantToUIColor(_ value: Variant_String_MarkerColor?) -> UIColor? {
+    guard let value = value else { return nil }
+    let mc: MarkerColor
+    switch value {
+    case .first(let hex):
+      mc = ColorValue.first(hex).toMarkerColor()
+    case .second(let markerColor):
+      mc = markerColor
+    }
+    return UIColor(
+      red: CGFloat(mc.r) / 255,
+      green: CGFloat(mc.g) / 255,
+      blue: CGFloat(mc.b) / 255,
+      alpha: CGFloat(mc.a) / 255
+    )
+  }
+  
+  static func render(config: PriceMarkerStyle?) -> UIImage {
+    let style = Style.fromConfig(config)
+    
+    // Build text: "9M UZS"
+    let text = "\(style.price) \(style.currency)"
+    
+    // Font
+    let font = UIFont.systemFont(ofSize: style.fontSize, weight: .light)
+    let attributes: [NSAttributedString.Key: Any] = [.font: font]
+    let textSize = text.size(withAttributes: attributes)
+    
+    // Calculate size with padding
+    let width = textSize.width + style.paddingHorizontal * 2
+    let height = textSize.height + style.paddingVertical * 2
+    
+    // Reduced shadow size for smaller textures (was 20, now 8)
+    let shadowBlur: CGFloat = 8
+    let shadowOffset: CGFloat = 2
+    let canvasWidth = width + shadowBlur * 2
+    let canvasHeight = height + shadowBlur + shadowOffset + shadowBlur / 2
+    
+    let renderer = UIGraphicsImageRenderer(size: CGSize(width: canvasWidth, height: canvasHeight))
+    
+    return renderer.image { context in
+      let ctx = context.cgContext
+      
+      // Pill rect (centered with shadow space)
+      let pillRect = CGRect(
+        x: shadowBlur,
+        y: shadowBlur / 2,
+        width: width,
+        height: height
+      )
+      
+      // Corner radius = half height for pill shape
+      let cornerRadius = height / 2
+      let path = UIBezierPath(roundedRect: pillRect, cornerRadius: cornerRadius)
+      
+      // Shadow
+      ctx.saveGState()
+      ctx.setShadow(
+        offset: CGSize(width: 0, height: shadowOffset),
+        blur: shadowBlur,
+        color: UIColor.black.withAlphaComponent(CGFloat(style.shadowOpacity)).cgColor
+      )
+      
+      // Background
+      let bgColor = style.selected ? style.selectedBackgroundColor : style.backgroundColor
+      bgColor.setFill()
+      path.fill()
+      
+      ctx.restoreGState()
+      
+      // Text
+      let textColor = style.selected ? style.selectedTextColor : style.textColor
+      let textRect = CGRect(
+        x: pillRect.origin.x + style.paddingHorizontal,
+        y: pillRect.origin.y + style.paddingVertical,
+        width: textSize.width,
+        height: textSize.height
+      )
+      
+      text.draw(in: textRect, withAttributes: [
+        .font: font,
+        .foregroundColor: textColor
+      ])
+    }
+  }
+}