@exterio/react-native-yamap-lite 1.0.1

package/android/src/main/java/com/yamaplite/Events/MapLoadEvent.kt

@@ -0,0 +1,34 @@
+package com.yamaplite.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+import com.yandex.mapkit.map.MapLoadStatistics
+
+class MapLoadEvent(
+        surfaceId: Int,
+        viewTag: Int,
+        private val statistics: MapLoadStatistics,
+) : Event<MapLoadEvent>(surfaceId, viewTag) {
+
+    override fun getEventName(): String = EVENT_NAME
+
+    override fun getEventData(): WritableMap =
+            Arguments.createMap().apply {
+                putInt("renderObjectCount", statistics.renderObjectCount)
+                putDouble("curZoomModelsLoaded", statistics.curZoomModelsLoaded.toDouble())
+                putDouble("curZoomPlacemarksLoaded", statistics.curZoomPlacemarksLoaded.toDouble())
+                putDouble("curZoomLabelsLoaded", statistics.curZoomLabelsLoaded.toDouble())
+                putDouble("curZoomGeometryLoaded", statistics.curZoomGeometryLoaded.toDouble())
+                putDouble("tileMemoryUsage", statistics.tileMemoryUsage.toDouble())
+                putDouble("delayedGeometryLoaded", statistics.delayedGeometryLoaded.toDouble())
+                putDouble("fullyAppeared", statistics.fullyAppeared.toDouble())
+                putDouble("fullyLoaded", statistics.fullyLoaded.toDouble())
+            }
+
+    override fun getCoalescingKey(): Short = 0
+
+    companion object {
+        const val EVENT_NAME = "onMapLoaded"
+    }
+}

package/android/src/main/java/com/yamaplite/Events/PressEvent.kt

@@ -0,0 +1,24 @@
+package com.yamaplite.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+import com.yandex.mapkit.geometry.Point
+
+class PressEvent(
+        surfaceId: Int,
+        viewTag: Int,
+        private val eventName: String,
+        private val point: Point,
+) : Event<PressEvent>(surfaceId, viewTag) {
+
+    override fun getEventName(): String = eventName
+
+    override fun getEventData(): WritableMap =
+            Arguments.createMap().apply {
+                putDouble("lat", point.latitude)
+                putDouble("lon", point.longitude)
+            }
+
+    override fun getCoalescingKey(): Short = 0
+}

package/android/src/main/java/com/yamaplite/Utils/ImageCache.kt

@@ -0,0 +1,45 @@
+package com.yamaplite.utils
+
+import android.graphics.Bitmap
+import android.util.LruCache
+import android.util.Log
+import java.lang.Runtime
+
+object ImageCache {
+
+  private val cacheSize = 50 * 1024 * 1024 // 50 МБ в байтах
+
+  private val memoryCache: LruCache<String, Bitmap> = object : LruCache<String, Bitmap>(cacheSize) {
+    override fun sizeOf(key: String, value: Bitmap): Int {
+      return value.byteCount // размер в байтах
+    }
+  }
+
+  /** Получить Bitmap из кэша по URL */
+  fun get(url: String): Bitmap? {
+    val bitmap = memoryCache.get(url)
+    if (bitmap != null) {
+      Log.d("ImageCache", "Cache HIT for: $url (size: ${bitmap.byteCount} bytes)")
+    } else {
+      Log.d("ImageCache", "Cache MISS for: $url")
+    }
+    return bitmap
+  }
+
+  /** Положить Bitmap в кэш по URL */
+  fun put(url: String, bitmap: Bitmap) {
+    val size = bitmap.byteCount
+    memoryCache.put(url, bitmap)
+    Log.d("ImageCache", "Cached image: $url (size: $size bytes, cache size: ${memoryCache.size()} bytes)")
+  }
+
+  /** Проверка наличия Bitmap в кэше */
+  fun contains(url: String): Boolean {
+    return memoryCache.get(url) != null
+  }
+
+  /** Очистить весь кэш */
+  fun clear() {
+    memoryCache.evictAll()
+  }
+}

package/android/src/main/java/com/yamaplite/Utils/PointParser.kt

