@exterio/react-native-yamap-lite 1.0.1

package/ios/Listeners/MapInputListener.swift

@@ -0,0 +1,35 @@
+import Foundation
+import React
+import YandexMapsMobile
+
+class MapInputListener: NSObject, YMKMapInputListener {
+    private weak var delegate: YamapViewComponentDelegate?
+    
+    init(delegate: YamapViewComponentDelegate?) {
+        self.delegate = delegate
+        super.init()
+    }
+    
+    func onMapTap(with map: YMKMap, point: YMKPoint) {
+        let coords: [String: Any] = [
+            "lat": point.latitude,
+            "lon": point.longitude
+        ]
+        
+        DispatchQueue.main.async { [weak self] in
+            self?.delegate?.handleOnMapPress(coords: coords)
+        }
+    }
+    
+    func onMapLongTap(with map: YMKMap, point: YMKPoint) {
+        let coords: [String: Any] = [
+            "lat": point.latitude,
+            "lon": point.longitude
+        ]
+        
+        DispatchQueue.main.async { [weak self] in
+            self?.delegate?.handleOnMapLongPress(coords: coords)
+        }
+    }
+}
+

package/ios/Listeners/MapLoadListener.swift

@@ -0,0 +1,35 @@
+import Foundation
+import React
+import YandexMapsMobile
+
+class MapLoadListener: NSObject, YMKMapLoadedListener {
+    private var callback: RCTDirectEventBlock?
+    private weak var mapDelegate: YamapViewComponentDelegate?
+    init(callback: RCTDirectEventBlock?, mapDelegate: YamapViewComponentDelegate?) {
+        self.callback = callback
+        self.mapDelegate = mapDelegate
+        super.init()
+    }
+
+    func onMapLoaded(with statistics: YMKMapLoadStatistics) {
+        let params: [String: Any] = [
+            "renderObjectCount": statistics.renderObjectCount,
+            "curZoomModelsLoaded": statistics.curZoomModelsLoaded,
+            "curZoomPlacemarksLoaded": statistics.curZoomPlacemarksLoaded,
+            "curZoomLabelsLoaded": statistics.curZoomLabelsLoaded,
+            "curZoomGeometryLoaded": statistics.curZoomGeometryLoaded,
+            "tileMemoryUsage": statistics.tileMemoryUsage,
+            "delayedGeometryLoaded": statistics.delayedGeometryLoaded,
+            "fullyAppeared": statistics.fullyAppeared,
+            "fullyLoaded": statistics.fullyLoaded,
+        ]
+
+        DispatchQueue.main.async { [weak self] in
+            if let callback = self?.callback {
+                callback(params)
+            } else if let delegate = self?.mapDelegate {
+                delegate.handleOnMapLoaded(result: params)
+            }
+        }
+    }
+}

package/ios/Listeners/MapObjectTap.swift

@@ -0,0 +1,12 @@
+import Foundation
+import YandexMapsMobile
+
+@objc class MarkerTapListener: NSObject, YMKMapObjectTapListener {
+    func onMapObjectTap(with mapObject: YMKMapObject, point: YMKPoint) -> Bool {
+        if let handler = mapObject.userData as? MapObjectTapHandler {
+            handler.onMapObjectTap(point: point)
+            return handler.handled
+        }
+        return false
+    }
+}

package/ios/Listeners/UserLocationObjectListener.swift

@@ -0,0 +1,29 @@
+import Foundation
+import React
+import YandexMapsMobile
+
+@objc(UserLocationObjectListener)
+class UserLocationObjectListener: NSObject, YMKUserLocationObjectListener {
+    var userLocationView: YMKUserLocationView?
+
+    var cb: (() -> Void)?
+
+    init(callback: @escaping () -> Void) {
+        cb = callback
+        super.init()
+    }
+
+    func onObjectAdded(with view: YMKUserLocationView) {
+        userLocationView = view
+        cb?()
+    }
+
+    func onObjectRemoved(with _: YMKUserLocationView) {
+        //
+    }
+
+    func onObjectUpdated(with view: YMKUserLocationView, event _: YMKObjectEvent) {
+        userLocationView = view
+        cb?()
+    }
+}

package/ios/Models/YamapModels.swift

