@rnmapbox/maps 10.0.0-beta.28

package/ios/RCTMGL-v10/RCTMGLInteractiveElement.swift

@@ -0,0 +1,57 @@
+@_spi(Experimental) import MapboxMaps
+
+@objc
+class RCTMGLInteractiveElement : UIView, RCTMGLMapComponent {
+
+  var map : RCTMGLMapView? = nil
+  
+  var layers: [RCTMGLSourceConsumer] = []
+  
+  static let hitboxDefault = 44.0
+
+  @objc var draggable: Bool = false
+  
+  @objc var hasPressListener: Bool = false
+  
+  @objc var hitbox : [String:NSNumber] = [
+    "width": NSNumber(value: hitboxDefault),
+    "height": NSNumber(value: hitboxDefault)
+  ]
+  
+  @objc var id: String! = nil
+  
+  @objc var onDragStart: RCTBubblingEventBlock? = nil
+  
+  @objc var onPress: RCTBubblingEventBlock? = nil
+  
+  func getLayerIDs() -> [String] {
+    layers.compactMap {
+      if let layer = $0 as? RCTMGLLayer {
+        return layer.id
+      } else {
+        return nil
+      }
+    }
+  }
+
+  func isDraggable() -> Bool {
+    return draggable
+  }
+  
+  func isTouchable() -> Bool {
+    return hasPressListener
+  }
+  
+  // MARK: - RCTMGLMapComponent
+  func addToMap(_ map: RCTMGLMapView, style: Style) {
+    self.map = map
+  }
+
+  func removeFromMap(_ map: RCTMGLMapView) {
+    self.map = nil
+  }
+  
+  func waitForStyleLoad() -> Bool {
+    return true
+  }
+}

package/ios/RCTMGL-v10/RCTMGLLayer.swift

