@rnmapbox/maps 10.0.0-beta.28

package/ios/RCTMGL-v10/RCTMGLCamera.swift

@@ -0,0 +1,423 @@
+import Foundation
+import MapboxMaps
+import Turf
+
+protocol RCTMGLMapComponent : class {
+  func addToMap(_ map: RCTMGLMapView, style: Style)
+  func removeFromMap(_ map: RCTMGLMapView)
+  
+  func waitForStyleLoad() -> Bool
+}
+
+enum CameraMode: String, CaseIterable {
+  case flight, ease, linear, none
+}
+
+struct CameraUpdateItem {
+  var camera: CameraOptions
+  var mode: CameraMode
+  var duration: TimeInterval?
+  
+  func execute(map: RCTMGLMapView, cameraAnimator: inout BasicCameraAnimator?) {
+    logged("CameraUpdateItem.execute") {
+      if let center = camera.center {
+        try center.validate()
+      }
+      switch mode {
+        case .flight:
+          var _camera = camera
+          _camera.padding = nil
+          map.camera.fly(to: _camera, duration: duration)
+          changePadding(map: map, cameraAnimator: &cameraAnimator, curve: .linear)
+        case .ease:
+          map.camera.ease(to: camera, duration: duration ?? 0, curve: .easeInOut, completion: nil)
+        case .linear:
+          map.camera.ease(to: camera, duration: duration ?? 0, curve: .linear, completion: nil)
+        default:
+          map.mapboxMap.setCamera(to: camera)
+      }
+    }
+  }
+  
+  /// Padding is not currently animatable on the camera's `fly(to:)` method, so we create a separate animator instead.
+  /// If this changes, remove this and call `fly(to:)` with an unmodified `camera`.
+  func changePadding(map: RCTMGLMapView, cameraAnimator: inout BasicCameraAnimator?, curve: UIView.AnimationCurve) {
+    if let cameraAnimator = cameraAnimator {
+      cameraAnimator.stopAnimation()
+    }
+    cameraAnimator = map.camera.makeAnimator(duration: duration ?? 0, curve: curve) { (transition) in
+      transition.padding.toValue = camera.padding
+    }
+    cameraAnimator?.startAnimation()
+  }
+}
+
+class CameraUpdateQueue {
+  var queue: [CameraUpdateItem] = [];
+  
+  func dequeue() -> CameraUpdateItem? {
+    guard !queue.isEmpty else {
+      return nil
+    }
+    return queue.removeFirst()
+  }
+  
+  func enqueue(stop: CameraUpdateItem) {
+    queue.append(stop)
+  }
+  
+  func execute(map: RCTMGLMapView, cameraAnimator: inout BasicCameraAnimator?) {
+    guard let stop = dequeue() else {
+      return
+    }
+    
+    stop.execute(map: map, cameraAnimator: &cameraAnimator)
+  }
+}
+
+open class RCTMGLMapComponentBase : UIView, RCTMGLMapComponent {
+  private var _map: RCTMGLMapView! = nil
+  private var _mapCallbacks: [(RCTMGLMapView) -> Void] = []
+  
+  var map : RCTMGLMapView? {
+    return _map;
+  }
+
+  func withMapView(_ callback: @escaping (_ mapView: MapView) -> Void) {
+    withRCTMGLMapView { mapView in
+      callback(mapView.mapView)
+    }
+  }
+
+  func withRCTMGLMapView(_ callback: @escaping (_ map: RCTMGLMapView) -> Void) {
+    if let map = _map {
+      callback(map)
+    } else {
+      _mapCallbacks.append(callback)
+    }
+  }
+  
+  func waitForStyleLoad() -> Bool {
+    return false
+  }
+  
+  func addToMap(_ map: RCTMGLMapView, style: Style) {
+    _mapCallbacks.forEach { callback in
+        callback(map)
+    }
+    _mapCallbacks = []
+    _map = map
+  }
+  
+  func removeFromMap(_ map: RCTMGLMapView) {
+    _mapCallbacks = []
+    _map = nil
+  }
+}
+
+class RCTMGLCamera : RCTMGLMapComponentBase, LocationConsumer {
+  var cameraAnimator: BasicCameraAnimator?
+  let cameraUpdateQueue = CameraUpdateQueue()
+
+  // Properties set on RCTMGLCamera in React Native.
+  @objc var animationDuration: NSNumber?
+  @objc var animationMode: NSString?
+  @objc var defaultStop: [String: Any]?
+  @objc var followHeading: NSNumber? {
+    didSet {
+      _updateCameraFromTrackingMode()
+    }
+  }
+  @objc var followPitch: NSNumber? {
+    didSet {
+      _updateCameraFromTrackingMode()
+    }
+  }
+  @objc var followUserMode: NSString? {
+    didSet {
+      _updateCameraFromTrackingMode()
+    }
+  }
+  @objc var followUserLocation : Bool = false {
+    didSet {
+      _updateCameraFromTrackingMode()
+    }
+  }
+  @objc var followZoomLevel: NSNumber? {
+    didSet {
+      _updateCameraFromTrackingMode()
+    }
+  }
+  @objc var maxZoomLevel: NSNumber?
+  @objc var minZoomLevel: NSNumber?
+  @objc var onUserTrackingModeChange: RCTBubblingEventBlock? = nil
+  @objc var stop: [String: Any]? {
+    didSet {
+      _updateCamera()
+    }
+  }
+  
+  // Update methods.
+
+  func _updateCameraFromJavascript() {
+    guard !followUserLocation else {
+      return
+    }
+    
+    guard let stop = stop else {
+      return
+    }
+    
+    /*
+    V10 TODO
+    if let map = map, map.userTrackingMode != .none {
+      map.userTrackingMode = .none
+    }
+    */
+
+    if let stops = stop["stops"] as? [[String:Any]] {
+      stops.forEach {
+        if let stop = toUpdateItem(stop: $0) {
+          cameraUpdateQueue.enqueue(stop: stop)
+        }
+      }
+    } else {
+      if let stop = toUpdateItem(stop: stop) {
+        cameraUpdateQueue.enqueue(stop: stop)
+      }
+    }
+
+    if let map = map {
+      cameraUpdateQueue.execute(map: map, cameraAnimator: &cameraAnimator)
+    }
+  }
+  
+  func _updateCameraFromTrackingMode() {
+    withMapView { map in
+      if let locationModule = RCTMGLLocationModule.shared {
+        map.location.overrideLocationProvider(with: locationModule.locationProvider)
+      }
+      map.location.locationProvider.requestWhenInUseAuthorization()
+      map.location.addLocationConsumer(newConsumer: self)
+      var trackingModeChanged = false
+      if (self.followUserMode == "compass" && map.location.options.puckBearingSource != PuckBearingSource.heading) {
+        map.location.options.puckBearingEnabled = true
+        map.location.options.puckBearingSource = PuckBearingSource.heading
+        trackingModeChanged = true
+      } else if (self.followUserMode == "course" && map.location.options.puckBearingSource != PuckBearingSource.course) {
+        map.location.options.puckBearingEnabled = true
+        map.location.options.puckBearingSource = PuckBearingSource.course
+        trackingModeChanged = true
+      } else if (self.followUserMode == "normal" && map.location.options.puckBearingEnabled) {
+        map.location.options.puckBearingEnabled = false
+        trackingModeChanged = true
+      }
+      if let onUserTrackingModeChange = self.onUserTrackingModeChange {
+        if (trackingModeChanged) {
+          let event = RCTMGLEvent(type: .onUserTrackingModeChange, payload: ["followUserMode": self.followUserMode, "followUserLocation": self.followUserLocation])
+          onUserTrackingModeChange(event.toJSON())
+        }
+      }
+      var _camera = CameraOptions()
+      if let followHeading = self.followHeading as? CGFloat {
+        if (followHeading >= 0.0) {
+          _camera.bearing = followHeading
+        }
+      } else if let stopHeading = self.stop?["heading"] as? CGFloat {
+        if (stopHeading >= 0.0) {
+          _camera.bearing = stopHeading
+        }
+      }
+      if let followPitch = self.followPitch as? CGFloat {
+        if (followPitch >= 0.0) {
+          _camera.pitch = followPitch
+        }
+      } else if let stopPitch = self.stop?["pitch"] as? CGFloat {
+        if (stopPitch >= 0.0) {
+          _camera.pitch = stopPitch
+        }
+      }
+      if let zoom = self.followZoomLevel as? CGFloat {
+        if (zoom >= 0.0) {
+          _camera.zoom = zoom
+        }
+      }
+      map.mapboxMap.setCamera(to: _camera)
+    }
+  }
+  
+  private func toUpdateItem(stop: [String: Any]) -> CameraUpdateItem? {
+    var zoom: CGFloat?
+    if let z = stop["zoom"] as? Double {
+      zoom = CGFloat(z)
+    }
+    
+    var pitch: CGFloat?
+    if let p = stop["pitch"] as? Double {
+      pitch = CGFloat(p)
+    }
+    
+    var heading: CLLocationDirection?
+    if let h = stop["heading"] as? Double {
+      heading = CLLocationDirection(h)
+    }
+    
+    let padding = UIEdgeInsets(
+      top: stop["paddingTop"] as? Double ?? 0,
+      left: stop["paddingLeft"] as? Double ?? 0,
+      bottom: stop["paddingBottom"] as? Double ?? 0,
+      right: stop["paddingRight"] as? Double ?? 0
+    )
+
+    var center: LocationCoordinate2D?
+    if let feature: String = stop["centerCoordinate"] as? String {
+      
+      let centerFeature : Turf.Feature? = logged("RCTMGLCamera.toUpdateItem.decode.cc") { try
+        JSONDecoder().decode(Turf.Feature.self, from: feature.data(using: .utf8)!)
+      }
+      
+      switch centerFeature?.geometry {
+      case .point(let centerPoint):
+        center = centerPoint.coordinates
+      default:
+        Logger.log(level: .error, message: "RCTMGLCamera.toUpdateItem: Unexpected geometry: \(String(describing: centerFeature?.geometry))")
+        return nil
+      }
+    } else if let feature: String = stop["bounds"] as? String {
+      let collection : Turf.FeatureCollection? = logged("RCTMGLCamera.toUpdateItem.decode.bound") { try
+        JSONDecoder().decode(Turf.FeatureCollection.self, from: feature.data(using: .utf8)!) }
+      let features = collection?.features
+      
+      let ne: CLLocationCoordinate2D
+      switch features?.first?.geometry {
+        case .point(let point):
+          ne = point.coordinates
+        default:
+          Logger.log(level: .error, message: "RCTMGLCamera.toUpdateItem: Unexpected geometry: \(String(describing: features?.first?.geometry))")
+          return nil
+      }
+      
+      let sw: CLLocationCoordinate2D
+      switch features?.last?.geometry {
+        case .point(let point):
+          sw = point.coordinates
+        default:
+          Logger.log(level: .error, message: "RCTMGLCamera.toUpdateItem: Unexpected geometry: \(String(describing: features?.last?.geometry))")
+          return nil
+      }
+      
+      withMapView { map in
+        let bounds = CoordinateBounds(southwest: sw, northeast: ne)
+        let camera = map.mapboxMap.camera(
+          for: bounds,
+          padding: padding,
+          bearing: heading ?? map.cameraState.bearing,
+          pitch: pitch ?? map.cameraState.pitch
+        )
+
+        if let _center = camera.center, let _zoom = camera.zoom {
+          center = _center
+          zoom = _zoom
+        }
+      }
+    }
+
+    let duration: TimeInterval? = {
+      if let d = stop["duration"] as? Double {
+        return toSeconds(d)
+      }
+      return nil
+    }()
+    
+    let mode: CameraMode = {
+      if let m = stop["mode"] as? String, let m = CameraMode(rawValue: m) {
+        return m
+      }
+      return .flight
+    }()
+    
+    if let z1 = minZoomLevel, let z2 = CGFloat(exactly: z1), zoom ?? 100 < z2 {
+      zoom = z2
+    }
+
+    if let z1 = maxZoomLevel, let z2 = CGFloat(exactly: z1), zoom ?? 0 > z2 {
+      zoom = z2
+    }
+
+    let result = CameraUpdateItem(
+      camera: CameraOptions(
+        center: center,
+        padding: padding,
+        anchor: nil,
+        zoom: zoom,
+        bearing: heading,
+        pitch: pitch
+      ),
+      mode: mode,
+      duration: duration
+    )
+    return result
+  }
+  
+  func _updateCamera() {
+    if let _ = map {
+      if followUserLocation {
+        self._updateCameraFromTrackingMode()
+      } else {
+        self._updateCameraFromJavascript()
+      }
+    }
+  }
+  
+  func _setInitialCamera() {
+    guard let stop = self.defaultStop, let map = map else {
+      return
+    }
+    
+    if var updateItem = toUpdateItem(stop: stop) {
+      updateItem.mode = .none
+      updateItem.duration = 0
+      updateItem.execute(map: map, cameraAnimator: &cameraAnimator)
+    }
+  }
+  
+  func initialLayout() {
+    _setInitialCamera()
+    _updateCamera()
+  }
+  
+  override func addToMap(_ map: RCTMGLMapView, style: Style) {
+    super.addToMap(map, style: style)
+    map.reactCamera = self
+  }
+  
+  // MARK: - LocationConsumer
+  
+  func locationUpdate(newLocation: Location) {
+    if followUserLocation {
+      withMapView { map in
+        var animationType = CameraMode.none
+        if let m = self.animationMode as? String, let m = CameraMode(rawValue: m) {
+          animationType = m
+        }
+        let _camera = CameraOptions(center: newLocation.coordinate)
+        let _duration = self.animationDuration as? Double ?? 0.5
+        switch (animationType) {
+          case .flight:
+            map.camera.fly(to: _camera, duration: _duration)
+          case .ease:
+            map.camera.ease(to: _camera, duration: _duration, curve: .easeInOut, completion: nil)
+          case .linear:
+            map.camera.ease(to: _camera, duration: _duration, curve: .linear, completion: nil)
+          default:
+            map.mapboxMap.setCamera(to: CameraOptions(center: newLocation.coordinate))
+        }
+      }
+    }
+  }
+}
+
+/// Converts milliseconds to seconds.
+private func toSeconds(_ ms: Double) -> TimeInterval {
+  return ms * 0.001
+}