@@ -0,0 +1,39 @@
+package com.yamaplite.utils
+
+import com.facebook.react.bridge.ReadableArray
+import com.yandex.mapkit.ScreenPoint
+import com.yandex.mapkit.geometry.Point
+
+object PointParser {
+
+  fun parsePoints(points: ReadableArray?): ArrayList<Point> {
+    val result = ArrayList<Point>()
+    if (points == null) return result
+    for (i in 0 until points.size()) {
+      val map = points.getMap(i) ?: continue
+      if (!map.hasKey("lat") || !map.hasKey("lon")) continue
+      result.add(Point(map.getDouble("lat"), map.getDouble("lon")))
+    }
+    return result
+  }
+
+  fun parseRings(rings: ReadableArray?): ArrayList<ArrayList<Point>> {
+    val result = ArrayList<ArrayList<Point>>()
+    if (rings == null) return result
+    for (i in 0 until rings.size()) {
+      result.add(parsePoints(rings.getArray(i)))
+    }
+    return result
+  }
+
+  fun parseScreenPoints(points: ReadableArray?): ArrayList<ScreenPoint?> {
+    val result = ArrayList<ScreenPoint?>()
+    if (points == null) return result
+    for (i in 0 until points.size()) {
+      val map = points.getMap(i) ?: continue
+      if (!map.hasKey("x") || !map.hasKey("y")) continue
+      result.add(ScreenPoint(map.getDouble("x").toFloat(), map.getDouble("y").toFloat()))
+    }
+    return result
+  }
+}

package/android/src/main/java/com/yamaplite/Utils/ResolveImageHelper.kt

@@ -0,0 +1,122 @@
+package com.yamaplite.utils
+
+import com.yamaplite.utils.ImageCache
+import com.yandex.runtime.image.ImageProvider
+import android.util.Log
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Call
+import okhttp3.Response
+import java.io.IOException
+import android.os.Handler
+import android.os.Looper
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import kotlin.coroutines.resume
+
+
+class ResolveImageHelper {
+
+    companion object {
+        private val httpClient: OkHttpClient by lazy {
+            OkHttpClient.Builder()
+                .retryOnConnectionFailure(true)
+                .build()
+        }
+
+        @Volatile private var instance: ResolveImageHelper? = null
+
+        fun getInstance(): ResolveImageHelper =
+            instance ?: synchronized(this) {
+                instance ?: ResolveImageHelper().also { instance = it }
+            }
+    }
+
+    suspend fun resolveImage(context: Context, url: String, iconSize: Int): ImageProvider? = withContext(Dispatchers.IO) {
+        // 1. Проверка кэша - всегда ресайзим изображение из кэша под нужный размер
+        Log.d("ImageLoader", "Checking cache for: $url")
+        ImageCache.get(url)?.let { cachedBitmap ->
+            Log.d("ImageLoader", "Loaded from cache: $url")
+            val resizedBitmap = resizeBitmap(context, cachedBitmap, iconSize) ?: cachedBitmap
+            return@withContext ImageProvider.fromBitmap(resizedBitmap)
+        }
+        Log.d("ImageLoader", "Cache miss, trying other sources for: $url")
+
+        // 2. Проверяем как ресурс Android (для React Native ассетов в res/drawable-*)
+        val resId = context.resources.getIdentifier(url, "drawable", context.packageName)
+        if (resId != 0) {
+            try {
+                val bmp = BitmapFactory.decodeResource(context.resources, resId)
+                val resized = resizeBitmap(context, bmp, iconSize)
+                ImageCache.put(url, resized ?: bmp)
+                Log.d("ImageLoader", "Loaded from resources: $url")
+                return@withContext ImageProvider.fromBitmap(resized ?: bmp)
+            } catch (e: Exception) {
+                Log.e("ImageLoader", "Error loading from resources: $url", e)
+            }
+        }
+
+        // 3. HTTP/HTTPS → асинхронно, ждем завершения через suspendCancellableCoroutine
+        if (url.startsWith("http://") || url.startsWith("https://")) {
+            Log.d("ImageLoader", "Loading from network: $url")
+
+            return@withContext suspendCancellableCoroutine { continuation ->
+                val request = Request.Builder().url(url).build()
+                val call = httpClient.newCall(request)
+                continuation.invokeOnCancellation { call.cancel() }
+                call.enqueue(object : okhttp3.Callback {
+                    override fun onFailure(call: Call, e: IOException) {
+                        Log.e("ImageLoader", "Network load failed: $url", e)
+                        continuation.resume(null)
+                    }
+
+                    override fun onResponse(call: Call, response: Response) {
+                        var bitmap: Bitmap? = null
+                        try {
+                            response.body?.byteStream()?.use { inputStream ->
+                                try {
+                                    bitmap = BitmapFactory.decodeStream(inputStream)?.let { resizeBitmap(context, it, iconSize) }
+                                    bitmap?.let { ImageCache.put(url, it) }
+                                } catch (e: Exception) {
+                                    Log.e("ImageLoader", "Error decoding image: $url", e)
+                                } finally {
+                                    response.close()
+                                }
+                            }
+                        } catch (e: Exception) {
+                            Log.e("ImageLoader", "Error processing response: $url", e)
+                        }
+
+                        val imageProvider = bitmap?.let { ImageProvider.fromBitmap(it) }
+                        continuation.resume(imageProvider)
+                    }
+                })
+            }
+        }
+        
+        return@withContext null
+    }
+
+    fun resizeBitmap(context: Context, bitmap: Bitmap?, targetSize: Int): Bitmap? {
+        if (bitmap == null || targetSize <= 0) return bitmap
+        
+        // Convert dp to pixels based on screen density
+        val density = context.resources.displayMetrics.density
+        val targetSizePx = (targetSize * density).toInt()
+        
+        val width = bitmap.width
+        val height = bitmap.height
+        
+        if (width == targetSizePx && height == targetSizePx) return bitmap
+        
+        val scale = targetSizePx.toFloat() / width.coerceAtLeast(height).toFloat()
+        val scaledWidth = (width * scale).toInt()
+        val scaledHeight = (height * scale).toInt()
+        
+        return Bitmap.createScaledBitmap(bitmap, scaledWidth, scaledHeight, true)
+    }
+}

