@exterio/react-native-yamap-lite 1.0.1

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

@@ -0,0 +1,75 @@
+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.YamapLitePolylineViewManagerInterface
+import com.yamaplite.components.YamapPolyline
+import com.yamaplite.utils.PointParser
+
+class YamapLitePolylineViewManager :
+        SimpleViewManager<YamapPolyline>(), YamapLitePolylineViewManagerInterface<YamapPolyline> {
+    override fun getName(): String {
+        return NAME
+    }
+
+    override fun createViewInstance(context: ThemedReactContext): YamapPolyline {
+        return YamapPolyline(context)
+    }
+
+    @ReactProp(name = "strokeColor")
+    override fun setStrokeColor(view: YamapPolyline, color: Int?) {
+        view.setStrokeColor(color ?: Color.BLACK)
+    }
+
+    @ReactProp(name = "strokeWidth")
+    override fun setStrokeWidth(view: YamapPolyline, width: Float) {
+        view.setStrokeWidth(width)
+    }
+
+    @ReactProp(name = "outlineColor")
+    override fun setOutlineColor(view: YamapPolyline, color: Int?) {
+        view.setOutlineColor(color ?: Color.BLACK)
+    }
+
+    @ReactProp(name = "zInd")
+    override fun setZInd(view: YamapPolyline, zIndex: Int) {
+        view.setZIndex(zIndex.toFloat())
+    }
+
+    @ReactProp(name = "dashLength")
+    override fun setDashLength(view: YamapPolyline, length: Float) {
+        view.setDashLength(length)
+    }
+
+    @ReactProp(name = "gapLength")
+    override fun setGapLength(view: YamapPolyline, length: Float) {
+        view.setGapLength(length)
+    }
+
+    @ReactProp(name = "outlineWidth")
+    override fun setOutlineWidth(view: YamapPolyline, width: Float) {
+        view.setOutlineWidth(width)
+    }
+
+    @ReactProp(name = "dashOffset")
+    override fun setDashOffset(view: YamapPolyline, offset: Float) {
+        view.setDashOffset(offset)
+    }
+
+    @ReactProp(name = "points")
+    override fun setPoints(view: YamapPolyline, points: ReadableArray?) {
+        view.setPoints(PointParser.parsePoints(points))
+    }
+
+    @ReactProp(name = "handled")
+    override fun setHandled(view: YamapPolyline, handled: Boolean) {
+        view.setHandled(handled)
+    }
+
+    companion object {
+        const val NAME = "YamapLitePolylineView"
+    }
+}

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