@@ -0,0 +1,77 @@
+import Foundation
+import YandexMapsMobile
+
+@objc public protocol MapObject {
+    var zIndex: Float { get }
+    var handled: Bool { get }
+}
+
+@objc public protocol MapObjectTapHandler: AnyObject {
+    var handled: Bool { get }
+    var mapObject: YMKMapObject? { get }
+    func setMapObject(object: YMKMapObject)
+    var zIndex: Float { get }
+    func onMapObjectTap(point: YMKPoint)
+}
+
+struct Point {
+    let lat: Double
+    let lon: Double
+
+    init(lat: Double = 0.0, lon: Double = 0.0) {
+        self.lat = lat
+        self.lon = lon
+    }
+}
+
+struct Anchor {
+    let x: Double
+    let y: Double
+
+    init(x: Double = 0.5, y: Double = 0.5) {
+        self.x = x
+        self.y = y
+    }
+}
+
+struct Coordinate {
+    let latitude: Double
+    let longitude: Double
+    let zoom: Float?
+    let azimuth: Float?
+    let tilt: Float?
+
+    init(latitude: Double = 0.0, longitude: Double = 0.0, zoom: Float?, azimuth: Float?, tilt: Float?) {
+        self.latitude = latitude
+        self.longitude = longitude
+        self.zoom = zoom
+        self.azimuth = azimuth
+        self.tilt = tilt
+    }
+}
+
+struct LogoPosition {
+    var horizontal = YMKLogoHorizontalAlignment.right
+    var vertical = YMKLogoVerticalAlignment.bottom
+    init(position: NSObject) {
+        guard let horizontalPosition = position.value(forKey: "horizontal") as? String,
+              let verticalPosition = position.value(forKey: "vertical") as? String
+        else {
+            return
+        }
+        switch horizontalPosition {
+        case "left":
+            horizontal = YMKLogoHorizontalAlignment.left
+        case "center":
+            horizontal = YMKLogoHorizontalAlignment.center
+        default:
+            horizontal = YMKLogoHorizontalAlignment.right
+        }
+        switch verticalPosition {
+        case "top":
+            vertical = YMKLogoVerticalAlignment.top
+        default:
+            vertical = YMKLogoVerticalAlignment.bottom
+        }
+    }
+}

package/ios/Utils/ImageCache.swift

@@ -0,0 +1,20 @@
+import Foundation
+import UIKit
+
+public class ImageCache {
+  static let shared = ImageCache()
+  private let cache = NSCache<NSString, UIImage>()
+  private let cacheSize = 50 * 1024 * 1024  // 50 МБ в байтах
+
+  private init() {
+    cache.totalCostLimit = cacheSize
+  }
+
+  func setObject(_ image: UIImage, forKey key: NSString, cost: Int) {
+    cache.setObject(image, forKey: key, cost: cost)
+  }
+
+  func objectForKey(_ key: NSString) -> UIImage? {
+    return cache.object(forKey: key)
+  }
+}