@@ -0,0 +1,304 @@
+@_spi(Experimental) import MapboxMaps
+
+protocol RCTMGLSourceConsumer {
+  func addToMap(_ map: RCTMGLMapView, style: Style)
+  func removeFromMap(_ map: RCTMGLMapView, style: Style)
+}
+
+@objc(RCTMGLLayer)
+class RCTMGLLayer : UIView, RCTMGLMapComponent, RCTMGLSourceConsumer {
+  var bridge : RCTBridge? = nil
+
+  @objc var sourceLayerID : String? = nil {
+    didSet { self.optionsChanged() }
+  }
+  @objc var reactStyle : Dictionary<String, Any>? = nil {
+    didSet {
+      DispatchQueue.main.async {
+        self.addStylesAndUpdate()
+      }
+    }
+  }
+  
+  var style: Style? = nil
+
+  @objc var filter : Array<Any>? = nil {
+    didSet { optionsChanged() }
+  }
+  
+  @objc var id: String! = nil
+  @objc var sourceID: String? = nil {
+    didSet { optionsChanged() }
+  }
+  
+  @objc var minZoomLevel : NSNumber? = nil {
+    didSet { optionsChanged() }
+  }
+  @objc var maxZoomLevel : NSNumber? = nil {
+    didSet { optionsChanged() }
+  }
+
+  @objc var aboveLayerID : String? = nil {
+    didSet {
+      if let aboveLayerID = aboveLayerID {
+        if aboveLayerID != oldValue {
+          self.removeAndReaddLayer()
+        }
+      }
+    }
+  }
+
+  @objc var belowLayerID : String? = nil {
+    didSet {
+      if let belowLayerID = belowLayerID {
+        if belowLayerID != oldValue {
+          self.removeAndReaddLayer()
+        }
+      }
+    }
+  }
+  
+  @objc var layerIndex : NSNumber? = nil {
+    didSet {
+      if let layerIndex = layerIndex {
+        if layerIndex != oldValue {
+          self.removeAndReaddLayer()
+        }
+      }
+    }
+  }
+  
+  @objc weak var map: RCTMGLMapView? = nil
+  
+  var styleLayer: Layer? = nil
+  
+  /// wearther we inserted the layer or we're referring to an existing layer
+  var existingLayer = false
+
+  // MARK: - RCTMGLMapComponent
+  func waitForStyleLoad() -> Bool {
+    return true
+  }
+  
+  func removeAndReaddLayer() {
+    if let style = style {
+      self.removeFromMap(style)
+      self.insert(style, layerPosition: position())
+    }
+  }
+   
+  /**
+    addStyles - adds the styles defined by reactStyle to the current layer, but does not apply to the style to the map style
+   */
+  func addStyles() {
+    fatalError("Subclasses need to implement the `addStyles()` method.")
+  }
+  
+  func addStylesAndUpdate() {
+    guard styleLayer != nil else {
+      return
+    }
+
+    addStyles()
+    if let style = style,
+      let map = map {
+      if style.styleManager.styleLayerExists(forLayerId: id) {
+        self.updateLayer(map)
+      }
+    }
+  }
+  
+  func makeLayer(style: Style) throws -> Layer {
+    fatalError("Subclasses need to implement the `makeLayer(style:)` method.")
+  }
+  
+  func findLayer(style: Style, id: String) throws -> Layer {
+    return try style.layer(withId: id)
+  }
+  
+  func layerType() -> Layer.Type {
+    fatalError("Subclasses need to implement the `layerType` method. \(self)")
+  }
+
+  func apply(style : Style) throws {
+    fatalError("Subclasses need to implement the `apply` method.")
+  }
+
+  final func loggedApply(style: Style) {
+    logged("updateLayer", info: { "\(self.layerType()).\(optional: self.id)" }) {
+      try apply(style: style)
+    }
+  }
+
+  func position() -> LayerPosition {
+    if let belowLayerID = belowLayerID {
+      return .below(belowLayerID)
+    } else if let aboveLayerID = aboveLayerID {
+      return .above(aboveLayerID)
+    } else if let layerIndex = layerIndex {
+      return .at(layerIndex.intValue)
+    } else {
+      return .default
+    }
+  }
+  
+  func inserLayer(_ map: RCTMGLMapView) {
+    if self.style == nil {
+      print("inserLayer but style is nil")
+    }
+    if let style = style, let styleLayer = styleLayer {
+      insert(style, layerPosition: position()) {
+        map.layerAdded(styleLayer)
+      }
+    }
+  }
+
+  func updateLayer(_ map: RCTMGLMapView) {
+    if let style = style, let _ = styleLayer {
+      loggedApply(style: style)
+    }
+  }
+  
+  func layerWithSourceID<T : Source>(in style: Style) throws -> T  {
+    let result = try style.source(withId: self.sourceID!, type: T.self)
+    return result
+  }
+
+  func sourceWithSourceID<T : Source>(in style: Style) throws -> T  {
+    let result = try style.source(withId: self.sourceID!, type: T.self)
+    return result
+  }
+
+  func addedToMap() {
+    
+  }
+  
+  func addToMap(_ map: RCTMGLMapView, style: Style) {
+    self.map = map
+    self.style = style
+    guard let id = id else {
+      Logger.log(level: .error, message: "Cannot add layer without id to the map: \(map)")
+      return
+    }
+
+    do {
+      if (style.styleManager.styleLayerExists(forLayerId: id)) {
+        styleLayer = try findLayer(style: style, id: id)
+        existingLayer = true
+      } else {
+        styleLayer = try makeLayer(style: style)
+        existingLayer = false
+      }
+    } catch {
+      Logger.log(level: .error, message: "find/makeLayer failed for layer id=\(id)", error: error)
+    }
+    
+    guard self.styleLayer != nil else {
+      Logger.log(level: .error, message: "find/makeLayer retuned nil for layer id=\(id)")
+      return
+    }
+    setOptions(&self.styleLayer!)
+    addStyles()
+    if !existingLayer {
+      inserLayer(map)
+    } else {
+      updateLayer(map)
+    }
+    addedToMap()
+  }
+  
+  func removeFromMap(_ map: RCTMGLMapView, style: Style) {
+    removeFromMap(style)
+  }
+  
+  func setOptions(_ layer: inout Layer) {
+    if let sourceLayerID = sourceLayerID {
+      layer.sourceLayer = sourceLayerID
+    }
+    
+    if let sourceID = sourceID {
+      if !(existingLayer && sourceID == DEFAULT_SOURCE_ID) && hasSource() {
+        
+        layer.source = sourceID
+      }
+    }
+    
+    if let filter = filter, filter.count > 0 {
+      do {
+        let data = try JSONSerialization.data(withJSONObject: filter, options: .prettyPrinted)
+        let decodedExpression = try JSONDecoder().decode(Expression.self, from: data)
+        layer.filter = decodedExpression
+      } catch {
+        Logger.log(level: .error, message: "parsing filters failed for layer \(optional: id): \(error.localizedDescription)")
+      }
+    } else {
+      layer.filter = nil
+    }
+    
+    if let minZoom = minZoomLevel {
+      layer.minZoom = minZoom.doubleValue
+    }
+    
+    if let maxZoom = maxZoomLevel {
+      layer.maxZoom = maxZoom.doubleValue
+    }
+  }
+  
+  private func optionsChanged() {
+    if let style = self.style {
+      self.setOptions(&self.styleLayer!)
+      self.loggedApply(style: style)
+    }
+  }
+
+  func removeFromMap(_ map: RCTMGLMapView) {
+    removeFromMap(map.mapboxMap.style)
+  }
+  
+  private func removeFromMap(_ style: Style) {
+    do {
+      try style.removeLayer(withId: self.id)
+    } catch {
+      Logger.log(level: .error, message: "removing layer failed for layer \(optional: id): \(error.localizedDescription)")
+    }
+  }
+  
+  func insert(_ style: Style, layerPosition: LayerPosition, onInsert: (() -> Void)? = nil) {
+    var idToWaitFor: String?
+    switch layerPosition {
+    case .above(let aboveId):
+      idToWaitFor = aboveId
+    case .below(let belowId):
+      idToWaitFor = belowId
+    case .at(_):
+      idToWaitFor = nil
+    default:
+      idToWaitFor = nil
+    }
+    
+    if let idToWaitFor = idToWaitFor {
+      map!.waitForLayerWithID(idToWaitFor) { _ in
+        self.attemptInsert(style, layerPosition: layerPosition, onInsert: onInsert)
+      }
+    } else {
+      self.attemptInsert(style, layerPosition: layerPosition, onInsert: onInsert)
+    }
+  }
+  
+  private func attemptInsert(_ style: Style, layerPosition: LayerPosition, onInsert: (() -> Void)? = nil) {
+    guard let styleLayer = self.styleLayer else {
+      return
+    }
+    
+    do {
+      try style.addLayer(styleLayer, layerPosition: layerPosition)
+      onInsert?()
+    } catch {
+      Logger.log(level: .error, message: "inserting layer failed at position \(layerPosition): \(error.localizedDescription)")
+    }
+  }
+  
+  internal func hasSource() -> Bool {
+    return true
+  }
+}