@@ -0,0 +1,176 @@
+package com.yamaplite
+
+import android.view.View
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.YamapLiteViewManagerDelegate
+import com.facebook.react.viewmanagers.YamapLiteViewManagerInterface
+import com.yamaplite.components.YamapLiteView
+
+class YamapLiteViewManager :
+        ViewGroupManager<YamapLiteView>(), YamapLiteViewManagerInterface<YamapLiteView> {
+  private val mDelegate: ViewManagerDelegate<YamapLiteView>
+
+  init {
+    mDelegate = YamapLiteViewManagerDelegate(this)
+  }
+
+  override fun getDelegate(): ViewManagerDelegate<YamapLiteView> = mDelegate
+
+  override fun createViewInstance(context: ThemedReactContext): YamapLiteView {
+    return YamapLiteView(context)
+  }
+
+  override fun onDropViewInstance(view: YamapLiteView) {
+    view.onDropViewInstance()
+    super.onDropViewInstance(view)
+  }
+
+  override fun addView(parent: YamapLiteView, child: View, index: Int) {
+    parent.addReactChild(child, index)
+    super.addView(parent, child, index)
+  }
+
+  override fun getChildAt(parent: YamapLiteView, index: Int): View {
+    return parent.getReactChildAt(index)
+            ?: throw IndexOutOfBoundsException(
+                    "Index $index is out of bounds for child count ${parent.getReactChildCount()}"
+            )
+  }
+
+  override fun getChildCount(parent: YamapLiteView): Int {
+    return parent.getReactChildCount()
+  }
+
+  override fun removeViewAt(parent: YamapLiteView, index: Int) {
+    val childCount = parent.getReactChildCount()
+    if (index >= 0 && index < childCount) {
+      parent.removeReactChildAt(index)
+      super.removeViewAt(parent, index)
+    }
+  }
+
+  override fun getName() = "YamapLiteView"
+
+  @ReactProp(name = "userLocationIcon")
+  override fun setUserLocationIcon(view: YamapLiteView, value: String?) {
+    view.setUserLocationIcon(value)
+  }
+
+  @ReactProp(name = "userLocationIconScale")
+  override fun setUserLocationIconScale(view: YamapLiteView, value: Float) {
+    view.setUserLocationIconScale(value)
+  }
+
+  @ReactProp(name = "showUserPosition")
+  override fun setShowUserPosition(view: YamapLiteView, value: Boolean) {
+    view.setShowUserPosition(value)
+  }
+
+  @ReactProp(name = "nightMode")
+  override fun setNightMode(view: YamapLiteView, value: Boolean) {
+    view.setNightMode(value)
+  }
+
+  @ReactProp(name = "mapStyle")
+  override fun setMapStyle(view: YamapLiteView, value: String?) {
+    view.setMapStyle(value)
+  }
+
+  @ReactProp(name = "scrollGesturesEnabled")
+  override fun setScrollGesturesEnabled(view: YamapLiteView, _value: Boolean) {
+    view.setScrollGesturesEnabled(_value)
+  }
+
+  @ReactProp(name = "zoomGesturesEnabled")
+  override fun setZoomGesturesEnabled(view: YamapLiteView, _value: Boolean) {
+    view.setZoomGesturesEnabled(_value)
+  }
+
+  @ReactProp(name = "tiltGesturesEnabled")
+  override fun setTiltGesturesEnabled(view: YamapLiteView, _value: Boolean) {
+    view.setTiltGesturesEnabled(_value)
+  }
+
+  @ReactProp(name = "rotateGesturesEnabled")
+  override fun setRotateGesturesEnabled(view: YamapLiteView, _value: Boolean) {
+    view.setRotateGesturesEnabled(_value)
+  }
+
+  @ReactProp(name = "fastTapEnabled")
+  override fun setFastTapEnabled(view: YamapLiteView, _value: Boolean) {
+    view.setFastTapEnabled(_value)
+  }
+
+  @ReactProp(name = "initialRegion")
+  override fun setInitialRegion(view: YamapLiteView, value: ReadableMap?) {
+    if (value != null) {
+      val region = mutableMapOf<String, Any>()
+      if (value.hasKey("lat")) region["lat"] = value.getDouble("lat")
+      if (value.hasKey("lon")) region["lon"] = value.getDouble("lon")
+      if (value.hasKey("zoom")) region["zoom"] = value.getDouble("zoom")
+      if (value.hasKey("azimuth")) region["azimuth"] = value.getDouble("azimuth")
+      if (value.hasKey("tilt")) region["tilt"] = value.getDouble("tilt")
+      view.setInitialRegion(region)
+    }
+  }
+
+  @ReactProp(name = "maxFps")
+  override fun setMaxFps(view: YamapLiteView, _value: Float) {
+    view.setMaxFps(_value)
+  }
+
+  @ReactProp(name = "mapType")
+  override fun setMapType(view: YamapLiteView, _value: String?) {
+    view.setMapType(_value)
+  }
+
+  @ReactProp(name = "logoPosition")
+  override fun setLogoPosition(view: YamapLiteView, _value: ReadableMap?) {
+    if (_value != null) {
+      val position = mutableMapOf<String, Any>()
+      if (_value.hasKey("vertical")) position["vertical"] = _value.getString("vertical") ?: "bottom"
+      if (_value.hasKey("horizontal"))
+              position["horizontal"] = _value.getString("horizontal") ?: "left"
+      view.setLogoPosition(position)
+    }
+  }
+
+  @ReactProp(name = "logoPadding")
+  override fun setLogoPadding(view: YamapLiteView, _value: ReadableMap?) {
+    if (_value != null) {
+      val horizontalPadding =
+              if ((_value.hasKey("horizontal") && !_value.isNull("horizontal")))
+                      _value.getInt("horizontal")
+              else 0
+      val verticalPadding =
+              if ((_value.hasKey("vertical") && !_value.isNull("vertical")))
+                      _value.getInt("vertical")
+              else 0
+      view.setLogoPadding(horizontalPadding, verticalPadding)
+    }
+  }
+
+  @ReactProp(name = "userLocationAccuracyFillColor")
+  override fun setUserLocationAccuracyFillColor(view: YamapLiteView, _value: String?) {
+    view.setUserLocationAccuracyFillColor(_value)
+  }
+
+  @ReactProp(name = "userLocationAccuracyStrokeColor")
+  override fun setUserLocationAccuracyStrokeColor(view: YamapLiteView, _value: String?) {
+    view.setUserLocationAccuracyStrokeColor(_value)
+  }
+
+  @ReactProp(name = "userLocationAccuracyStrokeWidth")
+  override fun setUserLocationAccuracyStrokeWidth(view: YamapLiteView, _value: Float) {
+    view.setUserLocationAccuracyStrokeWidth(_value)
+  }
+
+  @ReactProp(name = "followUser")
+  override fun setFollowUser(view: YamapLiteView, _value: Boolean) {
+    view.setFollowUser(_value)
+  }
+}