package/android/src/main/java/com/yamaplite/Utils/YamapUtils.kt

@@ -0,0 +1,169 @@
+package com.yamaplite.utils
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.UIManagerHelper
+import com.yamaplite.NativeYamapUtilsSpec
+import com.yamaplite.components.YamapLiteView
+import com.yandex.mapkit.MapKitFactory
+import com.yandex.runtime.i18n.I18nManagerFactory
+
+@ReactModule(name = NativeYamapUtilsSpec.NAME)
+class YamapUtils(reactContext: ReactApplicationContext) : NativeYamapUtilsSpec(reactContext) {
+
+    private fun withView(viewId: Double, promise: Promise, action: (YamapLiteView) -> Unit) {
+        UiThreadUtil.runOnUiThread {
+            try {
+                val uiManager =
+                        UIManagerHelper.getUIManager(getReactApplicationContext(), viewId.toInt())
+                val view = uiManager?.resolveView(viewId.toInt()) as? YamapLiteView
+                if (view != null) {
+                    action(view)
+                } else {
+                    promise.reject("YamapLite", "failed to get view")
+                }
+            } catch (e: Exception) {
+                promise.reject("YamapLite", "failed to resolve view", e)
+            }
+        }
+    }
+
+    override fun getCameraPosition(viewId: Double, promise: Promise) =
+            withView(viewId, promise) { view ->
+                val cameraPosition = view.getCameraPosition()
+                if (cameraPosition != null) {
+                    promise.resolve(cameraPosition)
+                } else {
+                    promise.reject("YamapLite", "failed to get camera position")
+                }
+            }
+
+    override fun getMapObjectCount(viewId: Double, promise: Promise) =
+            withView(viewId, promise) { view ->
+                promise.resolve(view.getMapObjectCount().toDouble())
+            }
+
+    override fun getScreenPoints(viewId: Double, points: ReadableArray, promise: Promise) =
+            withView(viewId, promise) { view ->
+                val screenPoints = view.getScreenPoints(PointParser.parsePoints(points))
+                promise.resolve(Arguments.createMap().apply { putArray("points", screenPoints) })
+            }
+
+    override fun getVisibleRegion(viewId: Double, promise: Promise) =
+            withView(viewId, promise) { view ->
+                val visibleRegion = view.getVisibleRegion()
+                if (visibleRegion != null) {
+                    promise.resolve(visibleRegion)
+                } else {
+                    promise.reject("YamapLite", "failed to get visible region")
+                }
+            }
+
+    override fun fitAllMarkers(viewId: Double, promise: Promise) =
+            withView(viewId, promise) { view ->
+                view.fitAllMarkers()
+                promise.resolve(null)
+            }
+
+    override fun setZoom(
+            viewId: Double,
+            zoom: Double,
+            duration: Double,
+            animation: String,
+            promise: Promise
+    ) =
+            withView(viewId, promise) { view ->
+                view.setZoom(zoom.toFloat(), duration.toInt(), animation)
+                promise.resolve(null)
+            }
+
+    override fun setCenter(
+            viewId: Double,
+            latitude: Double,
+            longitude: Double,
+            zoom: Double,
+            azimuth: Double,
+            tilt: Double,
+            duration: Double,
+            animation: String,
+            promise: Promise
+    ) =
+            withView(viewId, promise) { view ->
+                view.setCenter(
+                        latitude,
+                        longitude,
+                        zoom.toFloat(),
+                        azimuth.toFloat(),
+                        tilt.toFloat(),
+                        duration.toInt(),
+                        animation
+                )
+                promise.resolve(null)
+            }
+
+    override fun getWorldPoints(viewId: Double, points: ReadableArray, promise: Promise) =
+            withView(viewId, promise) { view ->
+                val worldPoints = view.getWorldPoints(PointParser.parseScreenPoints(points))
+                promise.resolve(Arguments.createMap().apply { putArray("points", worldPoints) })
+            }
+
+    override fun init(apiKey: String, promise: Promise) {
+        UiThreadUtil.runOnUiThread {
+            try {
+                if (!isInitialized) {
+                    MapKitFactory.setApiKey(apiKey)
+                    MapKitFactory.initialize(getReactApplicationContext())
+                    isInitialized = true
+                }
+                promise.resolve(null)
+            } catch (e: Exception) {
+                promise.reject("YamapLite", "failed to init MapKit", e)
+            }
+        }
+    }
+
+    override fun getLocale(promise: Promise) {
+        UiThreadUtil.runOnUiThread {
+            try {
+                val locale = I18nManagerFactory.getLocale()
+                if (locale != null) {
+                    promise.resolve(locale)
+                } else {
+                    promise.reject("YamapLite", "failed to get locale")
+                }
+            } catch (e: Exception) {
+                promise.reject("YamapLite", "failed to get locale", e)
+            }
+        }
+    }
+
+    override fun setLocale(locale: String, promise: Promise) {
+        UiThreadUtil.runOnUiThread {
+            try {
+                I18nManagerFactory.setLocale(locale)
+                promise.resolve(null)
+            } catch (e: Exception) {
+                promise.reject("YamapLite", "failed to set locale", e)
+            }
+        }
+    }
+
+    override fun resetLocale(promise: Promise) {
+        UiThreadUtil.runOnUiThread {
+            try {
+                I18nManagerFactory.setLocale(null)
+                promise.resolve(null)
+            } catch (e: Exception) {
+                promise.reject("YamapLite", "failed to reset locale", e)
+            }
+        }
+    }
+
+    companion object {
+        @Volatile private var isInitialized = false
+    }
+}

