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

package/ios/Providers/Google/GoogleMapProvider.swift

@@ -0,0 +1,342 @@
+import Foundation
+import GoogleMaps
+import GoogleMapsUtils
+import UIKit
+
+/// Google Maps implementation of MapProviderProtocol
+class GoogleMapProvider: MapProviderProtocol {
+
+  // MARK: - Constants
+
+  private static let defaultLatitude: Double = 41.2995
+  private static let defaultLongitude: Double = 69.2401
+
+  /// Notification fired when an async marker icon finishes loading.
+  static let markerIconLoadedNotification = Notification.Name("MarkerIconLoaded")
+
+  // MARK: - Properties
+
+  // Internal (not private) because extensions in separate files need access.
+  // External consumers interact via MapProviderProtocol.mapView (UIView).
+  let gmsMapView: GMSMapView
+  var mapView: UIView { return gmsMapView }
+
+  private var mapDelegate: GoogleMapDelegate?
+
+  // MARK: - Injected Dependencies (DIP)
+  
+  let clusteringManager: ClusteringManagerProtocol
+  let selectionHandler: MarkerSelectionHandling
+
+  // Rendered markers (internal for cross-file extensions)
+  var renderedClusterMarkers: [GMSMarker] = []
+  var renderedSingleMarkers: [String: GMSMarker] = [:]
+  var nonClusteredMarkers: [String: GMSMarker] = [:]
+  var hiddenNonClusteredIds: Set<String> = []  // Non-clustered markers hidden due to overlap
+  var polylines: [String: GMSPolyline] = [:]
+  var dashedPolylineData: [String: PolylineData] = [:]
+  var polygons: [String: GMSPolygon] = [:]
+  var circles: [String: GMSCircle] = [:]
+  var customUserLocationMarker: GMSMarker?
+  var userLocationImageData: UIImage?
+  var clusterableMarkerData: [String: MarkerData] = [:]
+
+  var selectedMarkerId: String?
+
+  /// Last known user location — used by delegate for my-location button
+  var lastKnownUserLocation: CLLocation?
+
+  static let defaultMarkerSize: CGFloat = 44
+
+  // Cached URL to avoid re-downloading the same image
+  var cachedUserLocationImageUrl: String = ""
+
+  // Throttle timer for clustering (used by +Clustering extension)
+  var throttleTimer: Timer?
+
+  // Track zoom level to detect cluster structure changes (used by +Clustering animation)
+  var lastClusteredZoom: Float = -1
+  var clusteringDirty: Bool = false
+
+  // MARK: - Protocol Properties
+
+  var initialRegion: Region? = Region(latitude: defaultLatitude, longitude: defaultLongitude, latitudeDelta: 0.15, longitudeDelta: 0.15) {
+    didSet {
+      // Only move to initial region on first set, not on every re-render
+      guard oldValue == nil else { return }
+      updateCameraToInitialRegion()
+    }
+  }
+
+  var region: Region? {
+    didSet {
+      guard let region = region else { return }
+      // Guard: skip if camera is already at this position (prevent loops)
+      let currentPos = gmsMapView.camera
+      let latDiff = Swift.abs(currentPos.target.latitude - region.latitude)
+      let lonDiff = Swift.abs(currentPos.target.longitude - region.longitude)
+      guard latDiff > 0.0001 || lonDiff > 0.0001 else { return }
+      
+      let camera = GMSCameraPosition.camera(
+        withLatitude: region.latitude,
+        longitude: region.longitude,
+        zoom: calculateZoom(for: region)
+      )
+      gmsMapView.animate(to: camera)
+    }
+  }
+
+  var showsUserLocation: Bool? {
+    didSet {
+      // Only show native blue dot when no custom image is set
+      if userLocationImage.isEmpty {
+        gmsMapView.isMyLocationEnabled = showsUserLocation ?? false
+      } else {
+        gmsMapView.isMyLocationEnabled = false
+      }
+    }
+  }
+
+  var zoomEnabled: Bool? {
+    didSet { gmsMapView.settings.zoomGestures = zoomEnabled ?? true }
+  }
+
+  var scrollEnabled: Bool? {
+    didSet { gmsMapView.settings.scrollGestures = scrollEnabled ?? true }
+  }
+
+  var rotateEnabled: Bool? {
+    didSet { gmsMapView.settings.rotateGestures = rotateEnabled ?? true }
+  }
+
+  var pitchEnabled: Bool? {
+    didSet { gmsMapView.settings.tiltGestures = pitchEnabled ?? true }
+  }
+
+  var mapType: MapType? {
+    didSet { gmsMapView.mapType = convertMapType(mapType) }
+  }
+
+  var clusterConfig: ClusterConfig? {
+    didSet {
+      updateClusterConfig()
+    }
+  }
+
+  var customMapStyle: [MapStyleElement]? {
+    didSet { applyMapStyle() }
+  }
+
+  var darkMode: Bool? {
+    didSet { applyDarkMode() }
+  }
+
+  var mapPadding: EdgePadding = EdgePadding(top: 0, right: 0, bottom: 0, left: 0) {
+    didSet {
+      gmsMapView.padding = UIEdgeInsets(
+        top: mapPadding.top,
+        left: mapPadding.left,
+        bottom: mapPadding.bottom,
+        right: mapPadding.right
+      )
+    }
+  }
+
+  var showsTraffic: Bool? {
+    didSet { gmsMapView.isTrafficEnabled = showsTraffic ?? false }
+  }
+
+  var showsBuildings: Bool? {
+    didSet { gmsMapView.isBuildingsEnabled = showsBuildings ?? true }
+  }
+
+  var showsCompass: Bool? {
+    didSet { gmsMapView.settings.compassButton = showsCompass ?? true }
+  }
+
+  var minZoom: Double = 1 {
+    didSet { applyZoomLimits() }
+  }
+
+  var maxZoom: Double = 22 {
+    didSet { applyZoomLimits() }
+  }
+
+  var userTrackingMode: UserTrackingMode?
+
+  var userLocationImage: String = "" {
+    didSet {
+      guard userLocationImage != oldValue else { return }
+      setupCustomUserLocationMarker()
+    }
+  }
+
+  var userLocationSize: Double = 40 {
+    didSet {
+      guard userLocationSize != oldValue else { return }
+      setupCustomUserLocationMarker()
+    }
+  }
+
+  var userLocationAnchor: Point? {
+    didSet {
+      // Update anchor on existing custom marker
+      if let anchor = userLocationAnchor {
+        customUserLocationMarker?.groundAnchor = CGPoint(x: anchor.x, y: anchor.y)
+      } else {
+        customUserLocationMarker?.groundAnchor = CGPoint(x: 0.5, y: 0.5)
+      }
+    }
+  }
+
+  private func applyZoomLimits() {
+    gmsMapView.setMinZoom(Float(minZoom), maxZoom: Float(maxZoom))
+  }
+
+  // MARK: - Callbacks
+
+  var onPress: ((MapPressEvent) -> Void)?
+  var onLongPress: ((MapPressEvent) -> Void)?
+  var onMapReady: (() -> Void)?
+  var onRegionChange: ((RegionChangeEvent) -> Void)?
+  var onRegionChangeComplete: ((RegionChangeEvent) -> Void)?
+  var onMarkerPress: ((MarkerPressEvent) -> Void)?
+  var onMarkerDragStart: ((MarkerDragEvent) -> Void)?
+  var onMarkerDrag: ((MarkerDragEvent) -> Void)?
+  var onMarkerDragEnd: ((MarkerDragEvent) -> Void)?
+  var onClusterPress: ((ClusterPressEvent) -> Void)?
+  var onError: ((MapError) -> Void)?
+  var onUserTrackingModeChange: ((UserTrackingMode) -> Void)?
+  var onMapIdle: (() -> Void)?
+  var onPolylinePress: ((String) -> Void)?
+  var onPolygonPress: ((String) -> Void)?
+  var onCirclePress: ((String) -> Void)?
+
+  // MARK: - Initialization
+  
+  /// Creates a GoogleMapProvider with injected dependencies.
+  /// Uses default production implementations if none provided.
+  ///
+  /// - Parameters:
+  ///   - clusteringManager: Clustering logic handler (default: ClusteringManager)
+  ///   - selectionHandler: Marker selection handler (default: MarkerSelectionHandler.shared)
+  init(
+    clusteringManager: ClusteringManagerProtocol = ClusteringManager(),
+    selectionHandler: MarkerSelectionHandling = MarkerSelectionHandler.shared
+  ) {
+    self.clusteringManager = clusteringManager
+    self.selectionHandler = selectionHandler
+    
+    let camera = GMSCameraPosition.camera(
+      withLatitude: Self.defaultLatitude,
+      longitude: Self.defaultLongitude,
+      zoom: 10
+    )
+
+    // Use GMSMapViewOptions (required for Google Maps SDK v10.0+)
+    let options = GMSMapViewOptions()
+    options.camera = camera
+    options.frame = .zero
+    
+    let mapView = GMSMapView(options: options)
+    mapView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+    self.gmsMapView = mapView
+
+    setupIconLoadNotification()
+  }
+
+  deinit {
+    NotificationCenter.default.removeObserver(self)
+  }
+
+  // MARK: - Lifecycle
+
+  func setup() {
+    gmsMapView.settings.myLocationButton = false // Always hidden — consumers use centerOnUserLocation()
+    mapDelegate = GoogleMapDelegate(provider: self)
+    gmsMapView.delegate = mapDelegate
+  }
+
+  // MARK: - Map Style
+
+  func setMapStyle(_ style: [MapStyleElement]?) {
+    customMapStyle = style
+  }
+
+  func setDarkMode(_ enabled: Bool) {
+    darkMode = enabled
+  }
+
+  private func applyMapStyle() {
+    guard let styleElements = customMapStyle, !styleElements.isEmpty else {
+      gmsMapView.mapStyle = nil
+      return
+    }
+
+    do {
+      let jsonArray = styleElements.map { element -> [String: Any] in
+        var dict: [String: Any] = [:]
+        if let featureType = element.featureType {
+          dict["featureType"] = featureType
+        }
+        if let elementType = element.elementType {
+          dict["elementType"] = elementType
+        }
+
+        dict["stylers"] = element.stylers.map { styler -> [String: Any] in
+          var s: [String: Any] = [:]
+          if let color = styler.color { s["color"] = color }
+          if let visibility = styler.visibility { s["visibility"] = visibility }
+          if let weight = styler.weight { s["weight"] = weight }
+          if let saturation = styler.saturation { s["saturation"] = saturation }
+          if let lightness = styler.lightness { s["lightness"] = lightness }
+          if let gamma = styler.gamma { s["gamma"] = gamma }
+          return s
+        }
+        return dict
+      }
+
+      let jsonData = try JSONSerialization.data(withJSONObject: jsonArray)
+      let jsonString = String(data: jsonData, encoding: .utf8) ?? "[]"
+      gmsMapView.mapStyle = try GMSMapStyle(jsonString: jsonString)
+    } catch {
+      // Surface errors via onError instead of silent print
+      onError?(MapError(code: "STYLE_ERROR", message: "Failed to apply map style: \(error.localizedDescription)"))
+    }
+  }
+
+  private func applyDarkMode() {
+    if let isDark = darkMode {
+      gmsMapView.overrideUserInterfaceStyle = isDark ? .dark : .light
+    }
+  }
+
+  // MARK: - Helper Methods
+
+  private func updateCameraToInitialRegion() {
+    guard let region = initialRegion else { return }
+
+    let camera = GMSCameraPosition.camera(
+      withLatitude: region.latitude,
+      longitude: region.longitude,
+      zoom: calculateZoom(for: region)
+    )
+    gmsMapView.animate(to: camera)
+  }
+
+  func calculateZoom(for region: Region) -> Float {
+    return Float(MapStyleProvider.shared.zoomFromDeltas(
+      latDelta: region.latitudeDelta,
+      lonDelta: region.longitudeDelta
+    ))
+  }
+
+  private func convertMapType(_ type: MapType?) -> GMSMapViewType {
+    switch type {
+    case .satellite: return .satellite
+    case .hybrid: return .hybrid
+    case .standard, .none: return .normal
+    }
+  }
+
+}

