@exterio/react-native-yamap-lite 1.0.1

package/ios/Components/Circle.swift

@@ -0,0 +1,108 @@
+import Foundation
+import React
+import YandexMapsMobile
+
+@objc(YamapLiteCircleComponentDelegate)
+public protocol YamapLiteCircleComponentDelegate {
+  func onCirclePress(point: [String: Double])
+}
+
+@objc(YamapLiteCircle)
+public class YamapLiteCircle: UIView, MapObjectTapHandler {
+  @objc public weak var delegate: YamapLiteCircleComponentDelegate? = nil
+  public var mapObject: YMKMapObject?
+  @objc public var radius: Float = 100 {
+    didSet {
+      updateGeometry()
+      updateCircle()
+    }
+  }
+
+  @objc public var fillColor: UIColor = .black {
+    didSet {
+      updateCircle()
+    }
+  }
+
+  @objc public var strokeColor: UIColor = .black {
+    didSet {
+      updateCircle()
+    }
+  }
+
+  @objc public var strokeWidth: Float = 1 {
+    didSet {
+      updateCircle()
+    }
+  }
+
+  @objc public var zIndex: Float = 1 {
+    didSet {
+      updateCircle()
+    }
+  }
+
+  @objc public var circleCenter = YMKPoint(latitude: 55.951244, longitude: 38.718423) {
+    didSet {
+      updateGeometry()
+      updateCircle()
+    }
+  }
+
+  @objc public var handled = true
+  @objc public var circle: YMKCircle
+  @objc var listener: MarkerTapListener?
+  override init(frame: CGRect) {
+    circleCenter = YMKPoint(latitude: 0, longitude: 0)
+    radius = 0.0
+    fillColor = UIColor.black
+    strokeColor = UIColor.black
+    zIndex = 1
+    strokeWidth = 1
+    handled = true
+    circle = YMKCircle(center: circleCenter, radius: radius)
+    super.init(frame: frame)
+  }
+
+  @available(*, unavailable)
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) is not implemented.")
+  }
+
+  @objc public func updateGeometry() {
+    guard circleCenter.latitude.isFinite, circleCenter.longitude.isFinite, radius.isFinite
+    else { return }
+    circle = YMKCircle(center: circleCenter, radius: radius)
+  }
+
+  public func onMapObjectTap(point _: YMKPoint) {
+    delegate?.onCirclePress(point: [
+      "lat": circleCenter.latitude,
+      "lon": circleCenter.longitude,
+    ])
+  }
+
+  @objc public func setMapObject(object: YMKMapObject) {
+    if let polygonObject = object as? YMKCircleMapObject {
+      mapObject = polygonObject
+      mapObject?.userData = self
+      listener = MarkerTapListener()
+      mapObject?.addTapListener(with: listener!)
+      updateCircle()
+    }
+  }
+
+  @objc public func setCircleCenter(latitude: Double, longitude: Double) {
+    circleCenter = YMKPoint(latitude: latitude, longitude: longitude)
+  }
+
+  @objc public func updateCircle() {
+    if let circleObject = mapObject as? YMKCircleMapObject, circleObject.isValid {
+      circleObject.geometry = circle
+      circleObject.zIndex = zIndex
+      circleObject.fillColor = fillColor
+      circleObject.strokeColor = strokeColor
+      circleObject.strokeWidth = strokeWidth
+    }
+  }
+}

package/ios/Components/ClusteredYamap.swift