package/ios/Utils/PointsEqual.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#ifdef __cplusplus
+
+#include <cstddef>
+#include <vector>
+
+namespace yamaplite {
+
+template <typename Coord>
+inline bool latLonEqual(const Coord &a, const Coord &b) {
+  return a.lat == b.lat && a.lon == b.lon;
+}
+
+template <typename Coord>
+inline bool pointsEqual(const std::vector<Coord> &lhs,
+                        const std::vector<Coord> &rhs) {
+  if (lhs.size() != rhs.size()) {
+    return false;
+  }
+  for (size_t i = 0; i < lhs.size(); ++i) {
+    if (!latLonEqual(lhs[i], rhs[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+template <typename Coord>
+inline bool ringsEqual(const std::vector<std::vector<Coord>> &lhs,
+                       const std::vector<std::vector<Coord>> &rhs) {
+  if (lhs.size() != rhs.size()) {
+    return false;
+  }
+  for (size_t i = 0; i < lhs.size(); ++i) {
+    if (!pointsEqual(lhs[i], rhs[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+} // namespace yamaplite
+
+#endif

package/ios/Utils/ResolveImageHelper.swift

@@ -0,0 +1,142 @@
+import Foundation
+import UIKit
+import YandexMapsMobile
+import os.log
+
+private let logger = OSLog(subsystem: "com.yamaplite", category: "ResolveImageHelper")
+
+public class ResolveImageHelper {
+  // MARK: - Singleton
+  public static let shared = ResolveImageHelper()
+
+  // MARK: - Properties
+  var iconSize: NSNumber?
+  var source: String?
+  var lastSource: String?
+
+  private let session: URLSession = {
+    let config = URLSessionConfiguration.default
+    config.timeoutIntervalForRequest = 30.0
+    config.timeoutIntervalForResource = 60.0
+    config.requestCachePolicy = .reloadIgnoringLocalCacheData
+    return URLSession(configuration: config)
+  }()
+
+  private init() {}
+
+  func resolveUIImage(uri: NSString, completion: ((UIImage?) -> Void)? = nil) -> UIImage? {
+    guard !uri.isEqual(to: "") else {
+      os_log("URI is nil or empty", log: logger, type: .error)
+      completion?(nil)
+      return nil
+    }
+
+    if uri.hasPrefix("file://") || uri.hasPrefix("/") {
+      var url = URL(string: uri as String)
+      if url == nil {
+        url = URL(fileURLWithPath: uri as String)
+      }
+      guard let fileURL = url else {
+        os_log("Failed to create URL from URI: %@", log: logger, type: .error, uri)
+        completion?(nil)
+        return nil
+      }
+
+      guard let imageData = try? Data(contentsOf: fileURL) else {
+        os_log("Failed to load image data from URL: %@", log: logger, type: .error, uri)
+        completion?(nil)
+        return nil
+      }
+
+      guard let icon = UIImage(data: imageData) else {
+        os_log("Failed to create image from data: %@", log: logger, type: .error, uri)
+        completion?(nil)
+        return nil
+      }
+
+      let width: CGFloat =
+        (iconSize?.floatValue ?? 0) > 0 ? CGFloat(iconSize!.floatValue) : icon.size.width
+      let resized = self.resizeImage(icon, toWidth: width)
+
+      let cost = Int(resized.size.width * resized.size.height * resized.scale * resized.scale * 4)
+      ImageCache.shared.setObject(resized, forKey: uri, cost: cost)
+      completion?(resized)
+      return resized
+    }
+
+    if let cached = ImageCache.shared.objectForKey(uri) {
+      completion?(cached)
+      return cached
+    }
+
+    var url = URL(string: uri as String)
+    if url == nil {
+      url = URL(fileURLWithPath: uri as String)
+    }
+    guard let imageURL = url else {
+      os_log("Failed to create URL from URI: %@", log: logger, type: .error, uri)
+      completion?(nil)
+      return nil
+    }
+
+    loadImageAsync(uri: uri, withURL: imageURL, completion: completion)
+    return nil
+  }
+
+  func loadImageAsync(uri: NSString, withURL url: URL, completion: ((UIImage?) -> Void)? = nil) {
+    guard !uri.isEqual(to: "") else {
+      completion?(nil)
+      return
+    }
+    if let cached = ImageCache.shared.objectForKey(uri) {
+      completion?(cached)
+      return
+    }
+
+    let task = session.dataTask(with: url) { data, response, error in
+      if let error = error {
+        os_log("Network error loading image %@: %@", log: logger, type: .error, uri, error.localizedDescription)
+        completion?(nil)
+        return
+      }
+
+      if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode < 200 || httpResponse.statusCode >= 300 {
+        os_log("HTTP %d while loading image %@", log: logger, type: .error, httpResponse.statusCode, uri)
+        completion?(nil)
+        return
+      }
+
+      guard let imageData = data else {
+        os_log("No data received from URL: %@", log: logger, type: .error, uri)
+        completion?(nil)
+        return
+      }
+
+      guard let image = UIImage(data: imageData) else {
+        os_log("Failed to decode image data (%d bytes) from: %@", log: logger, type: .error, imageData.count, uri)
+        completion?(nil)
+        return
+      }
+
+      let cost = Int(image.size.width * image.size.height * image.scale * image.scale * 4)
+      ImageCache.shared.setObject(image, forKey: uri, cost: cost)
+
+      DispatchQueue.main.async {
+        completion?(image)
+      }
+    }
+
+    task.resume()
+  }
+
+  func resizeImage(_ image: UIImage, toWidth width: CGFloat) -> UIImage {
+    guard image.size.width > 0 && image.size.height > 0 else { return image }
+    let scaleFactor = width / image.size.width
+    let newSize = CGSize(width: width, height: image.size.height * scaleFactor)
+    UIGraphicsBeginImageContextWithOptions(newSize, false, 0.0)
+    image.draw(in: CGRect(origin: .zero, size: newSize))
+    let newImage = UIGraphicsGetImageFromCurrentImageContext()
+    UIGraphicsEndImageContext()
+    return newImage ?? image
+  }
+}

package/ios/YamapLiteCircleView.h

@@ -0,0 +1,15 @@
+#import <React/RCTViewComponentView.h>
+#import <React/RCTViewManager.h>
+#import <UIKit/UIKit.h>
+
+#ifndef YamapLiteCircleViewNativeComponent_h
+#define YamapLiteCircleViewNativeComponent_h
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface YamapLiteCircleView : RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif /* YamapLiteViewNativeComponent_h */

package/ios/YamapLiteCircleView.mm

@@ -0,0 +1,102 @@
+#import "YamapLiteCircleView.h"
+#include "ReactCodegen/react/renderer/components/YamapLiteViewSpec/EventEmitters.h"
+#include "react/renderer/components/YamapLiteViewSpec/EventEmitters.h"
+#include <Foundation/Foundation.h>
+#include <objc/NSObject.h>
+
+#import <RCTTypeSafety/RCTConvertHelpers.h>
+#import <React/RCTConversions.h>
+#import <react/renderer/components/YamapLiteViewSpec/ComponentDescriptors.h>
+#import <react/renderer/components/YamapLiteViewSpec/EventEmitters.h>
+#import <react/renderer/components/YamapLiteViewSpec/Props.h>
+#import <react/renderer/components/YamapLiteViewSpec/RCTComponentViewHelpers.h>
+#import <react/renderer/graphics/Color.h>
+
+#import "RCTFabricComponentsPlugins.h"
+#import "YamapLite-Swift.h"
+
+using namespace facebook::react;
+
+@interface YamapLiteCircleView () <RCTYamapLiteCircleViewViewProtocol,
+                                   YamapLiteCircleComponentDelegate>
+
+@end
+
+@implementation YamapLiteCircleView {
+  YamapLiteCircle *_view;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<
+      YamapLiteCircleViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps =
+        std::make_shared<const YamapLiteCircleViewProps>();
+    _props = defaultProps;
+    _view = [[YamapLiteCircle alloc] init];
+    _view.delegate = self;
+    self.contentView = _view;
+  }
+  return self;
+}
+
+- (void)updateProps:(Props::Shared const &)props
+           oldProps:(Props::Shared const &)oldProps {
+  const auto &oldViewProps =
+      *std::static_pointer_cast<YamapLiteCircleViewProps const>(_props);
+  const auto &newViewProps =
+      *std::static_pointer_cast<YamapLiteCircleViewProps const>(props);
+
+  if (oldViewProps.radius != newViewProps.radius) {
+    _view.radius = newViewProps.radius;
+  }
+  if (oldViewProps.fillColor != newViewProps.fillColor) {
+    UIColor *uiColor = RCTUIColorFromSharedColor(newViewProps.fillColor);
+    if (uiColor) {
+      _view.fillColor = uiColor;
+    }
+  }
+  if (oldViewProps.strokeColor != newViewProps.strokeColor) {
+    UIColor *uiColor = RCTUIColorFromSharedColor(newViewProps.strokeColor);
+    if (uiColor) {
+      _view.strokeColor = uiColor;
+    }
+  }
+  if (oldViewProps.strokeWidth != newViewProps.strokeWidth) {
+    _view.strokeWidth = newViewProps.strokeWidth;
+  }
+  if (oldViewProps.zIndex != newViewProps.zIndex) {
+    _view.zIndex = newViewProps.zInd;
+  }
+  if (oldViewProps.center.lat != newViewProps.center.lat ||
+      oldViewProps.center.lon != newViewProps.center.lon) {
+    [_view setCircleCenterWithLatitude:newViewProps.center.lat
+                             longitude:newViewProps.center.lon];
+  }
+  if (oldViewProps.handled != newViewProps.handled) {
+    _view.handled = newViewProps.handled;
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)onCirclePressWithPoint:
+    (NSDictionary<NSString *, NSNumber *> *_Nonnull)point {
+  if (_eventEmitter != nil) {
+    YamapLiteCircleViewEventEmitter::OnCirclePress event = {};
+    event.lat = [[point objectForKey:@"lat"] doubleValue];
+    event.lon = [[point objectForKey:@"lon"] doubleValue];
+    std::dynamic_pointer_cast<const YamapLiteCircleViewEventEmitter>(
+        _eventEmitter)
+        ->onCirclePress(event);
+  }
+}
+
+Class<RCTComponentViewProtocol> YamapLiteCircleViewCls(void) {
+  return YamapLiteCircleView.class;
+}
+
+@end

package/ios/YamapLiteMarkerView.h

@@ -0,0 +1,15 @@
+#import <React/RCTViewManager.h>
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+#ifndef YamapLiteMarkerViewNativeComponent_h
+#define YamapLiteMarkerViewNativeComponent_h
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface YamapLiteMarkerView : RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif /* YamapLiteViewNativeComponent_h */

package/ios/YamapLiteMarkerView.mm

@@ -0,0 +1,102 @@
+#import "YamapLiteMarkerView.h"
+#include "ReactCodegen/react/renderer/components/YamapLiteViewSpec/EventEmitters.h"
+#include "react/renderer/components/YamapLiteViewSpec/EventEmitters.h"
+#include <Foundation/Foundation.h>
+#include <objc/NSObject.h>
+
+#import <RCTTypeSafety/RCTConvertHelpers.h>
+#import <React/RCTConversions.h>
+
+#import "RCTFabricComponentsPlugins.h"
+#import "YamapLite-Swift.h"
+#import <react/renderer/components/YamapLiteViewSpec/ComponentDescriptors.h>
+#import <react/renderer/components/YamapLiteViewSpec/EventEmitters.h>
+#import <react/renderer/components/YamapLiteViewSpec/Props.h>
+#import <react/renderer/components/YamapLiteViewSpec/RCTComponentViewHelpers.h>
+
+using namespace facebook::react;
+
+@interface YamapLiteMarkerView () <RCTYamapLiteMarkerViewViewProtocol,
+                                   YamapLiteMarkerComponentDelegate>
+
+@end
+
+@implementation YamapLiteMarkerView {
+  YamapLiteMarker *_view;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<
+      YamapLiteMarkerViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps =
+        std::make_shared<const YamapLiteMarkerViewProps>();
+    _props = defaultProps;
+    _view = [[YamapLiteMarker alloc] init];
+    _view.delegate = self;
+    self.contentView = _view;
+  }
+  return self;
+}
+
+- (void)updateProps:(Props::Shared const &)props
+           oldProps:(Props::Shared const &)oldProps {
+  const auto &oldViewProps =
+      *std::static_pointer_cast<YamapLiteMarkerViewProps const>(_props);
+  const auto &newViewProps =
+      *std::static_pointer_cast<YamapLiteMarkerViewProps const>(props);
+  if (oldViewProps.scale != newViewProps.scale) {
+    _view.scale = newViewProps.scale;
+  }
+  if (oldViewProps.zInd != newViewProps.zInd) {
+    _view.zIndex = newViewProps.zInd;
+  }
+  if (oldViewProps.visible != newViewProps.visible) {
+    _view.visible = newViewProps.visible;
+  }
+  if (oldViewProps.handled != newViewProps.handled) {
+    _view.handled = newViewProps.handled;
+  }
+  if (oldViewProps.point.lat != newViewProps.point.lat ||
+      oldViewProps.point.lon != newViewProps.point.lon) {
+    [_view setPointWithLat:newViewProps.point.lat lon:newViewProps.point.lon];
+  }
+  if (oldViewProps.anchor.x != newViewProps.anchor.x ||
+      oldViewProps.anchor.y != newViewProps.anchor.y) {
+    [_view setAnchorWithX:newViewProps.anchor.x y:newViewProps.anchor.y];
+  }
+  if (RCTNSStringFromString(oldViewProps.source) !=
+      RCTNSStringFromString(newViewProps.source)) {
+    [_view setIconWithUri:RCTNSStringFromString(newViewProps.source)];
+  }
+  if (oldViewProps.rotated != newViewProps.rotated) {
+    _view.rotated = newViewProps.rotated;
+  }
+  if (oldViewProps.size != newViewProps.size) {
+    _view.size = newViewProps.size;
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)onMarkerPressWithPoint:
+    (NSDictionary<NSString *, NSNumber *> *_Nonnull)point {
+  if (_eventEmitter != nil) {
+    YamapLiteMarkerViewEventEmitter::OnMarkerPress event = {};
+    event.lat = [[point objectForKey:@"lat"] doubleValue];
+    event.lon = [[point objectForKey:@"lon"] doubleValue];
+
+    std::dynamic_pointer_cast<const YamapLiteMarkerViewEventEmitter>(
+        _eventEmitter)
+        ->onMarkerPress(event);
+  }
+}
+
+Class<RCTComponentViewProtocol> YamapLiteMarkerViewCls(void) {
+  return YamapLiteMarkerView.class;
+}
+
+@end

package/ios/YamapLitePolygonView.h

@@ -0,0 +1,15 @@
+#import <React/RCTViewComponentView.h>
+#import <React/RCTViewManager.h>
+#import <UIKit/UIKit.h>
+
+#ifndef YamapLitePolygonViewNativeComponent_h
+#define YamapLitePolygonViewNativeComponent_h
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface YamapLitePolygonView : RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif /* YamapLiteViewNativeComponent_h */