package/ios/ClusteredYamapLiteView.h

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

package/ios/ClusteredYamapLiteView.mm

@@ -0,0 +1,325 @@
+#import "ClusteredYamapLiteView.h"
+#include <os/log.h>
+#include "ReactCodegen/react/renderer/components/YamapLiteViewSpec/EventEmitters.h"
+#include "YamapLiteCircleView.h"
+#include "YamapLiteMarkerView.h"
+#include "YamapLitePolygonView.h"
+#include "YamapLitePolylineView.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 "RCTFabricComponentsPlugins.h"
+#import "YamapLite-Swift.h"
+#import <YandexMapsMobile/YMKMapKitFactory.h>
+
+using namespace facebook::react;
+
+@interface ClusteredYamapLiteView () <RCTClusteredYamapLiteViewViewProtocol,
+                                      YamapViewComponentDelegate>
+
+@end
+
+@implementation ClusteredYamapLiteView {
+  ClusteredYamapView *_view;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<
+      ClusteredYamapLiteViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps =
+        std::make_shared<const ClusteredYamapLiteViewProps>();
+    _props = defaultProps;
+
+    _view = [[ClusteredYamapView 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<ClusteredYamapLiteViewProps const>(_props);
+  const auto &newViewProps =
+      *std::static_pointer_cast<ClusteredYamapLiteViewProps const>(props);
+  // Ensure all map property updates happen on the main thread
+  // React Native Fabric can call updateProps from a background thread
+  dispatch_async(dispatch_get_main_queue(), ^{
+    // Always update properties from newViewProps to ensure applyProperties()
+    // uses correct values
+    NSString *sampleRate =
+        RCTNSStringFromStringNilIfEmpty(toString(newViewProps.mapType));
+    self->_view.mapType = sampleRate;
+    self->_view.nightMode = newViewProps.nightMode;
+    self->_view.zoomGesturesEnabled = newViewProps.zoomGesturesEnabled;
+    self->_view.scrollGesturesEnabled = newViewProps.scrollGesturesEnabled;
+    self->_view.rotateGesturesEnabled = newViewProps.rotateGesturesEnabled;
+    self->_view.tiltGesturesEnabled = newViewProps.tiltGesturesEnabled;
+    self->_view.fastTapEnabled = newViewProps.fastTapEnabled;
+    self->_view.userLocationAccuracyFillColor =
+        [self hexStringToColor:RCTNSStringFromString(
+                                   newViewProps.userLocationAccuracyFillColor)];
+    self->_view.userLocationAccuracyStrokeColor = [self
+        hexStringToColor:RCTNSStringFromString(
+                             newViewProps.userLocationAccuracyStrokeColor)];
+    self->_view.userLocationAccuracyStrokeWidth =
+        newViewProps.userLocationAccuracyStrokeWidth;
+    self->_view.showUserPosition = newViewProps.showUserPosition;
+    self->_view.userLocationIconScale = newViewProps.userLocationIconScale;
+    self->_view.clusterColor = [self
+        hexStringToColor:RCTNSStringFromString(newViewProps.clusterColor)];
+
+    NSMutableArray<YMKPoint *> *markersArr =
+        [NSMutableArray arrayWithCapacity:newViewProps.clusteredMarkers.size()];
+
+    for (const auto &marker : newViewProps.clusteredMarkers) {
+      YMKPoint *point = [YMKPoint pointWithLatitude:marker.lat
+                                          longitude:marker.lon];
+      [markersArr addObject:point];
+    }
+
+    [self->_view setupClusteredMarkersWithMarkers:markersArr];
+    NSDictionary *logoPositionDict = @{
+      @"horizontal" :
+          RCTNSStringFromString(toString(newViewProps.logoPosition.horizontal)),
+      @"vertical" :
+          RCTNSStringFromString(toString(newViewProps.logoPosition.vertical))
+    };
+    [self->_view setShowUserPositionState:newViewProps.showUserPosition];
+    [self->_view updateUserIcon];
+    [self->_view
+        setUserLocationIconWithPath:RCTNSStringFromString(
+                                        newViewProps.userLocationIcon)];
+    [self->_view move:newViewProps.initialRegion.lat :newViewProps.initialRegion.lon :newViewProps.initialRegion.zoom :newViewProps.initialRegion.azimuth :newViewProps.initialRegion.tilt];
+    [self->_view setLogoPositionWithPosition:logoPositionDict];
+    [self->_view
+        setLogoPaddingWithVertical:newViewProps.logoPadding.vertical
+                        horizontal:newViewProps.logoPadding.horizontal];
+    self->_view.maxFps = newViewProps.maxFps;
+    [self->_view applyProperties];
+  });
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)handleCommand:(NSString *)commandName args:(NSArray *)args {
+}
+
+- (void)setCenter:(double)latitude
+        longitude:(double)longitude
+             zoom:(float)zoom
+          azimuth:(float)azimuth
+             tilt:(float)tilt
+         duration:(float)duration
+        animation:(NSString *)animation {
+  [_view setCenterWithLatitude:latitude
+                     longitude:longitude
+                          zoom:zoom
+                       azimuth:azimuth
+                          tilt:tilt
+                      duration:duration
+                     animation:animation];
+}
+
+- (void)setZoom:(float)zoom
+       duration:(float)duration
+      animation:(NSString *)animation {
+  if (_view != nil) {
+    [_view setZoomWithZoom:zoom duration:duration animation:animation];
+  } else {
+    os_log_error(OS_LOG_DEFAULT, "ClusteredYamapLiteView: _view is nil");
+  }
+}
+
+- (void)fitAllMarkers {
+  if (_view != nil) {
+    [_view fitAllMarkers];
+  } else {
+    os_log_error(OS_LOG_DEFAULT, "ClusteredYamapLiteView: _view is nil");
+  }
+}
+
+- (void)handleOnMapLoadedWithResult:(NSDictionary *)obj {
+  if (_view != nil) {
+    [_view applyProperties];
+  }
+
+  if (_eventEmitter != nil) {
+    ClusteredYamapLiteViewEventEmitter::OnMapLoaded event = {};
+    event.curZoomGeometryLoaded =
+        [[obj objectForKey:@"curZoomGeometryLoaded"] doubleValue];
+    event.curZoomModelsLoaded =
+        [[obj objectForKey:@"curZoomModelsLoaded"] doubleValue];
+    event.curZoomLabelsLoaded =
+        [[obj objectForKey:@"curZoomLabelsLoaded"] doubleValue];
+    event.curZoomPlacemarksLoaded =
+        [[obj objectForKey:@"curZoomPlacemarksLoaded"] doubleValue];
+    event.fullyLoaded = [[obj objectForKey:@"fullyLoaded"] doubleValue];
+    event.renderObjectCount =
+        [[obj objectForKey:@"renderObjectCount"] doubleValue];
+    event.tileMemoryUsage = [[obj objectForKey:@"tileMemoryUsage"] doubleValue];
+    event.delayedGeometryLoaded =
+        [[obj objectForKey:@"delayedGeometryLoaded"] doubleValue];
+    event.fullyAppeared = [[obj objectForKey:@"fullyAppeared"] doubleValue];
+    std::dynamic_pointer_cast<const ClusteredYamapLiteViewEventEmitter>(
+        _eventEmitter)
+        ->onMapLoaded(event);
+  }
+}
+
+- (void)handleOnCameraPositionChangeWithCoords:(NSDictionary *)coords {
+  if (_eventEmitter != nil) {
+    ClusteredYamapLiteViewEventEmitter::OnCameraPositionChange event = {};
+    event.point.lat = [[coords objectForKey:@"lat"] doubleValue];
+    event.point.lon = [[coords objectForKey:@"lon"] doubleValue];
+    event.zoom = [[coords objectForKey:@"zoom"] doubleValue];
+    event.azimuth = [[coords objectForKey:@"azimuth"] doubleValue];
+    event.tilt = [[coords objectForKey:@"tilt"] doubleValue];
+    event.finished = [[coords objectForKey:@"finished"] boolValue];
+    event.target = [[coords objectForKey:@"target"] doubleValue];
+
+    // Handle reason string - Swift strings bridge to NSString
+    id reasonObj = [coords objectForKey:@"reason"];
+    NSString *reasonString = @"GESTURES"; // default fallback
+    if ([reasonObj isKindOfClass:[NSString class]]) {
+      reasonString = (NSString *)reasonObj;
+    } else if (reasonObj != nil) {
+      // Fallback: try to get string representation
+      reasonString = [NSString stringWithFormat:@"%@", reasonObj];
+    }
+    if ([reasonString isEqualToString:@"APPLICATION"]) {
+      event.reason = ClusteredYamapLiteViewEventEmitter::
+          OnCameraPositionChangeReason::APPLICATION;
+    } else {
+      event.reason = ClusteredYamapLiteViewEventEmitter::
+          OnCameraPositionChangeReason::GESTURES;
+    }
+
+    std::dynamic_pointer_cast<const ClusteredYamapLiteViewEventEmitter>(
+        _eventEmitter)
+        ->onCameraPositionChange(event);
+  }
+}
+
+- (void)handleOnCameraPositionChangeEndWithCoords:
+    (NSDictionary<NSString *, id> *)coords {
+  if (_eventEmitter != nil) {
+    ClusteredYamapLiteViewEventEmitter::OnCameraPositionChangeEnd event = {};
+    event.point.lat = [[coords objectForKey:@"lat"] doubleValue];
+    event.point.lon = [[coords objectForKey:@"lon"] doubleValue];
+    event.zoom = [[coords objectForKey:@"zoom"] doubleValue];
+    event.azimuth = [[coords objectForKey:@"azimuth"] doubleValue];
+    event.tilt = [[coords objectForKey:@"tilt"] doubleValue];
+    event.finished = [[coords objectForKey:@"finished"] boolValue];
+    event.target = [[coords objectForKey:@"target"] doubleValue];
+
+    // Handle reason string - Swift strings bridge to NSString
+    id reasonObj = [coords objectForKey:@"reason"];
+    NSString *reasonString = @"GESTURES"; // default fallback
+    if ([reasonObj isKindOfClass:[NSString class]]) {
+      reasonString = (NSString *)reasonObj;
+    } else if (reasonObj != nil) {
+      // Fallback: try to get string representation
+      reasonString = [NSString stringWithFormat:@"%@", reasonObj];
+    }
+    if ([reasonString isEqualToString:@"APPLICATION"]) {
+      event.reason = ClusteredYamapLiteViewEventEmitter::
+          OnCameraPositionChangeEndReason::APPLICATION;
+    } else {
+      event.reason = ClusteredYamapLiteViewEventEmitter::
+          OnCameraPositionChangeEndReason::GESTURES;
+    }
+    std::dynamic_pointer_cast<const ClusteredYamapLiteViewEventEmitter>(
+        _eventEmitter)
+        ->onCameraPositionChangeEnd(event);
+  }
+}
+
+- (void)handleOnMapPressWithCoords:(NSDictionary *)coords {
+  if (_eventEmitter != nil) {
+    ClusteredYamapLiteViewEventEmitter::OnMapPress event = {};
+    event.lat = [[coords objectForKey:@"lat"] doubleValue];
+    event.lon = [[coords objectForKey:@"lon"] doubleValue];
+    std::dynamic_pointer_cast<const ClusteredYamapLiteViewEventEmitter>(
+        _eventEmitter)
+        ->onMapPress(event);
+  }
+}
+
+- (void)handleOnMapLongPressWithCoords:(NSDictionary *)coords {
+  if (_eventEmitter != nil) {
+    ClusteredYamapLiteViewEventEmitter::OnMapLongPress event = {};
+    event.lat = [[coords objectForKey:@"lat"] doubleValue];
+    event.lon = [[coords objectForKey:@"lon"] doubleValue];
+    std::dynamic_pointer_cast<const ClusteredYamapLiteViewEventEmitter>(
+        _eventEmitter)
+        ->onMapLongPress(event);
+  }
+}
+
+- (void)mountChildComponentView:
+            (nonnull UIView<RCTComponentViewProtocol> *)childComponentView
+                          index:(NSInteger)index {
+  if ([childComponentView isKindOfClass:YamapLiteMarkerView.class]) {
+    [_view insertReactSubview:childComponentView atIndex:index];
+  }
+  if ([childComponentView isKindOfClass:YamapLiteCircleView.class]) {
+    [_view insertReactSubview:childComponentView atIndex:index];
+  }
+  if ([childComponentView isKindOfClass:YamapLitePolygonView.class]) {
+    [_view insertReactSubview:childComponentView atIndex:index];
+  }
+  if ([childComponentView isKindOfClass:YamapLitePolylineView.class]) {
+    [_view insertReactSubview:childComponentView atIndex:index];
+  }
+}
+- (void)unmountChildComponentView:
+            (nonnull UIView<RCTComponentViewProtocol> *)childComponentView
+                            index:(NSInteger)index {
+  if ([childComponentView isKindOfClass:YamapLiteMarkerView.class] ||
+      [childComponentView isKindOfClass:YamapLiteCircleView.class] ||
+      [childComponentView isKindOfClass:YamapLitePolygonView.class] ||
+      [childComponentView isKindOfClass:YamapLitePolylineView.class]) {
+    [_view removeReactSubview:childComponentView];
+    [childComponentView removeFromSuperview];
+  }
+}
+
+Class<RCTComponentViewProtocol> ClusteredYamapLiteViewCls(void) {
+  return ClusteredYamapLiteView.class;
+}
+
+- hexStringToColor:(NSString *)stringToConvert {
+  NSString *noHashString =
+      [stringToConvert stringByReplacingOccurrencesOfString:@"#"
+                                                 withString:@""];
+  NSScanner *stringScanner = [NSScanner scannerWithString:noHashString];
+
+  unsigned hex;
+  if (![stringScanner scanHexInt:&hex])
+    return nil;
+  int r = (hex >> 16) & 0xFF;
+  int g = (hex >> 8) & 0xFF;
+  int b = (hex) & 0xFF;
+
+  return [UIColor colorWithRed:r / 255.0f
+                         green:g / 255.0f
+                          blue:b / 255.0f
+                         alpha:1.0f];
+}
+
+@end

package/ios/ClusteredYamapLiteViewManager.mm

@@ -0,0 +1,17 @@
+#import <React/RCTViewManager.h>
+#import <React/RCTUIManager.h>
+#import "RCTBridge.h"
+
+@interface ClusteredYamapLiteViewManager : RCTViewManager
+@end
+
+@implementation ClusteredYamapLiteViewManager
+
+RCT_EXPORT_MODULE(ClusteredYamapLiteView)
+
+- (UIView *)view
+{
+  return [[UIView alloc] init];
+}
+
+@end