package/ios/RCTMGL-v10/RCTMGLCameraManager.m

@@ -0,0 +1,20 @@
+#import "React/RCTBridgeModule.h"
+#import <React/RCTViewManager.h>
+#import <Foundation/Foundation.h>
+
+@interface RCT_EXTERN_MODULE(RCTMGLCameraManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(animationDuration, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(animationMode, NSString)
+RCT_EXPORT_VIEW_PROPERTY(defaultStop, NSDictionary)
+RCT_EXPORT_VIEW_PROPERTY(followHeading, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(followPitch, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(followUserLocation, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(followUserMode, NSString)
+RCT_EXPORT_VIEW_PROPERTY(followZoomLevel, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(maxZoomLevel, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(minZoomLevel, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(onUserTrackingModeChange, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(stop, NSDictionary)
+
+@end

package/ios/RCTMGL-v10/RCTMGLCameraManager.swift

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

package/ios/RCTMGL-v10/RCTMGLCircleLayer.swift

@@ -0,0 +1,66 @@
+import MapboxMaps
+
+@objc(RCTMGLCircleLayer)
+class RCTMGLCircleLayer: RCTMGLVectorLayer {
+  
+  typealias LayerType = CircleLayer
+
+  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 CircleLayer) in
+      if let styleLayer = self.styleLayer as? LayerType {
+        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 = self.reactStyle {
+        styler.circleLayer(
+          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
+  }
+/*
+- (MGLCircleStyleLayer*)makeLayer:(MGLStyle*)style
+{
+    MGLSource *source = [self layerWithSourceIDInStyle:style];
+    if (source == nil) { return nil; }
+    MGLCircleStyleLayer *layer = [[MGLCircleStyleLayer alloc] initWithIdentifier:self.id source:source];
+    layer.sourceLayerIdentifier = self.sourceLayerID;
+    return layer;
+}
+
+- (void)addStyles
+{
+    RCTMGLStyle *style = [[RCTMGLStyle alloc] initWithMGLStyle:self.style];
+    style.bridge = self.bridge;
+    [style circleLayer:(MGLCircleStyleLayer*)self.styleLayer withReactStyle:self.reactStyle isValid:^{
+        return [self isAddedToMap];
+    }];
+}*/
+
+}

package/ios/RCTMGL-v10/RCTMGLCircleLayerManager.m

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

package/ios/RCTMGL-v10/RCTMGLCircleLayerManager.swift

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

package/ios/RCTMGL-v10/RCTMGLEvent.swift

@@ -0,0 +1,47 @@
+import Foundation
+
+protocol RCTMGLEventProtocol {
+
+    func toJSON() -> [String: Any];
+}
+
+@objc
+class RCTMGLEvent : NSObject, RCTMGLEventProtocol {
+    var type: String = ""
+    var payload: [String:Any]? = nil
+    func toJSON() -> [String: Any]
+    {
+        if let payload = payload {
+            return ["type": type, "payload": payload];
+        } else {
+            return ["type": type]
+        }
+    }
+
+    enum EventType : String {
+      case tap
+      case longPress
+      //case regionWillChange
+      case regionIsChanging
+      case regionDidChange
+      case cameraChanged
+      case mapIdle
+      case imageMissing
+      case didFinishLoadingMap
+      case didFinishRenderingFully
+      case didFinishRendering
+      case didFinishLoadingStyle
+      case offlineProgress
+      case offlineError
+      case offlineTileLimit
+      case onUserTrackingModeChange
+      case vectorSourceLayerPress
+      case shapeSourceLayerPress
+    }
+    
+    init(type: EventType, payload: [String:Any]?) {
+        self.type = type.rawValue
+        self.payload = payload
+    }
+    
+}

package/ios/RCTMGL-v10/RCTMGLFeatureUtils.swift

@@ -0,0 +1,79 @@
+import MapboxMaps
+import MapKit
+
+class RCTMGLFeatureUtils {
+  
+  enum ParseError : Error {
+    case fcParseError(String)
+  }
+  
+  static func parseAsFC(string: String) throws -> GeoJSONObject {
+    let data = string.data(using: .utf8)!
+    let geojson = try JSONDecoder().decode(GeoJSONObject.self, from:data)
+    return geojson
+    //let feature = Feature(geometry: try JSONDecoder().decode(Geometry.self, from: data))
+    // return feature
+  }
+  
+  static func toNSValue(_ cglocation: CLLocationCoordinate2D) -> NSValue {
+    return NSValue(mkCoordinate: cglocation)
+//    return NSValue(cgPoint: CGPoint(x: cglocation.latitude, y: cglocation.longitude))
+  }
+  
+  static func geometryToGeometry(_ geometry: Turf.Geometry) -> MapboxCommon.Geometry {
+    switch geometry {
+    case .geometryCollection(let collection):
+      return MapboxCommon.Geometry(geometryCollection: collection.geometries.map { geometryToGeometry($0) })
+    case .lineString(let lineString):
+      return MapboxCommon.Geometry(line: lineString.coordinates.map { toNSValue($0) })
+    case .multiLineString(let multiLineString):
+      return MapboxCommon.Geometry(multiLine: multiLineString.coordinates.map { $0.map { toNSValue($0) }})
+    case .multiPoint(let multiPoint):
+      return MapboxCommon.Geometry(multiPoint: multiPoint.coordinates.map { toNSValue($0) })
+    case .multiPolygon(let multiPolygon):
+      return MapboxCommon.Geometry(multiPolygon: multiPolygon.coordinates.map { $0.map { $0.map { toNSValue($0) }}})
+    case .point(let point):
+      return MapboxCommon.Geometry(point: toNSValue(point.coordinates))
+/*
+      let value = NSValue(cgPoint: CGPoint(x: point.coordinates.longitude, y: point.coordinates.latitude))
+      return MapboxCommon.Geometry(point: value) */
+    case .polygon(let polygon):
+      return MapboxCommon.Geometry(polygon: polygon.coordinates.map { $0.map { toNSValue($0)}})
+    }
+  }
+  
+  static func fcToGeomtry(_ collection: FeatureCollection) -> Turf.Geometry {
+    return .geometryCollection(GeometryCollection(geometries: collection.features.map { $0.geometry! }))
+  }
+
+  static func boundingBox(geometry: Geometry) -> BoundingBox? {
+    switch geometry {
+    case .polygon(let polygon):
+      return BoundingBox(from:  polygon.outerRing.coordinates)
+    case .lineString(let lineString):
+      return BoundingBox(from: lineString.coordinates)
+    case .point(let point):
+      return BoundingBox(from: [point.coordinates])
+    case .multiPoint(let multiPoint):
+      return BoundingBox(from: multiPoint.coordinates)
+    case .multiPolygon(let multiPolygon):
+      let coordinates : [[[LocationCoordinate2D]]] = multiPolygon.coordinates;
+      return BoundingBox(from: Array(coordinates.joined().joined()))
+    case .geometryCollection(let collection):
+      let geometries = collection.geometries
+      let coordinates : [[LocationCoordinate2D]] = geometries.map { (geometry) in
+        if let bb = boundingBox(geometry: geometry) {
+          return [bb.northEast,bb.southWest]
+        } else {
+          return []
+        }
+      };
+      
+      return BoundingBox(from: Array(coordinates.joined()))
+    case .multiLineString(let multiLineString):
+      let coordinates = multiLineString.coordinates
+      return BoundingBox(from: Array(coordinates.joined()))
+    }
+  }
+  
+}

package/ios/RCTMGL-v10/RCTMGLFillExtrusionLayerManager.m

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

package/ios/RCTMGL-v10/RCTMGLFillExtrusionLayerManager.swift

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