@rnmapbox/maps 10.0.0-beta.28

package/ios/RCTMGL-v10/RCTMGLMapViewManager.m

@@ -0,0 +1,88 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_REMAP_MODULE(RCTMGLMapView, RCTMGLMapViewManager, RCTViewManager)
+
+RCT_REMAP_VIEW_PROPERTY(attributionEnabled, reactAttributionEnabled, BOOL)
+RCT_REMAP_VIEW_PROPERTY(attributionPosition, reactAttributionPosition, NSDictionary)
+RCT_REMAP_VIEW_PROPERTY(logoEnabled, reactLogoEnabled, BOOL)
+RCT_REMAP_VIEW_PROPERTY(logoPosition, reactLogoPosition, NSDictionary)
+RCT_REMAP_VIEW_PROPERTY(compassEnabled, reactCompassEnabled, BOOL)
+RCT_REMAP_VIEW_PROPERTY(compassFadeWhenNorth, reactCompassFadeWhenNorth, BOOL)
+RCT_REMAP_VIEW_PROPERTY(compassPosition, reactCompassPosition, NSDictionary)
+RCT_REMAP_VIEW_PROPERTY(compassViewPosition, reactCompassViewPosition, NSInteger)
+RCT_REMAP_VIEW_PROPERTY(compassViewMargins, reactCompassViewMargins, CGPoint)
+
+RCT_REMAP_VIEW_PROPERTY(scaleBarEnabled, reactScaleBarEnabled, BOOL)
+RCT_REMAP_VIEW_PROPERTY(scaleBarPosition, reactScaleBarPosition, NSDictionary)
+
+RCT_REMAP_VIEW_PROPERTY(zoomEnabled, reactZoomEnabled, BOOL)
+RCT_REMAP_VIEW_PROPERTY(scrollEnabled, reactScrollEnabled, BOOL)
+RCT_REMAP_VIEW_PROPERTY(rotateEnabled, reactRotateEnabled, BOOL)
+RCT_REMAP_VIEW_PROPERTY(pitchEnabled, reactPitchEnabled, BOOL)
+
+
+RCT_REMAP_VIEW_PROPERTY(styleURL, reactStyleURL, NSString)
+RCT_REMAP_VIEW_PROPERTY(onPress, reactOnPress, RCTBubblingEventBlock)
+RCT_REMAP_VIEW_PROPERTY(onLongPress, reactOnLongPress, RCTBubblingEventBlock)
+RCT_REMAP_VIEW_PROPERTY(onMapChange, reactOnMapChange, RCTBubblingEventBlock)
+
+RCT_EXTERN_METHOD(takeSnap:(nonnull NSNumber*)reactTag
+                  writeToDisk:(BOOL)writeToDisk
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(queryTerrainElevation:(nonnull NSNumber*)reactTag
+                  coordinates: (nonnull NSArray<NSNumber>*)coordinates
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(setSourceVisibility:(nonnull NSNumber *)reactTag
+                  visible:(BOOL)visible
+                  sourceId:(nonnull NSString*)sourceId
+                  sourceLayerId:(nullable NSString*)sourceLayerId
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getCenter:(nonnull NSNumber*)reactTag
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getCoordinateFromView:(nonnull NSNumber*)reactTag
+                  atPoint:(CGPoint)point
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getPointInView:(nonnull NSNumber*)reactTag
+                  atCoordinate:(NSArray<NSNumber*>*)coordinate
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getZoom:(nonnull NSNumber*)reactTag
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getVisibleBounds:(nonnull NSNumber*)reactTag
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(queryRenderedFeaturesAtPoint:(nonnull NSNumber*)reactTag
+                  atPoint:(NSArray<NSNumber*>*)point
+                  withFilter:(NSArray*)filter
+                  withLayerIDs:(NSArray<NSString*>*)layerIDs
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(queryRenderedFeaturesInRect:(nonnull NSNumber*)reactTag
+                  withBBox:(NSArray<NSNumber*>*)bbox
+                  withFilter:(NSArray*)filter
+                  withLayerIDs:(NSArray<NSString*>*)layerIDs
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(setHandledMapChangedEvents:(nonnull NSNumber*)reactTag
+                  events:(NSArray<NSString*>*)events
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end

package/ios/RCTMGL-v10/RCTMGLMapViewManager.swift

@@ -0,0 +1,242 @@
+import MapboxMaps
+
+@objc(RCTMGLMapViewManager)
+class RCTMGLMapViewManager: RCTViewManager {
+    @objc
+    override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+    
+    func defaultFrame() -> CGRect {
+        return UIScreen.main.bounds
+    }
+    
+    override func view() -> UIView! {
+        let result = RCTMGLMapView(frame: self.defaultFrame())
+        return result
+    }
+}
+
+// MARK: helpers
+
+extension RCTMGLMapViewManager {
+    func withMapView(
+        _ reactTag: NSNumber,
+        name: String,
+        rejecter: @escaping RCTPromiseRejectBlock,
+        fn: @escaping (_: RCTMGLMapView) -> Void) -> Void
+    {
+      self.bridge.uiManager.addUIBlock { (manager, viewRegistry) in
+        let view = viewRegistry![reactTag]
+
+        guard let view = view! as? RCTMGLMapView else {
+          RCTLogError("Invalid react tag, could not find RCTMGLMapView");
+          rejecter(name, "Unknown find reactTag: \(reactTag)", nil)
+          return;
+        }
+      
+        fn(view)
+      }
+    }
+
+    func withMapboxMap(
+        _ reactTag: NSNumber,
+        name: String,
+        rejecter: @escaping RCTPromiseRejectBlock,
+        fn: @escaping (_: MapboxMap) -> Void) -> Void
+    {
+      withMapView(reactTag, name: name, rejecter: rejecter) { view in
+        guard let mapboxMap = view.mapboxMap else {
+          RCTLogError("MapboxMap is not yet available");
+          rejecter(name, "Map not loaded yet", nil)
+          return;
+        }
+        
+        fn(mapboxMap)
+      }
+    }
+}
+
+// MARK: - react methods
+
+extension RCTMGLMapViewManager {
+    @objc
+    func takeSnap(_ reactTag: NSNumber,
+                  writeToDisk: Bool,
+                  resolver: @escaping RCTPromiseResolveBlock,
+                  rejecter: @escaping RCTPromiseRejectBlock
+    ) -> Void {
+      withMapView(reactTag, name:"takeSnap", rejecter: rejecter) { view in
+        let uri = view.takeSnap(writeToDisk: writeToDisk)
+        resolver(["uri": uri.absoluteString])
+      }
+    }
+  
+    @objc
+    func queryTerrainElevation(_ reactTag: NSNumber,
+                               coordinates: [NSNumber],
+                               resolver: @escaping RCTPromiseResolveBlock,
+                               rejecter: @escaping RCTPromiseRejectBlock
+    ) -> Void {
+      withMapView(reactTag, name:"queryTerrainElevation", rejecter: rejecter) { view in
+        let result = view.queryTerrainElevation(coordinates: coordinates)
+        if let result = result {
+          resolver(["data": NSNumber(value: result)])
+        } else {
+          resolver(nil)
+        }
+      }
+    }
+  
+  @objc
+  func setSourceVisibility(_ reactTag: NSNumber,
+                      visible: Bool,
+                      sourceId: String,
+                      sourceLayerId: String?,
+                      resolver: @escaping RCTPromiseResolveBlock,
+                      rejecter: @escaping RCTPromiseRejectBlock) -> Void {
+    withMapView(reactTag, name:"setSourceVisibility", rejecter: rejecter) { view in
+      view.setSourceVisibility(visible, sourceId: sourceId, sourceLayerId:sourceLayerId)
+      resolver(nil)
+    }
+  }
+
+  @objc
+  func getCenter(_ reactTag: NSNumber,
+                 resolver: @escaping RCTPromiseResolveBlock,
+                 rejecter: @escaping RCTPromiseRejectBlock) -> Void {
+    withMapboxMap(reactTag, name:"getCenter", rejecter: rejecter) { mapboxMap in
+      resolver(["center": [
+        mapboxMap.cameraState.center.longitude,
+        mapboxMap.cameraState.center.latitude
+      ]])
+    }
+  }
+
+  @objc
+  func getCoordinateFromView(
+    _ reactTag: NSNumber,
+    atPoint point: CGPoint,
+    resolver: @escaping RCTPromiseResolveBlock,
+    rejecter: @escaping RCTPromiseRejectBlock) {
+      withMapboxMap(reactTag, name:"getCoordinateFromView", rejecter: rejecter) { mapboxMap in
+        let coordinates = mapboxMap.coordinate(for: point)
+        resolver(["coordinateFromView": [coordinates.longitude, coordinates.latitude]])
+      }
+  }
+
+  @objc
+  func getPointInView(
+    _ reactTag: NSNumber,
+    atCoordinate coordinate: [NSNumber],
+    resolver: @escaping RCTPromiseResolveBlock,
+    rejecter: @escaping RCTPromiseRejectBlock) {
+      withMapboxMap(reactTag, name:"getPointInView", rejecter: rejecter) { mapboxMap in
+        let coordinate = CLLocationCoordinate2DMake(coordinate[1].doubleValue, coordinate[0].doubleValue)
+        let point = mapboxMap.point(for: coordinate)
+        resolver(["pointInView": [(point.x), (point.y)]])
+      }
+  }
+
+  @objc
+  func setHandledMapChangedEvents(
+    _ reactTag: NSNumber,
+    events: [String],
+    resolver: @escaping RCTPromiseResolveBlock,
+    rejecter: @escaping RCTPromiseRejectBlock) {
+    withMapView(reactTag, name:"setHandledMapChangedEvents", rejecter: rejecter) { mapView in
+      mapView.handleMapChangedEvents = Set(events.compactMap {
+        RCTMGLEvent.EventType(rawValue: $0)
+      })
+      resolver(nil);
+    }
+  }
+
+  @objc
+  func getZoom(
+    _ reactTag: NSNumber,
+    resolver: @escaping RCTPromiseResolveBlock,
+    rejecter: @escaping RCTPromiseRejectBlock) {
+      withMapboxMap(reactTag, name:"getZoom", rejecter: rejecter) { mapboxMap in
+        resolver(["zoom": mapboxMap.cameraState.zoom])
+      }
+  }
+
+  @objc
+  func getVisibleBounds(
+    _ reactTag: NSNumber,
+    resolver: @escaping RCTPromiseResolveBlock,
+    rejecter: @escaping RCTPromiseRejectBlock) {
+      withMapView(reactTag, name:"getVisibleBounds", rejecter: rejecter) { mapView in
+        resolver(["visibleBounds":  mapView.mapboxMap.coordinateBounds(for: mapView.bounds).toArray()])
+      }
+  }
+}
+
+// MARK: - queryRenderedFeatures
+
+extension RCTMGLMapViewManager {
+  @objc
+  func queryRenderedFeaturesAtPoint(
+    _ reactTag: NSNumber,
+    atPoint point: [NSNumber],
+    withFilter filter: [Any]?,
+    withLayerIDs layerIDs: [String]?,
+    resolver: @escaping RCTPromiseResolveBlock,
+    rejecter: @escaping RCTPromiseRejectBlock) -> Void {
+      withMapboxMap(reactTag, name:"queryRenderedFeaturesAtPoint", rejecter: rejecter) { mapboxMap in
+        let point = CGPoint(x: CGFloat(point[0].floatValue), y: CGFloat(point[1].floatValue))
+
+        logged("queryRenderedFeaturesAtPoint.option", rejecter: rejecter) {
+          let options = try RenderedQueryOptions(layerIds: layerIDs, filter: filter?.asExpression())
+          
+          mapboxMap.queryRenderedFeatures(at: point, options: options) { result in
+            switch result {
+            case .success(let features):
+              resolver([
+                "data": ["type": "FeatureCollection", "features": features.compactMap { queriedFeature in
+                  logged("queryRenderedFeaturesAtPoint.feature.toJSON") { try queriedFeature.feature.toJSON() }
+                }]
+              ])
+            case .failure(let error):
+              rejecter("queryRenderedFeaturesAtPoint","failed to query features", error)
+            }
+          }
+        }
+      }
+  }
+
+  @objc
+  func queryRenderedFeaturesInRect(
+    _ reactTag: NSNumber,
+    withBBox bbox: [NSNumber],
+    withFilter filter: [Any]?,
+    withLayerIDs layerIDs: [String]?,
+    resolver: @escaping RCTPromiseResolveBlock,
+    rejecter: @escaping RCTPromiseRejectBlock) -> Void {
+      withMapboxMap(reactTag, name:"queryRenderedFeaturesInRect", rejecter: rejecter) { mapboxMap in
+        let left = CGFloat(bbox[0].floatValue)
+        let bottom = CGFloat(bbox[1].floatValue)
+        let right = CGFloat(bbox[2].floatValue)
+        let top = CGFloat(bbox[3].floatValue)
+        let rect = CGRect(x: [left,right].min()!, y: [bottom,top].min()!, width: fabs(right-left), height: fabs(top-bottom))
+        
+        logged("queryRenderedFeaturesInRect.option", rejecter: rejecter) {
+          let options = try RenderedQueryOptions(layerIds: layerIDs, filter: filter?.asExpression())
+          
+          mapboxMap.queryRenderedFeatures(in: rect, options: options) { result in
+            switch result {
+            case .success(let features):
+              resolver([
+                "data": ["type": "FeatureCollection", "features": features.compactMap { queriedFeature in
+                  logged("queryRenderedFeaturesInRect.queriedfeature.map") { try queriedFeature.feature.toJSON() }
+                }]
+              ])
+            case .failure(let error):
+              rejecter("queryRenderedFeaturesAtPoint","failed to query features", error)
+            }
+          }
+        }
+      }
+   }
+}

package/ios/RCTMGL-v10/RCTMGLMarkerView.swift

@@ -0,0 +1,138 @@
+import MapboxMaps
+
+class RCTMGLMarkerView : UIView, RCTMGLMapComponent {
+  static let key = "RCTMGLMarkerView"
+  
+  var map: RCTMGLMapView? = nil
+  
+  
+  // MARK: - react view
+  var reactSubviews : [UIView] = []
+
+  @objc
+  override func insertReactSubview(_ subview: UIView!, at atIndex: Int) {
+    if subview is RCTMGLCallout {
+      Logger.log(level: .warn, message: "MarkerView doesn't supports callouts")
+    }
+    reactSubviews.insert(subview, at: atIndex)
+    if reactSubviews.count > 1 {
+      Logger.log(level: .error, message: "MarkerView supports max 1 subview")
+    }
+  }
+
+  @objc
+  override func removeReactSubview(_ subview: UIView!) {
+    reactSubviews.removeAll(where: { $0 == subview })
+  }
+  
+  func view() -> UIView? {
+    return reactSubviews.first
+  }
+  
+  // MARK: - RCTMGLMapComponent
+
+  func waitForStyleLoad() -> Bool {
+    return true
+  }
+  
+  func addToMap(_ map: RCTMGLMapView, style: Style) {
+    logged("RCTMGLMarkerView.addToMap") {
+      self.map = map
+      let point = point()!
+
+      try point.coordinates.validate()
+
+      guard let view = view() else {
+        Logger.log(level: .error, message: "MarkerView: No subview to render")
+        return
+      }
+      let bounds = view.bounds
+      try viewAnnotations()?.add(view, options: ViewAnnotationOptions.init(geometry: Geometry.point(point), width: bounds.width, height: bounds.height, associatedFeatureId: nil, allowOverlap: true, visible: true, anchor: .center, offsetX: 0, offsetY: 0, selected: false))
+    }
+  }
+  
+  func viewAnnotations() -> ViewAnnotationManager? {
+    self.map?.viewAnnotations
+  }
+
+  func removeFromMap(_ map: RCTMGLMapView) {
+    guard let view = view() else {
+      Logger.log(level: .error, message: "MarkerView: No subview to render")
+      return
+    }
+    viewAnnotations()?.remove(view)
+    self.map = map
+  }
+  
+  override func reactSetFrame(_ frame: CGRect) {
+    super.reactSetFrame(frame)
+
+    _updateFrameOrAnchor()
+  }
+  
+  @objc var coordinate : String? {
+    didSet {
+      _updateCoordinate()
+    }
+  }
+  
+  @objc var anchor : [String:NSNumber]? {
+    didSet {
+      _updateFrameOrAnchor()
+    }
+  }
+  
+  func point() -> Point? {
+    guard let coordinate = coordinate else {
+      return nil
+    }
+     
+    guard let data = coordinate.data(using: .utf8) else {
+      return nil
+    }
+     
+    guard let feature = try? JSONDecoder().decode(Feature.self, from: data) else {
+      return nil
+    }
+     
+    guard let geometry : Geometry = feature.geometry else {
+      return nil
+    }
+
+    guard case .point(let point) = geometry else {
+      return nil
+    }
+
+    return point
+  }
+  
+  func _updateCoordinate() {
+    var options = ViewAnnotationOptions()
+    
+    options.geometry = Geometry.point(point()!)
+    try? viewAnnotations()?.update(self, options: options)
+  }
+  
+  func _updateFrameOrAnchor() {
+    guard let view = view() else {
+      Logger.log(level:.warn, message: "MarkerView: No subview to render")
+      return
+    }
+    var options = ViewAnnotationOptions()
+    let defaultX : CGFloat = 0.5
+    let defaultY : CGFloat = 0.5
+    let bounds = view.bounds
+    options.width = bounds.width
+    options.height = bounds.height
+    
+    if let anchor = anchor {
+      if let anchorX = anchor["x"] {
+        options.offsetX = bounds.width * (CGFloat(anchorX.floatValue) - defaultX)
+      }
+      if let anchorY = anchor["y"] {
+        options.offsetY = bounds.height * (CGFloat(anchorY.floatValue) - defaultY)
+      }
+    }
+    try? viewAnnotations()?.update(self, options: options)
+  }
+}

package/ios/RCTMGL-v10/RCTMGLMarkerViewManager.m

@@ -0,0 +1,11 @@
+#import "React/RCTBridgeModule.h"
+#import <React/RCTViewManager.h>
+#import <Foundation/Foundation.h>
+
+@interface RCT_EXTERN_REMAP_MODULE(RCTMGLMarkerView, RCTMGLMarkerViewManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(coordinate, NSString)
+RCT_EXPORT_VIEW_PROPERTY(anchor, NSDictionary)
+
+@end
+

package/ios/RCTMGL-v10/RCTMGLMarkerViewManager.swift

@@ -0,0 +1,14 @@
+import Foundation
+import MapboxMaps
+
+@objc(RCTMGLMarkerViewManager)
+class RCTMGLMarkerViewManager : RCTViewManager {
+  @objc
+  override static func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+  
+  override func view() -> UIView! {
+    return RCTMGLMarkerView()
+  }
+}

package/ios/RCTMGL-v10/RCTMGLNativeUserLocation.swift

@@ -0,0 +1,44 @@
+import MapboxMaps
+
+@objc
+class RCTMGLNativeUserLocation : UIView, RCTMGLMapComponent {
+  weak var map : RCTMGLMapView! = nil
+  
+  let locationLayerId = "location-layer"
+
+  var locationLayer : LocationIndicatorLayer? = nil
+
+  var visible : Bool = false
+
+  @objc
+  var iosShowsUserHeadingIndicator : Bool = false {
+    didSet {
+      if visible {
+        if let map = self.map {
+          map.location.options.puckType = .puck2D(.makeDefault(showBearing: iosShowsUserHeadingIndicator))
+        }
+      }
+    }
+  }
+
+  func addToMap(_ map: RCTMGLMapView, style: Style) {
+    self.map = map
+    
+    visible = true
+    
+    map.location.options.puckType = .puck2D(.makeDefault(showBearing: iosShowsUserHeadingIndicator))
+  }
+
+  func removeFromMap(_ map: RCTMGLMapView) {
+    guard let mapboxMap = map.mapboxMap else {
+      return
+    }
+    visible = false
+    let style = mapboxMap.style
+    map.location.options.puckType = .none
+  }
+  
+  func waitForStyleLoad() -> Bool {
+    return true
+  }
+}

package/ios/RCTMGL-v10/RCTMGLNativeUserLocationManager.m

@@ -0,0 +1,9 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_MODULE(RCTMGLNativeUserLocationManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(iosShowsUserHeadingIndicator, BOOL);
+
+@end
+

package/ios/RCTMGL-v10/RCTMGLNativeUserLocationManager.swift

@@ -0,0 +1,11 @@
+@objc(RCTMGLNativeUserLocationManager)
+class RCTMGLNativeUserLocationManager : RCTViewManager {
+  @objc
+  override static func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+
+  @objc override func view() -> UIView {
+    return RCTMGLNativeUserLocation()
+  }
+}

package/ios/RCTMGL-v10/RCTMGLOfflineModule.m

@@ -0,0 +1,32 @@
+#import "React/RCTBridgeModule.h"
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(RCTMGLOfflineModule, RCTEventEmitter<RCTBridgeModule>)
+
+RCT_EXTERN_METHOD(getPacks:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(createPack:(NSDictionary *) options resolver: (RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(resumePackDownload:(NSString *)name
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(pausePackDownload:(NSString *)name
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(setTileCountLimit:(nonnull NSNumber *)limit)
+
+RCT_EXTERN_METHOD(setProgressEventThrottle:(nonnull NSNumber *)throttleValue)
+
+RCT_EXTERN_METHOD(getPackStatus:(NSString *)name
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+
+RCT_EXTERN_METHOD(deletePack:(NSString *)name
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(migrateOfflineCache:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+
+@end