package/android/src/main/java/com/yamaplite/YamapLiteCircleViewManager.kt

@@ -0,0 +1,67 @@
+package com.yamaplite
+
+import android.graphics.Color
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.YamapLiteCircleViewManagerInterface
+import com.yamaplite.components.YamapCircle
+import com.yandex.mapkit.geometry.Point
+
+@ReactModule(name = YamapLiteCircleViewManager.NAME)
+class YamapLiteCircleViewManager :
+        SimpleViewManager<YamapCircle>(), YamapLiteCircleViewManagerInterface<YamapCircle> {
+
+    override fun getName(): String {
+        return NAME
+    }
+
+    override fun createViewInstance(context: ThemedReactContext): YamapCircle {
+        return YamapCircle(context)
+    }
+
+    @ReactProp(name = "fillColor")
+    override fun setFillColor(view: YamapCircle, color: Int?) {
+        view.setFillColor(color ?: Color.BLACK)
+    }
+
+    @ReactProp(name = "strokeColor")
+    override fun setStrokeColor(view: YamapCircle, color: Int?) {
+        view.setStrokeColor(color ?: Color.BLACK)
+    }
+
+    @ReactProp(name = "strokeWidth", defaultFloat = 1f)
+    override fun setStrokeWidth(view: YamapCircle, width: Float) {
+        view.setStrokeWidth(width)
+    }
+
+    @ReactProp(name = "zInd", defaultInt = 0)
+    override fun setZInd(view: YamapCircle, zInd: Int) {
+        view.setZInd(zInd)
+    }
+
+    @ReactProp(name = "center")
+    override fun setCenter(view: YamapCircle, center: ReadableMap?) {
+        if (center != null) {
+            val lat = if (center.hasKey("lat")) center.getDouble("lat") else 0.0
+            val lon = if (center.hasKey("lon")) center.getDouble("lon") else 0.0
+            view.setCenter(Point(lat, lon))
+        }
+    }
+
+    @ReactProp(name = "radius", defaultFloat = 0f)
+    override fun setRadius(view: YamapCircle, radius: Float) {
+        view.setRadius(radius)
+    }
+
+    @ReactProp(name = "handled", defaultBoolean = false)
+    override fun setHandled(view: YamapCircle, handled: Boolean) {
+        view.setHandled(handled)
+    }
+
+    companion object {
+        const val NAME = "YamapLiteCircleView"
+    }
+}