@@ -0,0 +1,190 @@
+import Foundation
+import React
+import UIKit
+import YandexMapsMobile
+import os.log
+
+private let clusterLogger = OSLog(subsystem: "com.yamaplite", category: "ClusteredYamapView")
+
+@objc(ClusteredYamapView)
+public class ClusteredYamapView: YamapView {
+  @objc public var placemarks: [YMKPlacemarkMapObject] = []
+  @objc public var clusterCollection: YMKClusterizedPlacemarkCollection?
+  @objc public var clusterColor: UIColor = .red
+  private var clusterListener: ClusterListener?
+
+  private let FONT_SIZE: CGFloat = 45
+  private let MARGIN_SIZE: CGFloat = 9
+  private let STROKE_SIZE: CGFloat = 9
+
+  override init(frame: CGRect) {
+    super.init(frame: frame)
+    clusterListener = ClusterListener(callback: nil, delegate: delegate)
+    clusterListener?.setClusteredView(self)
+  }
+
+  @available(*, unavailable)
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  private func initializeClusterCollection() {
+    guard clusterCollection == nil else { return }
+    guard let map = mapView?.mapWindow?.map else {
+      DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) { [weak self] in
+        self?.initializeClusterCollection()
+      }
+      return
+    }
+
+    if clusterListener == nil {
+      clusterListener = ClusterListener(callback: nil, delegate: delegate)
+    }
+    clusterListener?.setClusteredView(self)
+    clusterCollection = map.mapObjects.addClusterizedPlacemarkCollection(with: clusterListener!)
+  }
+
+  @objc override public func insertReactSubview(_ subview: UIView!, at atIndex: Int) {
+    let isMarker =
+      !(subview is YMKMapView) && subview.responds(to: Selector(("contentView")))
+      && (subview.value(forKey: "contentView") as? YamapLiteMarker) != nil
+
+    let isCircle =
+      !(subview is YMKMapView) && subview.responds(to: Selector(("contentView")))
+      && (subview.value(forKey: "contentView") as? YamapLiteCircle) != nil
+
+    if isMarker {
+      let safeIndex = min(atIndex, subviews.count)
+      insertSubview(subview, at: safeIndex)
+
+      if let markerView = subview.value(forKey: "contentView") as? YamapLiteMarker {
+        if atIndex < placemarks.count {
+          markerView.setClusterMapObject(placemarks[atIndex])
+        }
+      }
+    } else if isCircle {
+      let safeIndex = min(atIndex, subviews.count)
+      super.insertReactSubview(subview, at: safeIndex)
+    } else {
+      let safeIndex = min(atIndex, subviews.count)
+      super.insertReactSubview(subview, at: safeIndex)
+    }
+  }
+
+  @objc public func setupClusteredMarkers(markers: [YMKPoint]?) {
+    guard let unwrappedMarkers = markers else { return }
+    placemarks.removeAll()
+
+    guard let map = mapView?.mapWindow?.map else {
+      os_log("mapView.mapWindow.map is nil, cannot setup clustered markers", log: clusterLogger, type: .error)
+      DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) { [weak self] in
+        self?.setupClusteredMarkers(markers: unwrappedMarkers)
+      }
+      return
+    }
+
+    if clusterCollection == nil {
+      if clusterListener == nil {
+        clusterListener = ClusterListener(callback: nil, delegate: delegate)
+      }
+      clusterListener?.setClusteredView(self)
+      clusterCollection = map.mapObjects.addClusterizedPlacemarkCollection(with: clusterListener!)
+    }
+
+    guard let collection = clusterCollection else {
+      os_log("clusterCollection is nil after initialization attempt", log: clusterLogger, type: .error)
+      return
+    }
+
+    collection.clear()
+
+    let newPlacemarks: [YMKPlacemarkMapObject] = collection.addEmptyPlacemarks(
+      with: unwrappedMarkers)
+    placemarks.append(contentsOf: newPlacemarks)
+
+    let markerSubviews = subviews.filter { subview in
+      !(subview is YMKMapView) && subview.responds(to: Selector(("contentView")))
+    }
+
+    for i in 0..<min(placemarks.count, markerSubviews.count) {
+      let subview = markerSubviews[i]
+      if let markerView = subview.value(forKey: "contentView") as? YamapLiteMarker {
+        markerView.setClusterMapObject(placemarks[i])
+      }
+    }
+
+    collection.clusterPlacemarks(withClusterRadius: 50, minZoom: 12)
+  }
+
+  @objc override public func removeReactSubview(_ subview: UIView!) {
+    guard let contentView = subview.value(forKey: "contentView") as? UIView else {
+      super.removeReactSubview(subview)
+      return
+    }
+
+    if contentView is YamapLiteMarker {
+      // setupClusteredMarkers owns the placemarks lifecycle (collection.clear + rebuild).
+      // Removing individual placemarks here races with that rebuild, so we only
+      // detach the UIView — the next setupClusteredMarkers call cleans the map object.
+      subview.removeFromSuperview()
+    } else {
+      super.removeReactSubview(subview)
+    }
+  }
+
+  @objc override public func fitAllMarkers() {
+    var markerPoints: [YMKPoint] = []
+
+    for placemark in placemarks {
+      if placemark.isValid {
+        markerPoints.append(placemark.geometry)
+      }
+    }
+
+    if markerPoints.isEmpty {
+      return
+    }
+
+    fitMakers(markerPoints)
+  }
+
+  @objc public func clusterImage(clusterSize: Int) -> UIImage? {
+    let text = NSString(string: String(clusterSize))
+    let font = UIFont.systemFont(ofSize: FONT_SIZE)
+    let attributes: [NSAttributedString.Key: Any] = [.font: font]
+    let size = text.size(withAttributes: attributes)
+
+    let textRadius = sqrt(size.height * size.height + size.width * size.width) / 2
+    let internalRadius = textRadius + MARGIN_SIZE
+    let externalRadius = internalRadius + STROKE_SIZE
+    let imageSize = CGSize(width: externalRadius * 2, height: externalRadius * 2)
+
+    let renderer = UIGraphicsImageRenderer(size: imageSize)
+
+    return renderer.image { context in
+      let cgContext = context.cgContext
+
+      cgContext.setFillColor(clusterColor.cgColor)
+      cgContext.fillEllipse(
+        in: CGRect(x: 0, y: 0, width: externalRadius * 2, height: externalRadius * 2))
+
+      cgContext.setFillColor(UIColor.white.cgColor)
+      cgContext.fillEllipse(
+        in: CGRect(
+          x: STROKE_SIZE, y: STROKE_SIZE, width: internalRadius * 2, height: internalRadius * 2))
+
+      let textRect = CGRect(
+        x: externalRadius - size.width / 2,
+        y: externalRadius - size.height / 2,
+        width: size.width,
+        height: size.height
+      )
+      text.draw(
+        in: textRect,
+        withAttributes: [
+          .font: font,
+          .foregroundColor: UIColor.black,
+        ])
+    }
+  }
+}