package/ios/Providers/MapProviderFactory.swift

@@ -0,0 +1,17 @@
+import Foundation
+
+/// Factory that creates the correct map provider based on the provider type.
+/// When new providers are added (Apple, Yandex), extend this factory.
+enum MapProviderFactory {
+
+  static func create(for provider: MapProvider) -> MapProviderProtocol {
+    switch provider {
+    case .google:
+      return GoogleMapProvider()
+    case .apple:
+      fatalError("Apple Maps provider is not yet implemented. Coming in Phase 4.")
+    case .yandex:
+      fatalError("Yandex Maps provider is not yet implemented.")
+    }
+  }
+}

package/ios/Providers/MapProviderProtocol.swift

@@ -1,5 +1,6 @@
 import Foundation
 import UIKit
+import CoreLocation
 
 /// Protocol that all map providers must implement
 /// This allows the library to support multiple map backends (Google, Apple, Yandex)
@@ -13,16 +14,26 @@ protocol MapProviderProtocol: AnyObject {
   // MARK: - Properties
   
   var initialRegion: Region? { get set }
+  var region: Region? { get set }
   var showsUserLocation: Bool? { get set }
   var zoomEnabled: Bool? { get set }
   var scrollEnabled: Bool? { get set }
   var rotateEnabled: Bool? { get set }
   var pitchEnabled: Bool? { get set }
   var mapType: MapType? { get set }
-  var showsMyLocationButton: Bool? { get set }
   var clusterConfig: ClusterConfig? { get set }
   var customMapStyle: [MapStyleElement]? { get set }
   var darkMode: Bool? { get set }
+  var mapPadding: EdgePadding { get set }
+  var showsTraffic: Bool? { get set }
+  var showsBuildings: Bool? { get set }
+  var showsCompass: Bool? { get set }
+  var minZoom: Double { get set }
+  var maxZoom: Double { get set }
+  var userTrackingMode: UserTrackingMode? { get set }
+  var userLocationImage: String { get set }
+  var userLocationSize: Double { get set }
+  var userLocationAnchor: Point? { get set }
   
   // MARK: - Callbacks
   
@@ -30,6 +41,7 @@ protocol MapProviderProtocol: AnyObject {
   var onLongPress: ((MapPressEvent) -> Void)? { get set }
   var onMapReady: (() -> Void)? { get set }
   var onRegionChange: ((RegionChangeEvent) -> Void)? { get set }
+  var onUserTrackingModeChange: ((UserTrackingMode) -> Void)? { get set }
   var onRegionChangeComplete: ((RegionChangeEvent) -> Void)? { get set }
   var onMarkerPress: ((MarkerPressEvent) -> Void)? { get set }
   var onMarkerDragStart: ((MarkerDragEvent) -> Void)? { get set }
@@ -37,20 +49,30 @@ protocol MapProviderProtocol: AnyObject {
   var onMarkerDragEnd: ((MarkerDragEvent) -> Void)? { get set }
   var onClusterPress: ((ClusterPressEvent) -> Void)? { get set }
   var onError: ((MapError) -> Void)? { get set }
+  var onMapIdle: (() -> Void)? { get set }
+  var onPolylinePress: ((String) -> Void)? { get set }
+  var onPolygonPress: ((String) -> Void)? { get set }
+  var onCirclePress: ((String) -> Void)? { get set }
   
   // MARK: - Lifecycle
   
   func setup()
   func updateSettings()
+
+  // MARK: - User Location
+  func updateUserLocation(_ location: CLLocation, heading: CLHeading?)
   
   // MARK: - Camera Methods
   
   func animateToRegion(_ region: Region, duration: Double?)
   func fitToCoordinates(_ coordinates: [Coordinate], edgePadding: EdgePadding?, animated: Bool?)
+  func fitToSuppliedMarkers(_ markerIds: [String], edgePadding: EdgePadding?, animated: Bool?)
   func animateCamera(_ camera: Camera, duration: Double?)
   func setCamera(_ camera: Camera)
   func getCamera() -> Camera
   func getMapBoundaries() -> MapBoundaries?
+  func pointForCoordinate(_ coordinate: Coordinate) -> Point
+  func coordinateForPoint(_ point: Point) -> Coordinate
   
   // MARK: - Marker Management
   
@@ -60,6 +82,7 @@ protocol MapProviderProtocol: AnyObject {
   func removeMarker(_ id: String)
   func clearMarkers()
   func selectMarker(_ id: String)
+  func deselectMarker()
   
   // MARK: - Clustering
   
@@ -75,4 +98,28 @@ protocol MapProviderProtocol: AnyObject {
   // MARK: - Region
   
   func getCurrentRegion() -> Region
+
+  /// Animate camera to the user's current location
+  func centerOnUserLocation()
+  
+  // MARK: - Polyline Management
+  
+  func addPolyline(_ polyline: PolylineData)
+  func updatePolyline(_ polyline: PolylineData)
+  func removePolyline(_ id: String)
+  func clearPolylines()
+  
+  // MARK: - Polygon Management
+  
+  func addPolygon(_ polygon: PolygonData)
+  func updatePolygon(_ polygon: PolygonData)
+  func removePolygon(_ id: String)
+  func clearPolygons()
+  
+  // MARK: - Circle Management
+  
+  func addCircle(_ circle: CircleData)
+  func updateCircle(_ circle: CircleData)
+  func removeCircle(_ id: String)
+  func clearCircles()
 }

package/ios/Shared/ClusterConfig+Factory.swift

@@ -22,8 +22,8 @@ extension ClusterConfig {
     let bc: Variant_String_MarkerColor = existing?.borderColor
       ?? .second(MarkerColor(r: 255, g: 255, b: 255, a: 255))
     let anim: Bool = existing?.animatesClusters ?? true
+    let animReappear: Bool = existing?.animateOnReappear ?? true
     let dur: Double = existing?.animationDuration ?? 0.3
-    let style: ClusterAnimationStyle = existing?.animationStyle ?? .default
     let realtime: Bool = existing?.realtimeClustering ?? false
     let vpPad: Double = existing?.renderBuffer ?? 0
     let throttle: Double = existing?.throttleInterval ?? 150
@@ -39,8 +39,8 @@ extension ClusterConfig {
       borderWidth: bw,
       borderColor: bc,
       animatesClusters: anim,
+      animateOnReappear: animReappear,
       animationDuration: dur,
-      animationStyle: style,
       realtimeClustering: realtime,
       renderBuffer: vpPad,
       throttleInterval: throttle

package/ios/Shared/MapStyleProvider.swift

@@ -16,8 +16,10 @@ protocol MapStyleProviding {
   /// Converts altitude to approximate zoom level
   func zoomFromAltitude(_ altitude: Double) -> Double
   
-  /// Gets the dark mode JSON style for Google Maps
-  var googleDarkModeStyle: String { get }
+  /// Gets the dark mode JSON style for the current provider.
+  /// Currently uses Google Maps JSON format; future providers may need
+  /// their own styling format (Apple: MKMapConfiguration, Yandex: custom).
+  var darkModeStyle: String { get }
 }
 
 // MARK: - Implementation
@@ -71,7 +73,7 @@ final class MapStyleProvider: MapStyleProviding {
     return clamp(zoom, min: minZoom, max: maxZoom)
   }
   
-  var googleDarkModeStyle: String {
+  var darkModeStyle: String {
     return Self.darkModeJSON
   }
   
@@ -116,7 +118,7 @@ final class MockMapStyleProvider: MapStyleProviding {
   var mockZoom: Double = 10.0
   var mockAltitude: Double = 40000.0
   
-  var googleDarkModeStyle: String {
+  var darkModeStyle: String {
     return "[]" // Empty JSON for testing
   }
   

package/ios/Shared/MarkerSelectionHandler.swift

@@ -80,8 +80,11 @@ final class MarkerSelectionHandler: MarkerSelectionHandling {
       zIndex: markerData.zIndex,
       anchor: markerData.anchor,
       config: updatedConfig,
+      accessibilityLabel: markerData.accessibilityLabel,
       clusteringEnabled: markerData.clusteringEnabled,
-      animation: markerData.animation
+      animation: markerData.animation,
+      animationDuration: markerData.animationDuration,
+      animateOnReappear: markerData.animateOnReappear
     )
   }
 }

package/ios/Utils/ColorValueExtension.swift

@@ -1,101 +1,80 @@
 import Foundation
 import UIKit
 
+// MARK: - Shared Hex Parser (DRY)
+// Single implementation used by both ColorValue and Variant_String_MarkerColor
+
+private func parseHexColor(_ hex: String) -> MarkerColor {
+  var hexSanitized = hex.trimmingCharacters(in: .whitespacesAndNewlines)
+  hexSanitized = hexSanitized.replacingOccurrences(of: "#", with: "")
+
+  var rgb: UInt64 = 0
+  Scanner(string: hexSanitized).scanHexInt64(&rgb)
+
+  let r, g, b: Double
+  if hexSanitized.count == 6 {
+    r = Double((rgb & 0xFF0000) >> 16)
+    g = Double((rgb & 0x00FF00) >> 8)
+    b = Double(rgb & 0x0000FF)
+  } else if hexSanitized.count == 3 {
+    r = Double((rgb & 0xF00) >> 8) * 17
+    g = Double((rgb & 0x0F0) >> 4) * 17
+    b = Double(rgb & 0x00F) * 17
+  } else {
+    r = 0; g = 0; b = 0
+  }
+
+  return MarkerColor(r: r, g: g, b: b, a: 255)
+}
+
+// MARK: - MarkerColor → UIColor
+
+extension MarkerColor {
+  /// Convert MarkerColor directly to UIColor
+  func toUIColor() -> UIColor {
+    return UIColor(
+      red: CGFloat(self.r) / 255,
+      green: CGFloat(self.g) / 255,
+      blue: CGFloat(self.b) / 255,
+      alpha: CGFloat(self.a) / 255
+    )
+  }
+}
+
 // MARK: - ColorValue Extension
-// Shared extension for converting ColorValue (hex string or MarkerColor) to MarkerColor
+
 extension ColorValue {
   /// Extract MarkerColor from ColorValue, parsing hex string if needed
   func toMarkerColor() -> MarkerColor {
     switch self {
     case .first(let hexString):
-      return ColorValue.parseHex(hexString)
+      return parseHexColor(hexString)
     case .second(let markerColor):
       return markerColor
     }
   }
 
-  /// Parse hex color string to MarkerColor
-  private static func parseHex(_ hex: String) -> MarkerColor {
-    var hexSanitized = hex.trimmingCharacters(in: .whitespacesAndNewlines)
-    hexSanitized = hexSanitized.replacingOccurrences(of: "#", with: "")
-
-    var rgb: UInt64 = 0
-    Scanner(string: hexSanitized).scanHexInt64(&rgb)
-
-    let r, g, b: Double
-    if hexSanitized.count == 6 {
-      r = Double((rgb & 0xFF0000) >> 16)
-      g = Double((rgb & 0x00FF00) >> 8)
-      b = Double(rgb & 0x0000FF)
-    } else if hexSanitized.count == 3 {
-      r = Double((rgb & 0xF00) >> 8) * 17
-      g = Double((rgb & 0x0F0) >> 4) * 17
-      b = Double(rgb & 0x00F) * 17
-    } else {
-      r = 0; g = 0; b = 0
-    }
-
-    return MarkerColor(r: r, g: g, b: b, a: 255)
-  }
-}
-
-// MARK: - UIColor Helper
-extension ColorValue {
   /// Convert ColorValue directly to UIColor
   func toUIColor() -> UIColor {
-    let color = self.toMarkerColor()
-    return UIColor(
-      red: CGFloat(color.r) / 255,
-      green: CGFloat(color.g) / 255,
-      blue: CGFloat(color.b) / 255,
-      alpha: CGFloat(color.a) / 255
-    )
+    return self.toMarkerColor().toUIColor()
   }
 }
 
 // MARK: - Variant_String_MarkerColor Extension
 // Nitrogen generates this as a separate type from ColorValue (same shape)
 // when the field is optional in the struct. We mirror the same helpers.
+
 extension Variant_String_MarkerColor {
   func toMarkerColor() -> MarkerColor {
     switch self {
     case .first(let hexString):
-      return Variant_String_MarkerColor.parseHex(hexString)
+      return parseHexColor(hexString)
     case .second(let markerColor):
       return markerColor
     }
   }
 
   func toUIColor() -> UIColor {
-    let color = self.toMarkerColor()
-    return UIColor(
-      red: CGFloat(color.r) / 255,
-      green: CGFloat(color.g) / 255,
-      blue: CGFloat(color.b) / 255,
-      alpha: CGFloat(color.a) / 255
-    )
-  }
-
-  private static func parseHex(_ hex: String) -> MarkerColor {
-    var hexSanitized = hex.trimmingCharacters(in: .whitespacesAndNewlines)
-    hexSanitized = hexSanitized.replacingOccurrences(of: "#", with: "")
-
-    var rgb: UInt64 = 0
-    Scanner(string: hexSanitized).scanHexInt64(&rgb)
-
-    let r, g, b: Double
-    if hexSanitized.count == 6 {
-      r = Double((rgb & 0xFF0000) >> 16)
-      g = Double((rgb & 0x00FF00) >> 8)
-      b = Double(rgb & 0x0000FF)
-    } else if hexSanitized.count == 3 {
-      r = Double((rgb & 0xF00) >> 8) * 17
-      g = Double((rgb & 0x0F0) >> 4) * 17
-      b = Double(rgb & 0x00F) * 17
-    } else {
-      r = 0; g = 0; b = 0
-    }
-
-    return MarkerColor(r: r, g: g, b: b, a: 255)
+    return self.toMarkerColor().toUIColor()
   }
 }