package/android/src/main/java/com/yamaplite/YamapLiteMarkerViewManager.kt

@@ -0,0 +1,82 @@
+package com.yamaplite
+
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.viewmanagers.YamapLiteMarkerViewManagerInterface
+import com.facebook.react.viewmanagers.YamapLiteMarkerViewManagerDelegate
+import com.yamaplite.components.YamapLiteMarkerView
+
+class YamapLiteMarkerViewManager : SimpleViewManager<YamapLiteMarkerView>(), YamapLiteMarkerViewManagerInterface<YamapLiteMarkerView> {
+  private val mDelegate: ViewManagerDelegate<YamapLiteMarkerView>
+
+  init {
+    mDelegate = YamapLiteMarkerViewManagerDelegate(this)
+  }
+
+  override fun getDelegate(): ViewManagerDelegate<YamapLiteMarkerView> = mDelegate
+
+  override fun getName(): String = "YamapLiteMarkerView"
+
+  override fun createViewInstance(context: ThemedReactContext): YamapLiteMarkerView {
+    return YamapLiteMarkerView(context)
+  }
+
+  override fun onDropViewInstance(view: YamapLiteMarkerView) {
+    view.onDrop()
+    super.onDropViewInstance(view)
+  }
+
+  @ReactProp(name = "point")
+  override fun setPoint(view: YamapLiteMarkerView, value: ReadableMap?) {
+    if (value == null) return
+    val lat = if (value.hasKey("lat")) value.getDouble("lat") else 0.0
+    val lon = if (value.hasKey("lon")) value.getDouble("lon") else 0.0
+    view.setPoint(lat, lon)
+  }
+
+  @ReactProp(name = "source")
+  override fun setSource(view: YamapLiteMarkerView, value: String?) {
+    view.setIconSource(value)
+  }
+
+  @ReactProp(name = "scale")
+  override fun setScale(view: YamapLiteMarkerView, value: Double) {
+    view.setScale(value)
+  }
+
+  @ReactProp(name = "zInd")
+  override fun setZInd(view: YamapLiteMarkerView, value: Int) {
+    view.setZInd(value)
+  }
+
+  @ReactProp(name = "visible")
+  override fun setVisible(view: YamapLiteMarkerView, value: Boolean) {
+    view.setVisible(value)
+  }
+
+  @ReactProp(name = "anchor")
+  override fun setAnchor(view: YamapLiteMarkerView, value: ReadableMap?) {
+    if (value == null) return
+    val x = if (value.hasKey("x")) value.getDouble("x") else 0.5
+    val y = if (value.hasKey("y")) value.getDouble("y") else 0.5
+    view.setAnchor(x, y)
+  }
+  
+  @ReactProp(name = "rotated")
+  override fun setRotated(view: YamapLiteMarkerView, value: Boolean) {
+    view.setRotated(value)
+  }
+  
+  @ReactProp(name = "handled")
+  override fun setHandled(view: YamapLiteMarkerView, value: Boolean) {
+    view.setHandled(value)
+  }
+
+  @ReactProp(name = "size")
+  override fun setSize(view: YamapLiteMarkerView, size: Int) {
+    view.setSize(size)
+  }
+}

