@mapvina-com/mapvina-react-native 1.0.0

package/ios/components/map-view/MLRNMapViewComponentView.h

@@ -0,0 +1,13 @@
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+#import <React/RCTUIManager.h>
+#import <React/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface MLRNMapViewComponentView : RCTViewComponentView
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/components/map-view/MLRNMapViewComponentView.mm

@@ -0,0 +1,430 @@
+#import "MLRNMapViewComponentView.h"
+
+#import <react/renderer/components/MapVinaReactNativeSpec/ComponentDescriptors.h>
+#import <react/renderer/components/MapVinaReactNativeSpec/EventEmitters.h>
+#import <react/renderer/components/MapVinaReactNativeSpec/Props.h>
+#import <react/renderer/components/MapVinaReactNativeSpec/RCTComponentViewHelpers.h>
+
+#import "RCTFabricComponentsPlugins.h"
+
+#import <React/RCTConversions.h>
+#import "MLRNFollyConvert.h"
+#import "MLRNMapView.h"
+
+using namespace facebook::react;
+
+struct PressEvent {
+  folly::dynamic lngLat;
+  folly::dynamic point;
+};
+
+PressEvent createPressEvent(NSDictionary *dict) {
+  PressEvent result;
+
+  result.lngLat = folly::dynamic::array([dict[@"properties"][@"lngLat"][0] doubleValue],
+                                        [dict[@"properties"][@"lngLat"][1] doubleValue]);
+  result.point = folly::dynamic::array([dict[@"properties"][@"point"][0] doubleValue],
+                                       [dict[@"properties"][@"point"][1] doubleValue]);
+
+  return result;
+}
+
+struct ViewState {
+  folly::dynamic center;
+  double zoom;
+  double bearing;
+  double pitch;
+  folly::dynamic bounds;
+  bool animated;
+  bool userInteraction;
+};
+
+ViewState createViewState(NSDictionary *dict) {
+  ViewState result;
+
+  result.center =
+      folly::dynamic::array([dict[@"center"][0] doubleValue], [dict[@"center"][1] doubleValue]);
+  result.zoom = [dict[@"zoom"] doubleValue];
+  result.bearing = [dict[@"bearing"] doubleValue];
+  result.pitch = [dict[@"pitch"] doubleValue];
+
+  result.bounds =
+      folly::dynamic::array([dict[@"bounds"][0] doubleValue], [dict[@"bounds"][1] doubleValue],
+                            [dict[@"bounds"][2] doubleValue], [dict[@"bounds"][3] doubleValue]);
+
+  result.animated = [dict[@"animated"] boolValue];
+  result.userInteraction = [dict[@"userInteraction"] boolValue];
+
+  return result;
+}
+
+// MARK: - MLRNMapViewComponentView
+
+@interface MLRNMapViewComponentView () <RCTMLRNMapViewViewProtocol>
+
+@end
+
+@implementation MLRNMapViewComponentView {
+  MLRNMapView *_view;
+  CGRect _frame;
+}
+
++ (BOOL)shouldBeRecycled {
+  return NO;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const MLRNMapViewProps>();
+    _props = defaultProps;
+    _frame = frame;
+    [self prepareView];
+  }
+
+  return self;
+}
+
+- (void)prepareView {
+  _view = [[MLRNMapView alloc] initWithFrame:_frame];
+
+  // Capture weak self reference to prevent retain cycle
+  __weak __typeof__(self) weakSelf = self;
+
+  [_view setReactOnPress:^(NSDictionary *event) {
+    __typeof__(self) strongSelf = weakSelf;
+
+    if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+      PressEvent pressEvent = createPressEvent(event);
+
+      facebook::react::MLRNMapViewEventEmitter::OnPress eventStruct{pressEvent.lngLat,
+                                                                    pressEvent.point};
+
+      std::dynamic_pointer_cast<const facebook::react::MLRNMapViewEventEmitter>(
+          strongSelf->_eventEmitter)
+          ->onPress(eventStruct);
+    }
+  }];
+
+  [_view setReactOnLongPress:^(NSDictionary *event) {
+    __typeof__(self) strongSelf = weakSelf;
+
+    if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+      PressEvent pressEvent = createPressEvent(event);
+
+      facebook::react::MLRNMapViewEventEmitter::OnLongPress eventStruct{pressEvent.lngLat,
+                                                                        pressEvent.point};
+
+      std::dynamic_pointer_cast<const facebook::react::MLRNMapViewEventEmitter>(
+          strongSelf->_eventEmitter)
+          ->onLongPress(eventStruct);
+    }
+  }];
+
+  [_view setReactOnRegionWillChange:^(NSDictionary *event) {
+    __typeof__(self) strongSelf = weakSelf;
+
+    if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+      ViewState viewState = createViewState(event);
+
+      facebook::react::MLRNMapViewEventEmitter::OnRegionWillChange eventStruct{
+          viewState.center, viewState.zoom,     viewState.bearing,        viewState.pitch,
+          viewState.bounds, viewState.animated, viewState.userInteraction};
+
+      std::dynamic_pointer_cast<const facebook::react::MLRNMapViewEventEmitter>(
+          strongSelf->_eventEmitter)
+          ->onRegionWillChange(eventStruct);
+    }
+  }];
+  [_view setReactOnRegionIsChanging:^(NSDictionary *event) {
+    __typeof__(self) strongSelf = weakSelf;
+
+    if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+      ViewState viewState = createViewState(event);
+
+      facebook::react::MLRNMapViewEventEmitter::OnRegionIsChanging eventStruct{
+          viewState.center, viewState.zoom,     viewState.bearing,        viewState.pitch,
+          viewState.bounds, viewState.animated, viewState.userInteraction};
+
+      std::dynamic_pointer_cast<const facebook::react::MLRNMapViewEventEmitter>(
+          strongSelf->_eventEmitter)
+          ->onRegionIsChanging(eventStruct);
+    }
+  }];
+  [_view setReactOnRegionDidChange:^(NSDictionary *event) {
+    __typeof__(self) strongSelf = weakSelf;
+
+    if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+      ViewState viewState = createViewState(event);
+
+      facebook::react::MLRNMapViewEventEmitter::OnRegionDidChange eventStruct{
+          viewState.center, viewState.zoom,     viewState.bearing,        viewState.pitch,
+          viewState.bounds, viewState.animated, viewState.userInteraction};
+
+      std::dynamic_pointer_cast<const facebook::react::MLRNMapViewEventEmitter>(
+          strongSelf->_eventEmitter)
+          ->onRegionDidChange(eventStruct);
+    }
+  }];
+
+  [_view setReactOnWillStartLoadingMap:^(NSDictionary *event) {
+    __typeof__(self) strongSelf = weakSelf;
+
+    if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+      std::dynamic_pointer_cast<const facebook::react::MLRNMapViewEventEmitter>(
+          strongSelf->_eventEmitter)
+          ->onWillStartLoadingMap({});
+    }
+  }];
+  [_view setReactOnDidFinishLoadingMap:^(NSDictionary *event) {
+    __typeof__(self) strongSelf = weakSelf;
+
+    if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+      std::dynamic_pointer_cast<const facebook::react::MLRNMapViewEventEmitter>(
+          strongSelf->_eventEmitter)
+          ->onDidFinishLoadingMap({});
+    }
+  }];
+  [_view setReactOnDidFailLoadingMap:^(NSDictionary *event) {
+    __typeof__(self) strongSelf = weakSelf;
+
+    if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+      std::dynamic_pointer_cast<const facebook::react::MLRNMapViewEventEmitter>(
+          strongSelf->_eventEmitter)
+          ->onDidFailLoadingMap({});
+    }
+  }];
+
+  [_view setReactOnWillStartRenderingFrame:^(NSDictionary *event) {
+    __typeof__(self) strongSelf = weakSelf;
+
+    if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+      std::dynamic_pointer_cast<const facebook::react::MLRNMapViewEventEmitter>(
+          strongSelf->_eventEmitter)
+          ->onWillStartRenderingFrame({});
+    }
+  }];
+  [_view setReactOnDidFinishRenderingFrame:^(NSDictionary *event) {
+    __typeof__(self) strongSelf = weakSelf;
+
+    if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+      std::dynamic_pointer_cast<const facebook::react::MLRNMapViewEventEmitter>(
+          strongSelf->_eventEmitter)
+          ->onDidFinishRenderingFrame({});
+    }
+  }];
+  [_view setReactOnDidFinishRenderingFrameFully:^(NSDictionary *event) {
+    __typeof__(self) strongSelf = weakSelf;
+
+    if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+      std::dynamic_pointer_cast<const facebook::react::MLRNMapViewEventEmitter>(
+          strongSelf->_eventEmitter)
+          ->onDidFinishRenderingFrameFully({});
+    }
+  }];
+
+  [_view setReactOnWillStartRenderingMap:^(NSDictionary *event) {
+    __typeof__(self) strongSelf = weakSelf;
+
+    if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+      std::dynamic_pointer_cast<const facebook::react::MLRNMapViewEventEmitter>(
+          strongSelf->_eventEmitter)
+          ->onWillStartRenderingMap({});
+    }
+  }];
+  [_view setReactOnDidFinishRenderingMap:^(NSDictionary *event) {
+    __typeof__(self) strongSelf = weakSelf;
+
+    if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+      std::dynamic_pointer_cast<const facebook::react::MLRNMapViewEventEmitter>(
+          strongSelf->_eventEmitter)
+          ->onDidFinishRenderingMap({});
+    }
+  }];
+  [_view setReactOnDidFinishRenderingMapFully:^(NSDictionary *event) {
+    __typeof__(self) strongSelf = weakSelf;
+
+    if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+      std::dynamic_pointer_cast<const facebook::react::MLRNMapViewEventEmitter>(
+          strongSelf->_eventEmitter)
+          ->onDidFinishRenderingMapFully({});
+    }
+  }];
+
+  [_view setReactOnDidFinishLoadingStyle:^(NSDictionary *event) {
+    __typeof__(self) strongSelf = weakSelf;
+
+    if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+      std::dynamic_pointer_cast<const facebook::react::MLRNMapViewEventEmitter>(
+          strongSelf->_eventEmitter)
+          ->onDidFinishLoadingStyle({});
+    }
+  }];
+
+  self.contentView = _view;
+}
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView
+                          index:(NSInteger)index {
+  if ([childComponentView isKindOfClass:[RCTViewComponentView class]] &&
+      ((RCTViewComponentView *)childComponentView).contentView) {
+    [_view addToMap:((RCTViewComponentView *)childComponentView).contentView];
+  }
+  [super mountChildComponentView:childComponentView index:index + 1];
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView
+                            index:(NSInteger)index {
+  if ([childComponentView isKindOfClass:[RCTViewComponentView class]] &&
+      ((RCTViewComponentView *)childComponentView).contentView) {
+    [_view removeFromMap:((RCTViewComponentView *)childComponentView).contentView];
+  }
+  [super unmountChildComponentView:childComponentView index:index + 1];
+}
+
+#pragma mark - RCTComponentViewProtocol
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps {
+  const auto &oldViewProps = *std::static_pointer_cast<MLRNMapViewProps const>(_props);
+  const auto &newViewProps = *std::static_pointer_cast<MLRNMapViewProps const>(props);
+
+  if (oldViewProps.mapStyle != newViewProps.mapStyle) {
+    [_view setReactMapStyle:RCTNSStringFromString(newViewProps.mapStyle)];
+  }
+
+  if (oldViewProps.light != newViewProps.light) {
+    NSDictionary *reactLight = (!newViewProps.light.isNull() && newViewProps.light.isObject())
+                                   ? convertFollyDynamicToId(newViewProps.light)
+                                   : nil;
+    [_view setReactLight:reactLight];
+  }
+
+  if (oldViewProps.contentInset.top != newViewProps.contentInset.top ||
+      oldViewProps.contentInset.right != newViewProps.contentInset.right ||
+      oldViewProps.contentInset.bottom != newViewProps.contentInset.bottom ||
+      oldViewProps.contentInset.left != newViewProps.contentInset.left) {
+    NSDictionary *contentInset = @{
+      @"top" : @(newViewProps.contentInset.top),
+      @"right" : @(newViewProps.contentInset.right),
+      @"bottom" : @(newViewProps.contentInset.bottom),
+      @"left" : @(newViewProps.contentInset.left)
+    };
+
+    [_view setReactContentInset:contentInset];
+  }
+
+  if (oldViewProps.preferredFramesPerSecond != newViewProps.preferredFramesPerSecond) {
+    [_view setReactPreferredFramesPerSecond:newViewProps.preferredFramesPerSecond];
+  }
+
+  if (oldViewProps.dragPan != newViewProps.dragPan) {
+    [_view setReactScrollEnabled:newViewProps.dragPan];
+  }
+
+  if (oldViewProps.touchZoom != newViewProps.touchZoom) {
+    [_view setReactTouchZoomEnabled:newViewProps.touchZoom];
+  }
+
+  if (oldViewProps.doubleTapZoom != newViewProps.doubleTapZoom) {
+    [_view setReactDoubleTapZoomEnabled:newViewProps.doubleTapZoom];
+  }
+
+  if (oldViewProps.doubleTapHoldZoom != newViewProps.doubleTapHoldZoom) {
+    [_view setReactDoubleTapHoldZoomEnabled:newViewProps.doubleTapHoldZoom];
+  }
+
+  if (oldViewProps.touchRotate != newViewProps.touchRotate) {
+    [_view setReactRotateEnabled:newViewProps.touchRotate];
+  }
+
+  if (oldViewProps.touchPitch != newViewProps.touchPitch) {
+    [_view setPitchEnabled:newViewProps.touchPitch];
+  }
+
+  if (oldViewProps.tintColor != newViewProps.tintColor) {
+    [_view setTintColor:RCTUIColorFromSharedColor(newViewProps.tintColor)];
+  }
+
+  if (oldViewProps.attribution != newViewProps.attribution) {
+    [_view setReactAttributionEnabled:newViewProps.attribution];
+  }
+
+  if (oldViewProps.attributionPosition.top != newViewProps.attributionPosition.top ||
+      oldViewProps.attributionPosition.right != newViewProps.attributionPosition.right ||
+      oldViewProps.attributionPosition.bottom != newViewProps.attributionPosition.bottom ||
+      oldViewProps.attributionPosition.left != newViewProps.attributionPosition.left) {
+    NSDictionary *attributionPosition = @{
+      @"top" : @(newViewProps.attributionPosition.top),
+      @"right" : @(newViewProps.attributionPosition.right),
+      @"bottom" : @(newViewProps.attributionPosition.bottom),
+      @"left" : @(newViewProps.attributionPosition.left)
+    };
+
+    [_view setReactAttributionPosition:attributionPosition];
+  }
+
+  if (oldViewProps.logo != newViewProps.logo) {
+    [_view setReactLogoEnabled:newViewProps.logo];
+  }
+
+  if (oldViewProps.logoPosition.top != newViewProps.logoPosition.top ||
+      oldViewProps.logoPosition.right != newViewProps.logoPosition.right ||
+      oldViewProps.logoPosition.bottom != newViewProps.logoPosition.bottom ||
+      oldViewProps.logoPosition.left != newViewProps.logoPosition.left) {
+    NSDictionary *logoPosition = @{
+      @"top" : @(newViewProps.logoPosition.top),
+      @"right" : @(newViewProps.logoPosition.right),
+      @"bottom" : @(newViewProps.logoPosition.bottom),
+      @"left" : @(newViewProps.logoPosition.left)
+    };
+
+    [_view setReactLogoPosition:logoPosition];
+  }
+
+  if (oldViewProps.compass != newViewProps.compass) {
+    [_view setReactCompassEnabled:newViewProps.compass];
+  }
+
+  if (oldViewProps.compassPosition.top != newViewProps.compassPosition.top ||
+      oldViewProps.compassPosition.right != newViewProps.compassPosition.right ||
+      oldViewProps.compassPosition.bottom != newViewProps.compassPosition.bottom ||
+      oldViewProps.compassPosition.left != newViewProps.compassPosition.left) {
+    NSDictionary *compassPosition = @{
+      @"top" : @(newViewProps.compassPosition.top),
+      @"right" : @(newViewProps.compassPosition.right),
+      @"bottom" : @(newViewProps.compassPosition.bottom),
+      @"left" : @(newViewProps.compassPosition.left)
+    };
+
+    [_view setReactCompassPosition:compassPosition];
+  }
+
+  if (oldViewProps.compassHiddenFacingNorth != newViewProps.compassHiddenFacingNorth) {
+    [_view setReactCompassHiddenFacingNorth:newViewProps.compassHiddenFacingNorth];
+  }
+
+  if (oldViewProps.scaleBar != newViewProps.scaleBar) {
+    [_view setReactScaleBarEnabled:newViewProps.scaleBar];
+  }
+
+  if (oldViewProps.scaleBarPosition.top != newViewProps.scaleBarPosition.top ||
+      oldViewProps.scaleBarPosition.right != newViewProps.scaleBarPosition.right ||
+      oldViewProps.scaleBarPosition.bottom != newViewProps.scaleBarPosition.bottom ||
+      oldViewProps.scaleBarPosition.left != newViewProps.scaleBarPosition.left) {
+    NSDictionary *scaleBarPosition = @{
+      @"top" : @(newViewProps.scaleBarPosition.top),
+      @"right" : @(newViewProps.scaleBarPosition.right),
+      @"bottom" : @(newViewProps.scaleBarPosition.bottom),
+      @"left" : @(newViewProps.scaleBarPosition.left)
+    };
+
+    [_view setReactScaleBarPosition:scaleBarPosition];
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<MLRNMapViewComponentDescriptor>();
+}
+
+@end

package/ios/components/map-view/MLRNMapViewManager.h

@@ -0,0 +1,70 @@
+#import <MapVina/MapVina.h>
+#import "ViewManager.h"
+
+@interface MLRNMapViewManager : ViewManager <MLNMapViewDelegate>
+
++ (void)getCenter:(MLRNMapView *_Nonnull)view
+          resolve:(RCTPromiseResolveBlock _Nonnull)resolve
+           reject:(RCTPromiseRejectBlock _Nonnull)reject;
+
++ (void)getZoom:(MLRNMapView *_Nonnull)view
+        resolve:(RCTPromiseResolveBlock _Nonnull)resolve
+         reject:(RCTPromiseRejectBlock _Nonnull)reject;
+
++ (void)getBearing:(MLRNMapView *_Nonnull)view
+           resolve:(RCTPromiseResolveBlock _Nonnull)resolve
+            reject:(RCTPromiseRejectBlock _Nonnull)reject;
+
++ (void)getPitch:(MLRNMapView *_Nonnull)view
+         resolve:(RCTPromiseResolveBlock _Nonnull)resolve
+          reject:(RCTPromiseRejectBlock _Nonnull)reject;
+
++ (void)getBounds:(MLRNMapView *_Nonnull)view
+          resolve:(RCTPromiseResolveBlock _Nonnull)resolve
+           reject:(RCTPromiseRejectBlock _Nonnull)reject;
+
++ (void)getViewState:(MLRNMapView *_Nonnull)view
+             resolve:(RCTPromiseResolveBlock _Nonnull)resolve
+              reject:(RCTPromiseRejectBlock _Nonnull)reject;
+
++ (void)project:(MLRNMapView *_Nonnull)view
+     coordinate:(CLLocationCoordinate2D)coordinate
+        resolve:(RCTPromiseResolveBlock _Nonnull)resolve
+         reject:(RCTPromiseRejectBlock _Nonnull)reject;
+
++ (void)unproject:(MLRNMapView *_Nonnull)view
+            point:(CGPoint)point
+          resolve:(RCTPromiseResolveBlock _Nonnull)resolve
+           reject:(RCTPromiseRejectBlock _Nonnull)reject;
+
++ (void)createStaticMapImage:(MLRNMapView *_Nonnull)view
+                 writeToDisk:(BOOL)writeToDisk
+                     resolve:(RCTPromiseResolveBlock _Nonnull)resolve
+                      reject:(RCTPromiseRejectBlock _Nonnull)reject;
+
++ (void)queryRenderedFeaturesWithPoint:(MLRNMapView *_Nonnull)view
+                                 point:(CGPoint)point
+                              layerIds:(NSSet *_Nonnull)layerIds
+                             predicate:(NSPredicate *_Nonnull)predicate
+                               resolve:(RCTPromiseResolveBlock _Nonnull)resolve
+                                reject:(RCTPromiseRejectBlock _Nonnull)reject;
+
++ (void)queryRenderedFeaturesWithRect:(MLRNMapView *_Nonnull)view
+                                 rect:(CGRect)rect
+                             layerIds:(NSSet *_Nonnull)layerIds
+                            predicate:(NSPredicate *_Nonnull)predicate
+                              resolve:(RCTPromiseResolveBlock _Nonnull)resolve
+                               reject:(RCTPromiseRejectBlock _Nonnull)reject;
+
++ (void)showAttribution:(MLRNMapView *_Nonnull)view
+                resolve:(RCTPromiseResolveBlock _Nonnull)resolve
+                 reject:(RCTPromiseRejectBlock _Nonnull)reject;
+
++ (void)setSourceVisibility:(MLRNMapView *_Nonnull)view
+                    visible:(BOOL)visible
+                   sourceId:(nonnull NSString *)sourceId
+              sourceLayerId:(nullable NSString *)sourceLayerId
+                    resolve:(RCTPromiseResolveBlock _Nonnull)resolve
+                     reject:(RCTPromiseRejectBlock _Nonnull)reject;
+
+@end

package/ios/components/map-view/MLRNMapViewManager.m

@@ -0,0 +1,152 @@
+#import <React/RCTUIManager.h>
+
+#import "CameraStop.h"
+#import "CameraUpdateQueue.h"
+#import "FilterParser.h"
+#import "MLRNEvent.h"
+#import "MLRNEventTypes.h"
+#import "MLRNGeoJSONSource.h"
+#import "MLRNImages.h"
+#import "MLRNMapTouchEvent.h"
+#import "MLRNMapView.h"
+#import "MLRNMapViewManager.h"
+#import "MLRNUserLocation.h"
+#import "MLRNUtils.h"
+
+@implementation MLRNMapViewManager
+
+// MARK: - React View Methods
+
++ (void)getCenter:(MLRNMapView *)view
+          resolve:(RCTPromiseResolveBlock)resolve
+           reject:(RCTPromiseRejectBlock)reject {
+  resolve(@[ @(view.centerCoordinate.longitude), @(view.centerCoordinate.latitude) ]);
+}
+
++ (void)getZoom:(MLRNMapView *)view
+        resolve:(RCTPromiseResolveBlock)resolve
+         reject:(RCTPromiseRejectBlock)reject {
+  resolve(@(view.zoomLevel));
+}
+
++ (void)getBearing:(MLRNMapView *)view
+           resolve:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject {
+  // Convert -0.0 to 0.0
+  resolve(@(view.camera.heading + 0.0));
+}
+
++ (void)getPitch:(MLRNMapView *)view
+         resolve:(RCTPromiseResolveBlock)resolve
+          reject:(RCTPromiseRejectBlock)reject {
+  resolve(@(view.camera.pitch));
+}
+
++ (void)getBounds:(MLRNMapView *)view
+          resolve:(RCTPromiseResolveBlock)resolve
+           reject:(RCTPromiseRejectBlock)reject {
+  resolve([MLRNUtils fromCoordinateBounds:view.visibleCoordinateBounds]);
+}
+
++ (void)getViewState:(MLRNMapView *)view
+             resolve:(RCTPromiseResolveBlock)resolve
+              reject:(RCTPromiseRejectBlock)reject {
+  NSArray *center = @[ @(view.centerCoordinate.longitude), @(view.centerCoordinate.latitude) ];
+  NSNumber *zoom = @(view.zoomLevel);
+  NSNumber *bearing = @(view.camera.heading);
+  NSNumber *pitch = @(view.camera.pitch);
+  NSArray *bounds = [MLRNUtils fromCoordinateBounds:view.visibleCoordinateBounds];
+
+  NSMutableDictionary *payload = [NSMutableDictionary dictionary];
+  payload[@"center"] = center;
+  payload[@"zoom"] = zoom;
+  payload[@"bearing"] = bearing;
+  payload[@"pitch"] = pitch;
+  payload[@"bounds"] = bounds;
+
+  resolve(payload);
+}
+
++ (CGPoint)project:(MLRNMapView *)view coordinate:(CLLocationCoordinate2D)coordinate {
+  CGPoint pointInView = [view convertCoordinate:coordinate toPointToView:view];
+
+  return pointInView;
+}
+
++ (void)project:(MLRNMapView *)view
+     coordinate:(CLLocationCoordinate2D)coordinate
+        resolve:(RCTPromiseResolveBlock)resolve
+         reject:(RCTPromiseRejectBlock)reject {
+  CGPoint point = [self project:view coordinate:coordinate];
+
+  resolve(@[ @(point.x), @(point.y) ]);
+}
+
++ (void)unproject:(MLRNMapView *)view
+            point:(CGPoint)point
+          resolve:(RCTPromiseResolveBlock)resolve
+           reject:(RCTPromiseRejectBlock)reject {
+  CLLocationCoordinate2D coordinate = [view convertPoint:point toCoordinateFromView:view];
+
+  resolve(@[ @(coordinate.longitude), @(coordinate.latitude) ]);
+}
+
++ (void)createStaticMapImage:(MLRNMapView *)view
+                 writeToDisk:(BOOL)writeToDisk
+                     resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject {
+  NSString *uri = [view takeSnap:writeToDisk];
+  resolve(uri);
+}
+
++ (void)queryRenderedFeaturesWithPoint:(MLRNMapView *)view
+                                 point:(CGPoint)point
+                              layerIds:(NSSet *)layerIds
+                             predicate:(NSPredicate *)predicate
+                               resolve:(RCTPromiseResolveBlock)resolve
+                                reject:(RCTPromiseRejectBlock)reject {
+  NSArray<id<MLNFeature>> *shapes = [view visibleFeaturesAtPoint:point
+                                    inStyleLayersWithIdentifiers:layerIds
+                                                       predicate:predicate];
+
+  NSMutableArray<NSDictionary *> *features = [[NSMutableArray alloc] init];
+  for (int i = 0; i < shapes.count; i++) {
+    [features addObject:shapes[i].geoJSONDictionary];
+  }
+
+  resolve(features);
+}
+
++ (void)queryRenderedFeaturesWithRect:(MLRNMapView *)view
+                                 rect:(CGRect)rect
+                             layerIds:(NSSet *)layerIds
+                            predicate:(NSPredicate *)predicate
+                              resolve:(RCTPromiseResolveBlock)resolve
+                               reject:(RCTPromiseRejectBlock)reject {
+  NSArray<id<MLNFeature>> *shapes = [view visibleFeaturesInRect:rect
+                                   inStyleLayersWithIdentifiers:layerIds
+                                                      predicate:predicate];
+
+  NSArray<NSDictionary *> *features = [MLRNUtils featuresToJSON:shapes];
+
+  resolve(features);
+}
+
++ (void)showAttribution:(MLRNMapView *)view
+                resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject {
+  [view showAttribution:view];
+  resolve(nil);
+}
+
++ (void)setSourceVisibility:(MLRNMapView *)view
+                    visible:(BOOL)visible
+                   sourceId:(nonnull NSString *)sourceId
+              sourceLayerId:(nullable NSString *)sourceLayerId
+                    resolve:(RCTPromiseResolveBlock)resolve
+                     reject:(RCTPromiseRejectBlock)reject {
+  [view setSourceVisibility:visible sourceId:sourceId sourceLayerId:sourceLayerId];
+  resolve(nil);
+}
+
+@end

package/ios/components/map-view/MLRNMapViewModule.h

@@ -0,0 +1,4 @@
+#import <MapVinaReactNativeSpec/MapVinaReactNativeSpec.h>
+
+@interface MLRNMapViewModule : NSObject <NativeMapViewModuleSpec>
+@end