package/ios/Components/Marker.swift

@@ -0,0 +1,187 @@
+import Foundation
+import React
+import YandexMapsMobile
+
+@objc(YamapLiteMarkerComponentDelegate)
+public protocol YamapLiteMarkerComponentDelegate {
+    func onMarkerPress(point: [String: Double])
+}
+
+@objc(YamapLiteMarker)
+public class YamapLiteMarker: UIView, MapObjectTapHandler {
+    ////////////////////////
+    ///////PROPERTIES///////
+    ////////////////////////
+
+    private var listener: MarkerTapListener?
+    private weak var listenedObject: YMKMapObject?
+
+    var point: Point? {
+        didSet {
+            updateMarker()
+        }
+    }
+
+    @objc public weak var delegate: YamapLiteMarkerComponentDelegate? = nil
+
+    @objc public var scale: Double = 1.0 {
+        didSet {
+            if scale < 0.1 {
+                scale = 0.1
+            }
+            updateMarker()
+        }
+    }
+
+    private var originalIcon: UIImage?
+
+    @objc public var icon: UIImage? {
+        get {
+            return originalIcon
+        }
+        set {
+            originalIcon = newValue
+            updateMarker()
+        }
+    }
+
+    @objc public var onPress: RCTBubblingEventBlock? = nil
+    var anchor: Anchor?
+    @objc public var zIndex: Float = 0 {
+        didSet {
+            updateMarker()
+        }
+    }
+
+    @objc public var visible: Bool = true {
+        didSet {
+            updateMarker()
+        }
+    }
+
+    @objc public var handled: Bool = true
+    @objc public var mapObject: YMKMapObject? = nil
+    @objc public var rotated: Int = 1 {
+        didSet {
+            updateMarker()
+        }
+    }
+
+    @objc public var size: Int = 25 {
+        didSet {
+            updateMarker()
+        }
+    }
+
+    @objc public var onPressHandler: RCTBubblingEventBlock? = nil
+
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+    }
+
+    @available(*, unavailable)
+    required init?(coder _: NSCoder) {
+        fatalError("init(coder:) is not implemented.")
+    }
+
+    ////////////////////////
+    ////////METHODS/////////
+    ////////////////////////
+
+    @objc public func onMapObjectTap(point: YMKPoint) {
+        delegate?.onMarkerPress(point: [
+            "lat": point.latitude,
+            "lon": point.longitude,
+        ])
+    }
+
+    @objc public func setPoint(lat: Double, lon: Double) {
+        point = Point(lat: lat, lon: lon)
+        updateMarker()
+    }
+
+    @objc public func setAnchor(x: Double, y: Double) {
+        anchor = Anchor(x: x, y: y)
+        updateMarker()
+    }
+
+    @objc public func setIcon(uri: String) {
+        let image = ResolveImageHelper.shared.resolveUIImage(uri: uri as NSString) {
+            [weak self] loadedImage in
+            guard let self = self else {
+                return
+            }
+            guard let loadedImage = loadedImage else {
+                return
+            }
+            self.originalIcon = loadedImage
+            self.updateMarker()
+        }
+
+        if let image = image {
+            originalIcon = image
+            updateMarker()
+        }
+    }
+
+    @objc public func setMapObject(object: YMKMapObject) {
+        guard let placemark = object as? YMKPlacemarkMapObject else { return }
+        mapObject = placemark
+        mapObject!.userData = self
+        if listener == nil {
+            listener = MarkerTapListener()
+        }
+
+        if listenedObject !== placemark {
+            placemark.addTapListener(with: listener!)
+            listenedObject = placemark
+        }
+        updateMarker()
+    }
+
+    @objc public func updateMarker() {
+        DispatchQueue.main.async { [self] in
+            guard let obj = mapObject as? YMKPlacemarkMapObject, obj.isValid else { return }
+            let lat = self.point?.lat ?? 0.0
+            let lon = self.point?.lon ?? 0.0
+            guard lat.isFinite, lon.isFinite else { return }
+            obj.geometry = YMKPoint(latitude: lat, longitude: lon)
+
+            obj.zIndex = Float(zIndex)
+
+            let iconStyle = YMKIconStyle()
+            iconStyle.scale = NSNumber(value: scale)
+            iconStyle.visible = NSNumber(value: visible)
+            let anchorX = anchor?.x ?? 0.5
+            let anchorY = anchor?.y ?? 0.5
+            iconStyle.anchor = NSValue(cgPoint: CGPoint(x: CGFloat(anchorX), y: CGFloat(anchorY)))
+
+            iconStyle.rotationType = NSNumber(
+                value: rotated != 0
+                    ? YMKRotationType.rotate.rawValue
+                    : YMKRotationType.noRotation.rawValue)
+
+            if let icon = originalIcon {
+                let resizedIcon = ResolveImageHelper.shared.resizeImage(
+                    icon, toWidth: CGFloat(size))
+                obj.setIconWith(resizedIcon ?? icon)
+                obj.setIconStyleWith(iconStyle)
+            }
+        }
+    }
+}
+
+extension YamapLiteMarker {
+    @objc public func setClusterMapObject(_ placemark: YMKPlacemarkMapObject) {
+        mapObject = placemark
+        mapObject?.userData = self
+        if listener == nil {
+            listener = MarkerTapListener()
+        }
+        if listenedObject !== placemark {
+            placemark.addTapListener(with: listener!)
+            listenedObject = placemark
+        }
+        updateMarker()
+    }
+}