package/android/src/main/java/com/yamaplite/YamapLitePackage.kt

@@ -0,0 +1,41 @@
+package com.yamaplite
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager
+import com.yamaplite.utils.YamapUtils
+
+class YamapLiteViewPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? =
+          when (name) {
+            NativeYamapUtilsSpec.NAME -> YamapUtils(reactContext)
+            else -> null
+          }
+
+  override fun getReactModuleInfoProvider() = ReactModuleInfoProvider {
+    mapOf(
+            NativeYamapUtilsSpec.NAME to
+                    ReactModuleInfo(
+                            NativeYamapUtilsSpec.NAME,
+                            NativeYamapUtilsSpec.NAME,
+                            false,
+                            false,
+                            false,
+                            true
+                    )
+    )
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
+          listOf<ViewManager<*, *>>(
+                  YamapLiteViewManager(),
+                  YamapLiteMarkerViewManager(),
+                  YamapLiteCircleViewManager(),
+                  YamapLitePolylineViewManager(),
+                  YamapLitePolygonViewManager(),
+                  ClusteredYamapLiteViewManager()
+          )
+}

package/android/src/main/java/com/yamaplite/YamapLitePolygonViewManager.kt

@@ -0,0 +1,61 @@
+package com.yamaplite
+
+import android.graphics.Color
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.YamapLitePolygonViewManagerInterface
+import com.yamaplite.components.YamapPolygon
+import com.yamaplite.utils.PointParser
+
+class YamapLitePolygonViewManager :
+        SimpleViewManager<YamapPolygon>(), YamapLitePolygonViewManagerInterface<YamapPolygon> {
+
+    override fun getName(): String {
+        return NAME
+    }
+
+    override fun createViewInstance(context: ThemedReactContext): YamapPolygon {
+        return YamapPolygon(context)
+    }
+
+    @ReactProp(name = "fillColor")
+    override fun setFillColor(view: YamapPolygon, color: Int?) {
+        view.setFillColor(color ?: Color.BLACK)
+    }
+
+    @ReactProp(name = "strokeColor")
+    override fun setStrokeColor(view: YamapPolygon, color: Int?) {
+        view.setStrokeColor(color ?: Color.BLACK)
+    }
+
+    @ReactProp(name = "strokeWidth")
+    override fun setStrokeWidth(view: YamapPolygon, width: Float) {
+        view.setStrokeWidth(width)
+    }
+
+    @ReactProp(name = "zInd")
+    override fun setZInd(view: YamapPolygon, zIndex: Int) {
+        view.setZIndex(zIndex.toFloat())
+    }
+
+    @ReactProp(name = "points")
+    override fun setPoints(view: YamapPolygon, points: ReadableArray?) {
+        view.setPoints(PointParser.parsePoints(points))
+    }
+
+    @ReactProp(name = "innerRings")
+    override fun setInnerRings(view: YamapPolygon, innerRings: ReadableArray?) {
+        view.setInnerRings(PointParser.parseRings(innerRings))
+    }
+
+    @ReactProp(name = "handled")
+    override fun setHandled(view: YamapPolygon, handled: Boolean) {
+        view.setHandled(handled)
+    }
+
+    companion object {
+        const val NAME = "YamapLitePolygonView"
+    }
+}