@rnmapbox/maps 10.0.0-beta.28

package/ios/RCTMGL-v10/RCTMGLPointAnnotationManager.m

@@ -0,0 +1,22 @@
+#import "React/RCTBridgeModule.h"
+#import <React/RCTViewManager.h>
+#import <Foundation/Foundation.h>
+
+@interface RCT_EXTERN_REMAP_MODULE(RCTMGLPointAnnotation, RCTMGLPointAnnotationManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(coordinate, NSString)
+RCT_EXPORT_VIEW_PROPERTY(draggable, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(id, NSString)
+
+RCT_REMAP_VIEW_PROPERTY(onMapboxPointAnnotationDeselected, onDeselected, RCTBubblingEventBlock)
+RCT_REMAP_VIEW_PROPERTY(onMapboxPointAnnotationDrag, onDrag, RCTBubblingEventBlock)
+RCT_REMAP_VIEW_PROPERTY(onMapboxPointAnnotationDragEnd, onDragEnd, RCTBubblingEventBlock)
+RCT_REMAP_VIEW_PROPERTY(onMapboxPointAnnotationDragStart, onDragStart, RCTBubblingEventBlock)
+RCT_REMAP_VIEW_PROPERTY(onMapboxPointAnnotationSelected, onSelected, RCTBubblingEventBlock)
+
+RCT_EXTERN_METHOD(refresh:(nonnull NSNumber*)reactTag
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end
+

package/ios/RCTMGL-v10/RCTMGLPointAnnotationManager.swift

@@ -0,0 +1,34 @@
+import Foundation
+import MapboxMaps
+
+@objc(RCTMGLPointAnnotationManager)
+class RCTMGLPointAnnotationManager  : RCTViewManager {
+  @objc
+  override static func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+  
+  override func view() -> UIView! {
+    return RCTMGLPointAnnotation()
+  }
+
+  @objc
+  func refresh(_ reactTag: NSNumber,
+    resolver: RCTPromiseResolveBlock,
+    rejecter: RCTPromiseRejectBlock
+  )
+  {
+    self.bridge.uiManager.addUIBlock { (manager, viewRegistry) in
+      guard let view = viewRegistry?[reactTag] else {
+        Logger.log(level: .error, message: "View with tag: \(reactTag) not found")
+        return
+      }
+      guard let view = view as? RCTMGLPointAnnotation else {
+        Logger.log(level: .error, message: "View \(view) is not RCTMGLPointAnnotation")
+        return
+      }
+          
+      view.refresh()
+    }
+  }
+}

package/ios/RCTMGL-v10/RCTMGLRasterDemSource.swift

@@ -0,0 +1,57 @@
+import MapboxMaps
+
+@objc
+class RCTMGLRasterDemSource : RCTMGLSource {
+  typealias SourceType = RasterDemSource
+  
+  @objc
+  var url: String? = nil
+  
+  @objc
+  var tileUrlTemplates: [String]? = nil
+  
+  @objc
+  var tileSize : NSNumber? = nil
+  
+  @objc
+  var maxZoomLevel : NSNumber? = nil
+  
+  @objc
+  var minZoomLevel : NSNumber? = nil
+
+  @objc
+  static func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+  
+  override func sourceType() -> Source.Type {
+    return SourceType.self
+  }
+
+  override func makeSource() -> Source
+  {
+    var result = SourceType()
+    if let url = url {
+      result.url = url
+    } else if let tileUrlTemplates = tileUrlTemplates {
+      result.tiles = tileUrlTemplates
+    } else {
+      Logger.log(level: .error, message: "RCTMGLRasterDemSource should have either url or tileUrlTemplates ")
+      return result
+    }
+    
+    if let tileSize = tileSize {
+      result.tileSize = tileSize.doubleValue
+    }
+    
+    if let maxZoomLevel = maxZoomLevel {
+      result.maxzoom = maxZoomLevel.doubleValue
+    }
+
+    if let minZoomLevel = minZoomLevel {
+      result.minzoom = minZoomLevel.doubleValue
+    } 
+    return result
+  }  
+}
+  

package/ios/RCTMGL-v10/RCTMGLRasterDemSourceManager.m

@@ -0,0 +1,20 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_MODULE(RCTMGLRasterDemSourceManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(id, NSString)
+RCT_EXPORT_VIEW_PROPERTY(url, NSString)
+RCT_EXPORT_VIEW_PROPERTY(tileUrlTemplates, NSArray)
+RCT_EXPORT_VIEW_PROPERTY(bounds, NSArray)
+RCT_EXPORT_VIEW_PROPERTY(minZoomLevel, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(maxZoomLevel, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(tileSize, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(attribution, NSString)
+RCT_EXPORT_VIEW_PROPERTY(encoding, NSString)
+RCT_EXPORT_VIEW_PROPERTY(volatile, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(prefetchZoomDelta, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(minimumTileUpdateInterval, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(maxOverscaleFactorForParentTiles, NSNumber)
+
+@end

package/ios/RCTMGL-v10/RCTMGLRasterDemSourceManager.swift

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

package/ios/RCTMGL-v10/RCTMGLRasterLayer.swift

@@ -0,0 +1,48 @@
+import MapboxMaps
+
+@objc(RCTMGLRasterLayer)
+class RCTMGLRasterLayer: RCTMGLLayer {
+  typealias LayerType = RasterLayer
+
+  override func makeLayer(style: Style) throws -> Layer {
+    // let source : ImageSource = try self.sourceWithSourceID(in: style)
+    var layer = LayerType(id: self.id!)
+    layer.source = sourceID
+    return layer
+  }
+
+  override func apply(style : Style) throws {
+    try style.updateLayer(withId: id, type: RasterLayer.self) { (layer : inout RasterLayer) in
+      if let styleLayer = self.styleLayer as? RasterLayer {
+        layer = styleLayer
+      }
+    }
+  }
+ 
+  override func addStyles() {
+    if let style : Style = self.style {
+      let styler =  RCTMGLStyle(style: self.style!)
+      styler.bridge = self.bridge
+      
+      if var styleLayer = self.styleLayer as? LayerType {
+        styler.rasterLayer(
+          layer: &styleLayer,
+          reactStyle: reactStyle!,
+          applyUpdater:{ (updater) in try! style.updateLayer(withId: self.id, type: LayerType.self) { (layer: inout LayerType) in updater(&layer) }},
+          isValid: { return self.isAddedToMap() }
+        )
+        self.styleLayer = styleLayer
+      } else {
+        fatalError("[xxx] layer is not raster layer?!!! \(optional: self.styleLayer)")
+      }
+    }
+  }
+   
+  func isAddedToMap() -> Bool {
+    return true
+  }
+
+  override func layerType() -> Layer.Type {
+    return LayerType.self
+  }
+}

package/ios/RCTMGL-v10/RCTMGLRasterLayerManager.m

@@ -0,0 +1,12 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_MODULE(RCTMGLRasterLayerManager, RCTViewManager)
+
+// symbol layer props
+RCT_EXPORT_VIEW_PROPERTY(sourceLayerID, NSString)
+
+// standard layer props
+#include "CommonLayerProperties.H"
+
+@end

package/ios/RCTMGL-v10/RCTMGLRasterLayerManager.swift

@@ -0,0 +1,13 @@
+@objc(RCTMGLRasterLayerManager)
+class RCTMGLRasterLayerManager: RCTViewManager {
+    @objc
+    override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+  
+    override func view() -> UIView! {
+      let layer = RCTMGLRasterLayer()
+      layer.bridge = self.bridge
+      return layer
+    }
+}

package/ios/RCTMGL-v10/RCTMGLRasterSource.swift

@@ -0,0 +1,51 @@
+import MapboxMaps
+
+@objc
+class RCTMGLRasterSource : RCTMGLSource {
+  typealias SourceType = RasterSource
+
+  @objc var url: String? = nil
+  
+  @objc var tileUrlTemplates: [String]? = nil
+  
+  @objc var minZoomLevel: NSNumber?
+  @objc var maxZoomLevel: NSNumber?
+  @objc var tileSize: NSNumber?
+  
+  @objc var tms: Bool = false
+  
+  @objc var attribution: String?
+
+  override func makeSource() -> Source
+  {
+    var result = RasterSource()
+    if let url = url {
+      result.url = url
+    } else {
+      result.tiles = tileUrlTemplates
+    }
+    
+    if let tileSize = tileSize {
+      result.tileSize = tileSize.doubleValue
+    }
+    
+    if let minZoomLevel = minZoomLevel {
+      result.minzoom = minZoomLevel.doubleValue
+    }
+    
+    if let maxZoomLevel = maxZoomLevel {
+      result.maxzoom = maxZoomLevel.doubleValue
+    }
+    
+    if tms {
+      result.scheme = .tms
+    }
+    
+    if let attribution = attribution {
+      result.attribution = attribution
+    }
+    
+    return result
+  }
+
+}

package/ios/RCTMGL-v10/RCTMGLRasterSourceManager.m

@@ -0,0 +1,18 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_MODULE(RCTMGLRasterSourceManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(id, NSString)
+RCT_EXPORT_VIEW_PROPERTY(url, NSString)
+RCT_EXPORT_VIEW_PROPERTY(tileUrlTemplates, NSArray)
+
+RCT_EXPORT_VIEW_PROPERTY(tileSize, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(minZoomLevel, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(maxZoomLevel, NSNumber)
+
+RCT_EXPORT_VIEW_PROPERTY(tms, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(attribution, NSString)
+
+
+@end

package/ios/RCTMGL-v10/RCTMGLRasterSourceManager.swift

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

package/ios/RCTMGL-v10/RCTMGLShapeSource.swift

@@ -0,0 +1,277 @@
+import MapboxMaps
+import Turf
+
+@objc
+class RCTMGLShapeSource : RCTMGLSource {
+  @objc var url : String?
+
+  @objc var shape : String? {
+    didSet {
+      logged("RCTMGLShapeSource.updateShape") {
+        let obj : GeoJSONObject = try parse(shape)
+
+        doUpdate { (style) in
+          logged("RCTMGLShapeSource.setShape") {
+            try style.updateGeoJSONSource(withId: id, geoJSON: obj)
+          }
+        }
+      }
+    }
+  }
+  
+  @objc var cluster : NSNumber?
+  @objc var clusterRadius : NSNumber?
+  @objc var clusterMaxZoomLevel : NSNumber?
+  @objc var clusterProperties : [String: [Any]]?;
+  
+  @objc var maxZoomLevel : NSNumber?
+  @objc var buffer : NSNumber?
+  @objc var tolerance : NSNumber?
+  @objc var lineMetrics : NSNumber?
+  
+  override func sourceType() -> Source.Type {
+    return GeoJSONSource.self
+  }
+
+  override func makeSource() -> Source
+  {
+    var result =  GeoJSONSource()
+    
+    if let shape = shape {
+      do {
+        result.data = try parse(shape)
+      } catch {
+        Logger.log(level: .error, message: "Unable to read shape: \(shape) \(error) setting it to empty")
+        result.data = emptyShape()
+      }
+    }
+    
+    if let url = url {
+      result.data = .url(URL(string: url)!)
+    }
+    
+    if let cluster = cluster {
+      result.cluster = cluster.boolValue
+    }
+    
+    if let clusterRadius = clusterRadius {
+      result.clusterRadius = clusterRadius.doubleValue
+    }
+    
+    if let clusterMaxZoomLevel = clusterMaxZoomLevel {
+      result.clusterMaxZoom = clusterMaxZoomLevel.doubleValue
+    }
+    
+    do {
+      if let clusterProperties = clusterProperties {
+        result.clusterProperties = try clusterProperties.mapValues { (params : [Any]) in
+          let data = try JSONSerialization.data(withJSONObject: params, options: .prettyPrinted)
+          let decodedExpression = try JSONDecoder().decode(Expression.self, from: data)
+          
+          return decodedExpression
+        }
+      }
+    } catch {
+      Logger.log(level: .error, message: "RCTMGLShapeSource.parsing clusterProperties failed", error: error)
+    }
+    
+    if let maxZoomLevel = maxZoomLevel {
+      result.maxzoom = maxZoomLevel.doubleValue
+    }
+    
+    if let buffer = buffer {
+      result.buffer = buffer.doubleValue
+    }
+    
+    if let tolerance = tolerance {
+      result.tolerance = tolerance.doubleValue
+    }
+    
+    if let lineMetrics = lineMetrics {
+      result.lineMetrics = lineMetrics.boolValue
+    }
+    
+    return result
+  }
+
+  func doUpdate(_ update:(Style) -> Void) {
+    guard let map = self.map,
+          let _ = self.source,
+          map.mapboxMap.style.sourceExists(withId: id) else {
+      return
+    }
+    
+    let style = map.mapboxMap.style
+    update(style)
+  }
+  
+  func updateSource(property: String, value: Any) {
+    doUpdate { style in
+      try! style.setSourceProperty(for: id, property: property, value: value)
+    }
+  }
+}
+
+// MARK: - parse(shape)
+
+extension RCTMGLShapeSource
+{
+  func parse(_ shape: String) throws -> GeoJSONSourceData {
+    guard let data = shape.data(using: .utf8) else {
+      throw RCTMGLError.parseError("shape is not utf8")
+    }
+    do {
+      return try JSONDecoder().decode(GeoJSONSourceData.self, from: data)
+    } catch {
+      let origError = error
+      do {
+        // workaround for mapbox issue, GeoJSONSourceData can't decode a single geometry
+        let geometry = try JSONDecoder().decode(Geometry.self, from: data)
+        return .geometry(geometry)
+      } catch {
+        throw origError
+      }
+    }
+  }
+  
+  func parse(_ shape: String) throws -> Feature {
+    guard let data = shape.data(using: .utf8) else {
+      throw RCTMGLError.parseError("shape is not utf8")
+    }
+    return try JSONDecoder().decode(Feature.self, from: data)
+  }
+
+  func parse(_ shape: String?) throws -> GeoJSONObject {
+    guard let shape = shape else {
+      return emptyGeoJSONObject()
+    }
+    let data : GeoJSONSourceData = try parse(shape)
+    switch data {
+    case .empty:
+      return emptyGeoJSONObject()
+    case .feature(let feature):
+      return .feature(feature)
+    case .featureCollection(let featureColleciton):
+      return .featureCollection(featureColleciton)
+    case .geometry(let geometry):
+      return .geometry(geometry)
+    case .url(_):
+      throw RCTMGLError.parseError("url as shape is not supported when updating a ShapeSource")
+    }
+  }
+
+  func emptyGeoJSONObject() -> GeoJSONObject {
+    return .featureCollection(emptyFeatureCollection())
+  }
+
+  func emptyShape() -> GeoJSONSourceData {
+    return GeoJSONSourceData.featureCollection(FeatureCollection(features:[]))
+  }
+
+  func emptyFeatureCollection() -> FeatureCollection {
+    return FeatureCollection(features:[])
+  }
+
+  func parseAsJSONObject(shape: String?) -> Any? {
+    guard let shape = shape else {
+      return nil
+    }
+    guard let data = shape.data(using: .utf8) else {
+      Logger.log(level: .error, message: "shapeSource.setShape: Shape is not utf8")
+      return nil
+    }
+    let objs = logged("shapeSource.setShape.parseJSON") {
+      try JSONSerialization.jsonObject(with: data)
+    }
+    return objs
+  }
+}
+
+// MARK: - getClusterExpansionZoom/getClusterLeaves
+
+extension RCTMGLShapeSource
+{
+  func getClusterExpansionZoom(
+    _ clusterId: NSNumber,
+    completion: @escaping (Result<Int, Error>) -> Void)
+  {
+    guard let mapView = map?.mapView else {
+      completion(.failure(RCTMGLError.failed("getClusterExpansionZoom: no mapView")))
+      return
+    }
+
+    let options = SourceQueryOptions(sourceLayerIds: nil, filter: Exp(.eq) {
+      Exp(.get) { "cluster_id" }
+      clusterId.uintValue
+    })
+    mapView.mapboxMap.querySourceFeatures(for: id, options: options) { result in
+      switch result {
+      case .success(let features):
+        let cluster = features[0]
+        mapView.mapboxMap.queryFeatureExtension(for: self.id, feature: cluster.feature, extension: "supercluster", extensionField: "expansion-zoom") { result in
+          switch result {
+          case .success(let features):
+            guard let value = features.value as? NSNumber else {
+              completion(.failure(RCTMGLError.failed("getClusterExpansionZoom: not a number")))
+              return
+            }
+                
+            completion(.success(value.intValue))
+          case .failure(let error):
+            completion(.failure(error))
+          }
+        }
+      case .failure(let error):
+        completion(.failure(error))
+      }
+    }
+  }
+  
+  func getClusterLeaves(_ featureJSON: String,
+                              number: uint,
+                              offset: uint,
+                              completion: @escaping (Result<FeatureExtensionValue, Error>) -> Void)
+  {
+    guard let mapView = map?.mapView else {
+      completion(.failure(RCTMGLError.failed("getClusterLeaves: no mapView")))
+      return
+    }
+    
+    logged("RCTMGLShapeSource.getClusterLeaves", rejecter: { (_,_,error) in
+      completion(.failure(error!))
+    }) {
+      let cluster : Feature = try parse(featureJSON);
+      mapView.mapboxMap.queryFeatureExtension(for: self.id, feature: cluster,  extension: "supercluster", extensionField: "leaves", args: ["limit": UInt64(number),"offset": UInt64(offset)]) {
+        result in
+        switch result {
+        case .success(let features):
+          completion(.success(features))
+        case .failure(let error):
+          completion(.failure(error))
+        }
+      }
+    }
+  }
+
+  func getClusterChildren(_ featureJSON: String, completion: @escaping (Result<FeatureExtensionValue, Error>) -> Void) {
+    guard let mapView = map?.mapView else {
+      completion(.failure(RCTMGLError.failed("getClusterChildren: no mapView")))
+      return
+    }
+
+    logged("RCTMGLShapeSource.getClusterChildren", rejecter: { (_,_,error) in
+      completion(.failure(error!))
+    }) {
+      let cluster : Feature = try parse(featureJSON);
+      mapView.mapboxMap.queryFeatureExtension(for: self.id, feature: cluster, extension: "supercluster", extensionField: "children") {
+        result in
+        switch result {
+        case .success(let features):
+          completion(.success(features))
+        case .failure(let error):
+          completion(.failure(error))
+        }
+      }
+    }
+  }
+}

package/ios/RCTMGL-v10/RCTMGLShapeSourceManager.m

@@ -0,0 +1,44 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+
+@interface
+RCT_EXTERN_REMAP_MODULE(RCTMGLShapeSource, RCTMGLShapeSourceManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(id, NSString)
+RCT_EXPORT_VIEW_PROPERTY(url, NSString)
+RCT_EXPORT_VIEW_PROPERTY(shape, NSString)
+
+RCT_EXPORT_VIEW_PROPERTY(cluster, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(clusterRadius, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(clusterMaxZoomLevel, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(clusterProperties, NSDictionary)
+RCT_EXPORT_VIEW_PROPERTY(maxZoomLevel, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(buffer, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(tolerance, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(lineMetrics, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(images, NSDictionary)
+RCT_EXPORT_VIEW_PROPERTY(nativeImages, NSArray)
+RCT_EXPORT_VIEW_PROPERTY(hasPressListener, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(hitbox, NSDictionary)
+RCT_REMAP_VIEW_PROPERTY(onMapboxShapeSourcePress, onPress, RCTBubblingEventBlock)
+
+
+
+RCT_EXTERN_METHOD(getClusterExpansionZoom:(nonnull NSNumber*)reactTag
+                                clusterId:(nonnull NSNumber*)clusterId
+                                 resolver:(RCTPromiseResolveBlock)resolve
+                                 rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getClusterLeaves:(nonnull NSNumber*)reactTag
+                  featureJSON:(nonnull NSString*)featureJSON
+                  number:(NSUInteger) number
+                  offset:(NSUInteger) offset
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getClusterChildren:(nonnull NSNumber*)reactTag
+                  featureJSON:(nonnull NSString*)featureJSON
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end