package/ios/Components/Polygon.swift

@@ -0,0 +1,108 @@
+import Foundation
+import React
+import YandexMapsMobile
+
+@objc(YamapLitePolygonComponentDelegate)
+public protocol YamapLitePolygonComponentDelegate {
+  func onPolygonPress(point: [String: Double])
+}
+
+@objc(YamapLitePolygon)
+public class YamapLitePolygon: UIView, MapObjectTapHandler {
+  @objc public weak var delegate: YamapLitePolygonComponentDelegate? = nil
+  public var mapObject: YMKMapObject?
+  @objc var listener: MarkerTapListener?
+
+  override init(frame: CGRect) {
+    super.init(frame: frame)
+  }
+
+  @available(*, unavailable)
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) is not implemented.")
+  }
+
+  @objc public var fillColor: UIColor = .black {
+    didSet {
+      updatePolygon()
+    }
+
+  }
+
+  @objc public var strokeColor: UIColor = .black {
+    didSet {
+      updatePolygon()
+    }
+  }
+
+  @objc public var strokeWidth: Float = 1 {
+    didSet {
+      updatePolygon()
+    }
+  }
+
+  @objc public var zIndex: Float = 1 {
+    didSet {
+      updatePolygon()
+    }
+  }
+
+  @objc public var points: [YMKPoint]? = [] {
+    didSet {
+      updateGeometry()
+      updatePolygon()
+    }
+  }
+
+  @objc public var innerRings: [[YMKPoint]]? = [] {
+    didSet {
+      updateGeometry()
+      updatePolygon()
+    }
+  }
+
+  @objc public var handled: Bool = true
+
+  @objc public var polygon: YMKPolygon = YMKPolygon(
+    outerRing: YMKLinearRing(points: []),
+    innerRings: []
+  )
+
+  @objc public func updatePolygon() {
+    if let polygonObject = mapObject as? YMKPolygonMapObject, polygonObject.isValid {
+      polygonObject.geometry = polygon
+      polygonObject.zIndex = zIndex
+      polygonObject.fillColor = fillColor
+      polygonObject.strokeColor = strokeColor
+      polygonObject.strokeWidth = strokeWidth
+    }
+  }
+
+  @objc public func updateGeometry() {
+    let isFinitePoint: (YMKPoint) -> Bool = { $0.latitude.isFinite && $0.longitude.isFinite }
+    if let points = points, points.count >= 3, points.allSatisfy(isFinitePoint) {
+      let ring = YMKLinearRing(points: points)
+      let unwrappedInnerRings = (innerRings ?? [])
+        .filter { $0.count >= 3 && $0.allSatisfy(isFinitePoint) }
+        .map { YMKLinearRing(points: $0) }
+      polygon = YMKPolygon(outerRing: ring, innerRings: unwrappedInnerRings)
+    }
+  }
+
+  public func onMapObjectTap(point: YMKPoint) {
+    delegate?.onPolygonPress(point: [
+      "lat": point.latitude,
+      "lon": point.longitude,
+    ])
+  }
+
+  @objc public func setMapObject(object: YMKMapObject) {
+    if let polygonObject = object as? YMKPolygonMapObject {
+      mapObject = polygonObject
+      mapObject?.userData = self
+      listener = MarkerTapListener()
+      mapObject?.addTapListener(with: listener!)
+      updatePolygon()
+    }
+  }
+}