package/ios/RCTMGL-v10/RCTMGLLight.swift

@@ -0,0 +1,56 @@
+import MapboxMaps
+
+@objc(RCTMGLLight)
+class RCTMGLLight: UIView, RCTMGLMapComponent {
+  weak var bridge : RCTBridge! = nil
+  weak var map: MapboxMap! = nil
+  @objc var reactStyle : [String:Any]! = nil {
+    didSet {
+      if map != nil {
+        addStyles()
+      }
+    }
+  }
+  
+  func apply(light: Light) {
+    self.map.style
+    let lightData = try! JSONEncoder().encode(light)
+    let lightDictionary = try! JSONSerialization.jsonObject(with: lightData)
+    print("=> lightDictionary \(lightDictionary)")
+    try! self.map.style.setLight(properties: lightDictionary as! [String:Any])
+  }
+
+  func addStyles() {
+    var light = Light()
+    let style = RCTMGLStyle(style: map.style)
+    style.lightLayer(layer: &light, reactStyle: reactStyle, applyUpdater: { (updater) in
+      updater(&light)
+      self.apply(light: light)
+    }, isValid: {
+      return self.isAddedToMap()
+    })
+    
+    apply(light: light)
+  }
+  
+  func isAddedToMap() -> Bool {
+    return map != nil
+  }
+  
+  // MARK: - RCTMGLMapComponent
+
+  func waitForStyleLoad() -> Bool {
+    return true
+  }
+
+  func addToMap(_ map: RCTMGLMapView, style: Style) {
+    self.map = map.mapboxMap
+    if (reactStyle != nil) {
+      addStyles()
+    }
+  }
+  
+  func removeFromMap(_ map: RCTMGLMapView) {
+    self.map = nil
+  }
+}

package/ios/RCTMGL-v10/RCTMGLLightManager.m

@@ -0,0 +1,9 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_MODULE(RCTMGLLightManager, RCTViewManager)
+
+// light props
+RCT_EXPORT_VIEW_PROPERTY(reactStyle, NSDictionary);
+
+@end

package/ios/RCTMGL-v10/RCTMGLLightManager.swift

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

package/ios/RCTMGL-v10/RCTMGLLineLayer.swift

@@ -0,0 +1,52 @@
+import MapboxMaps
+
+@objc(RCTMGLLineLayer)
+class RCTMGLLineLayer: RCTMGLVectorLayer {
+  typealias LayerType = LineLayer
+
+  override func makeLayer(style: Style) throws -> Layer {
+    let vectorSource : VectorSource = try self.layerWithSourceID(in: style)
+    var layer = LayerType(id: self.id!)
+    layer.sourceLayer = self.sourceLayerID
+    layer.source = sourceID
+    return layer
+  }
+
+  override func layerType() -> Layer.Type {
+    return LayerType.self
+  }
+
+  override func apply(style : Style) throws {
+    try style.updateLayer(withId: id, type: LayerType.self) { (layer : inout LineLayer) in
+      if self.styleLayer != nil {
+        self.setOptions(&self.styleLayer!)
+      }
+      if let styleLayer = self.styleLayer as? LineLayer {
+        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,
+         let reactStyle = reactStyle {
+        styler.lineLayer(
+          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
+      }
+    }
+  }
+  
+  func isAddedToMap() -> Bool {
+    return true
+  }
+}

package/ios/RCTMGL-v10/RCTMGLLineLayerManager.m

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

package/ios/RCTMGL-v10/RCTMGLLineLayerManager.swift

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

package/ios/RCTMGL-v10/RCTMGLLocationModule.m

@@ -0,0 +1,15 @@
+#import "React/RCTBridgeModule.h"
+#import <React/RCTEventEmitter.h>
+
+@class RCTMGLLocation;
+
+@interface RCT_EXTERN_MODULE(RCTMGLLocationModule, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(start:(CLLocationDistance)minDisplacement)
+RCT_EXTERN_METHOD(stop)
+RCT_EXTERN_METHOD(getLastKnownLocation)
+
+RCT_EXTERN_METHOD(setMinDisplacement:(CLLocationDistance)minDisplacement)
+
+
+@end