package/ios/Components/Polyline.swift

@@ -0,0 +1,125 @@
+import Foundation
+import React
+import YandexMapsMobile
+
+@objc(YamapLitePolylineComponentDelegate)
+public protocol YamapLitePolylineComponentDelegate {
+    func onPolylinePress(point: [String: Double])
+}
+
+@objc(YamapLitePolyline)
+public final class YamapLitePolyline: UIView, MapObjectTapHandler {
+    @objc public weak var delegate: YamapLitePolylineComponentDelegate? = nil
+    public var mapObject: YMKMapObject?
+    @objc var listener: MarkerTapListener?
+
+    @objc public var strokeColor: UIColor = .black {
+        didSet {
+            updatePolyline()
+        }
+    }
+
+    @objc public var strokeWidth: Float = 1 {
+        didSet {
+            updatePolyline()
+        }
+    }
+
+    @objc public var outlineColor: UIColor = .black {
+        didSet {
+            updatePolyline()
+        }
+    }
+
+    @objc public var zIndex: Float = 1 {
+        didSet {
+            updatePolyline()
+        }
+    }
+
+    @objc public var dashLength: Float = 1 {
+        didSet {
+            updatePolyline()
+        }
+    }
+
+    @objc public var gapLength: Float = 0 {
+        didSet {
+            updatePolyline()
+        }
+    }
+
+    @objc public var outlineWidth: Float = 0 {
+        didSet {
+            updatePolyline()
+        }
+    }
+
+    @objc public var dashOffset: Float = 0 {
+        didSet {
+            updatePolyline()
+        }
+    }
+
+    @objc public var points: [YMKPoint] = [] {
+        didSet {
+            updateGeometry()
+            updatePolyline()
+        }
+    }
+
+    @objc public var handled = true
+
+    @objc public var polyline: YMKPolyline
+
+    override init(frame: CGRect) {
+        polyline = YMKPolyline(points: points)
+        super.init(frame: frame)
+    }
+
+    @available(*, unavailable)
+    required init?(coder _: NSCoder) {
+        fatalError("init(coder:) is not implemented.")
+    }
+
+    @objc public func updatePolyline() {
+        if let polylineObject = mapObject as? YMKPolylineMapObject, polylineObject.isValid {
+            polylineObject.geometry = polyline
+            polylineObject.zIndex = zIndex
+            polylineObject.setStrokeColorWith(strokeColor)
+            polylineObject.strokeWidth = strokeWidth
+            polylineObject.dashLength = dashLength
+            polylineObject.gapLength = gapLength
+            polylineObject.dashOffset = dashOffset
+            polylineObject.outlineWidth = outlineWidth
+            if outlineWidth > 0 {
+                polylineObject.outlineColor = outlineColor
+            }
+        }
+    }
+
+    @objc public func updateGeometry() {
+        if points.count >= 2,
+            points.allSatisfy({ $0.latitude.isFinite && $0.longitude.isFinite })
+        {
+            polyline = YMKPolyline(points: points)
+        }
+    }
+
+    @objc public func setMapObject(object: YMKMapObject) {
+        if let polylineObject = object as? YMKPolylineMapObject {
+            mapObject = polylineObject
+            mapObject?.userData = self
+            listener = MarkerTapListener()
+            mapObject?.addTapListener(with: listener!)
+            updatePolyline()
+        }
+    }
+
+    public func onMapObjectTap(point: YMKPoint) {
+        delegate?.onPolylinePress(point: [
+            "lat": point.latitude,
+            "lon": point.longitude,
+        ])
+    }
+}