@rnmapbox/maps 10.0.15 → 10.1.0-beta.4

package/ios/RCTMGL-v10/MBXMapViewManager.swift

@@ -0,0 +1,250 @@
+import MapboxMaps
+
+#if RNMBX_11
+extension QueriedSourceFeature {
+  var feature: Feature { return self.queriedFeature.feature }
+}
+#endif
+
+@objc(MBXMapViewManager)
+public class MBXMapViewManager: RCTViewManager {
+    @objc
+    override public static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+  
+    func defaultFrame() -> CGRect {
+        return UIScreen.main.bounds
+    }
+  
+    override public func view() -> UIView! {
+        let result = RCTMGLMapView(frame: self.defaultFrame(), eventDispatcher: self.bridge.eventDispatcher())
+        return result
+    }
+}
+
+// MARK: helpers
+
+extension MBXMapViewManager {
+    static func withMapboxMap(
+        _ view: RCTMGLMapView,
+        name: String,
+        rejecter: @escaping RCTPromiseRejectBlock,
+        fn: @escaping (_: MapboxMap) -> Void) -> Void
+    {
+        guard let mapboxMap = view.mapboxMap else {
+          RCTMGLLogError("MapboxMap is not yet available");
+          rejecter(name, "Map not loaded yet", nil)
+          return;
+        }
+        
+        fn(mapboxMap)
+    }
+}
+
+// MARK: - react methods
+
+extension MBXMapViewManager {
+    @objc public static func takeSnap(_ view: RCTMGLMapView,
+                         writeToDisk: Bool,
+                         resolver: @escaping RCTPromiseResolveBlock) {
+        let uri = view.takeSnap(writeToDisk: writeToDisk)
+        resolver(["uri": uri.absoluteString])
+    }
+  
+    @objc public static func queryTerrainElevation(_ view: RCTMGLMapView,
+                                  coordinates: [NSNumber],
+                                  resolver: @escaping RCTPromiseResolveBlock,
+                                  rejecter: @escaping RCTPromiseRejectBlock
+    ) -> Void {
+       let result = view.queryTerrainElevation(coordinates: coordinates)
+       if let result = result {
+         resolver(["data": NSNumber(value: result)])
+       } else {
+         resolver(nil)
+       }
+    }
+
+    @objc public static func setSourceVisibility(_ view: RCTMGLMapView,
+                                      visible: Bool,
+                                      sourceId: String,
+                                      sourceLayerId: String?,
+                                      resolver: @escaping RCTPromiseResolveBlock,
+                                      rejecter: @escaping RCTPromiseRejectBlock) -> Void {
+          view.setSourceVisibility(visible, sourceId: sourceId, sourceLayerId:sourceLayerId)
+          resolver(nil)
+    }
+    
+    @objc public static func getCenter(_ view: RCTMGLMapView, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        withMapboxMap(view, name: "getCenter", rejecter:rejecter) { map in
+            resolver(["center": [
+                map.cameraState.center.longitude,
+                map.cameraState.center.latitude
+            ]])
+        }
+    }
+
+    @objc public static func getCoordinateFromView(
+        _ view: RCTMGLMapView,
+        atPoint point: CGPoint,
+        resolver: @escaping RCTPromiseResolveBlock,
+        rejecter: @escaping RCTPromiseRejectBlock) {
+            withMapboxMap(view, name: "getCoordinateFromView", rejecter:rejecter) { map in
+                let coordinates = map.coordinate(for: point)
+                resolver(["coordinateFromView": [coordinates.longitude, coordinates.latitude]])
+            }
+            
+    }
+
+    @objc public static func getPointInView(
+        _ view: RCTMGLMapView,
+        atCoordinate coordinate: [NSNumber],
+        resolver: @escaping RCTPromiseResolveBlock,
+        rejecter: @escaping RCTPromiseRejectBlock) {
+            withMapboxMap(view, name: "getPointInView", rejecter:rejecter) { map in
+                let coordinate = CLLocationCoordinate2DMake(coordinate[1].doubleValue, coordinate[0].doubleValue)
+                let point = map.point(for: coordinate)
+                resolver(["pointInView": [(point.x), (point.y)]])
+            }
+            
+      }
+
+    @objc public static func setHandledMapChangedEvents(
+        _ view: RCTMGLMapView,
+        events: [String],
+        resolver: @escaping RCTPromiseResolveBlock,
+        rejecter: @escaping RCTPromiseRejectBlock) {
+          view.handleMapChangedEvents = Set(events.compactMap {
+            RCTMGLEvent.EventType(rawValue: $0)
+          })
+          resolver(nil);
+      }
+
+    @objc public static func getZoom(
+        _ view: RCTMGLMapView,
+        resolver: @escaping RCTPromiseResolveBlock,
+        rejecter: @escaping RCTPromiseRejectBlock) {
+            withMapboxMap(view, name: "getZoom", rejecter:rejecter) { map in
+                resolver(["zoom": map.cameraState.zoom])
+            }
+            
+    }
+
+    @objc public static func getVisibleBounds(
+        _ view: RCTMGLMapView,
+        resolver: @escaping RCTPromiseResolveBlock) {
+            resolver(["visibleBounds":  view.mapboxMap.coordinateBounds(for: view.bounds).toArray()])
+    }
+
+}
+
+// MARK: - queryRenderedFeatures
+
+extension MBXMapViewManager {
+    @objc public static func queryRenderedFeaturesAtPoint(
+        _ view: RCTMGLMapView,
+        atPoint point: [NSNumber],
+        withFilter filter: [Any]?,
+        withLayerIDs layerIDs: [String]?,
+        resolver: @escaping RCTPromiseResolveBlock,
+        rejecter: @escaping RCTPromiseRejectBlock) -> Void {
+            withMapboxMap(view, name: "queryRenderedFeaturesAtPoint", rejecter:rejecter) { map 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 ?? []).isEmpty ? nil : layerIDs, filter: filter?.asExpression())
+                  
+                  map.queryRenderedFeatures(with: 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 public static func queryRenderedFeaturesInRect(
+        _ map: RCTMGLMapView,
+        withBBox bbox: [NSNumber],
+        withFilter filter: [Any]?,
+        withLayerIDs layerIDs: [String]?,
+        resolver: @escaping RCTPromiseResolveBlock,
+        rejecter: @escaping RCTPromiseRejectBlock) -> Void {
+            let top = bbox.isEmpty ? 0.0 : CGFloat(bbox[0].floatValue)
+            let right = bbox.isEmpty ? 0.0 : CGFloat(bbox[1].floatValue)
+            let bottom = bbox.isEmpty ? 0.0 : CGFloat(bbox[2].floatValue)
+            let left = bbox.isEmpty ? 0.0 : CGFloat(bbox[3].floatValue)
+            let rect = bbox.isEmpty ? CGRect(x: 0.0, y: 0.0, width: map.bounds.size.width, height: map.bounds.size.height) : CGRect(x: [left,right].min()!, y: [top,bottom].min()!, width: abs(right-left), height: abs(bottom-top))
+            logged("queryRenderedFeaturesInRect.option", rejecter: rejecter) {
+              let options = try RenderedQueryOptions(layerIds: layerIDs?.isEmpty ?? true ? nil : layerIDs, filter: filter?.asExpression())
+              map.mapboxMap.queryRenderedFeatures(with: 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("queryRenderedFeaturesInRect","failed to query features", error)
+                }
+              }
+            }
+        }
+
+    @objc public static func querySourceFeatures(
+    _ map: RCTMGLMapView,
+    withSourceId sourceId: String,
+    withFilter filter: [Any]?,
+    withSourceLayerIds sourceLayerIds: [String]?,
+    resolver: @escaping RCTPromiseResolveBlock,
+    rejecter: @escaping RCTPromiseRejectBlock) -> Void {
+      let sourceLayerIds = sourceLayerIds?.isEmpty ?? true ? nil : sourceLayerIds
+      logged("querySourceFeatures.option", rejecter: rejecter) {
+        let options = SourceQueryOptions(sourceLayerIds: sourceLayerIds, filter: filter ?? Exp(arguments: []))
+        map.mapboxMap.querySourceFeatures(for: sourceId, options: options) { result in
+          switch result {
+          case .success(let features):
+            resolver([
+              "data": ["type": "FeatureCollection", "features": features.compactMap { queriedFeature in
+                logged("querySourceFeatures.queriedfeature.map") { try queriedFeature.feature.toJSON() }
+              }] as [String : Any]
+            ])
+          case .failure(let error):
+            rejecter("querySourceFeatures", "failed to query source features: \(error.localizedDescription)", error)
+          }
+        }
+      }
+    }
+
+    static func clearData(_ view: RCTMGLMapView, completion: @escaping (Error?) -> Void) {
+      #if RNMBX_11
+      MapboxMap.clearData(completion: completion)
+      #else
+      view.mapboxMap.clearData(completion: completion)
+      #endif
+    }
+  
+    @objc public static func clearData(
+        _ mapView: RCTMGLMapView,
+        resolver:@escaping RCTPromiseResolveBlock,
+        rejecter:@escaping RCTPromiseRejectBlock
+    ) {
+        self.clearData(mapView) { error in
+          if let error = error {
+            rejecter("clearData","failed to clearData: \(error.localizedDescription)", error)
+          } else {
+            resolver(nil)
+          }
+        }
+    }
+
+}

package/ios/RCTMGL-v10/MBXMapViewModule.h

@@ -0,0 +1,18 @@
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "rnmapbox_maps_specs.h"
+#else
+#import <React/RCTBridge.h>
+#endif
+
+@interface MBXMapViewModule : NSObject
+#ifdef RCT_NEW_ARCH_ENABLED
+<NativeMapViewModuleSpec>
+#else
+<RCTBridgeModule>
+#endif
+
+@end
+

package/ios/RCTMGL-v10/MBXMapViewModule.mm

@@ -0,0 +1,167 @@
+#import <React/RCTBridge.h>
+#import <React/RCTUIManager.h>
+#import <React/RCTUIManagerUtils.h>
+
+#import "MBXMapViewModule.h"
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "MBXMapViewComponentView.h"
+#endif // RCT_NEW_ARCH_ENABLED
+
+// needed for compilation for some reason
+#import <CoreFoundation/CoreFoundation.h>
+#import <CoreLocation/CoreLocation.h>
+
+@interface MapView : UIView
+@end
+
+#import <rnmapbox_maps-Swift.h>
+
+
+@implementation MBXMapViewModule
+
+RCT_EXPORT_MODULE();
+
+#ifdef RCT_NEW_ARCH_ENABLED
+@synthesize viewRegistry_DEPRECATED = _viewRegistry_DEPRECATED;
+#endif // RCT_NEW_ARCH_ENABLED
+@synthesize bridge = _bridge;
+
+- (dispatch_queue_t)methodQueue
+{
+  // It seems that due to how UIBlocks work with uiManager, we need to call the methods there
+  // for the blocks to be dispatched before the batch is completed
+  return RCTGetUIManagerQueue();
+}
+
+- (void)withMapView:(nonnull NSNumber*)viewRef block:(void (^)(MBXMapView *))block reject:(RCTPromiseRejectBlock)reject methodName:(NSString *)methodName
+{
+//    void (^upperBlock)(void) = ^{
+#ifdef RCT_NEW_ARCH_ENABLED
+    [self.viewRegistry_DEPRECATED addUIBlock:^(RCTViewRegistry *viewRegistry) {
+        MBXMapViewComponentView *componentView = [self.viewRegistry_DEPRECATED viewForReactTag:viewRef];
+        MBXMapView *view = componentView.contentView;
+        
+#else
+    [self.bridge.uiManager
+     addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        MBXMapView *view = [uiManager viewForReactTag:viewRef];
+#endif // RCT_NEW_ARCH_ENABLED
+        if (view != nil) {
+           block(view);
+        } else {
+            reject(methodName, [NSString stringWithFormat:@"Unknown reactTag: %@", viewRef], nil);
+        }
+    }];
+//        [self.bridge performSelector:@selector(batchDidComplete) withObject:self.bridge];
+//    };
+//      if (self.bridge) {
+//        dispatch_async(RCTGetUIManagerQueue(), upperBlock);
+//      } else {
+//        dispatch_async(dispatch_get_main_queue(), upperBlock);
+//      }
+}
+
+
+RCT_EXPORT_METHOD(takeSnap:(nonnull NSNumber*)viewRef writeToDisk:(BOOL)writeToDisk resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+{
+    [self withMapView:viewRef block:^(MBXMapView *view) {
+        [MBXMapViewManager takeSnap:view writeToDisk:writeToDisk resolver:resolve];
+    } reject:reject methodName:@"takeSnap"];
+}
+
+RCT_EXPORT_METHOD(clearData:(nonnull NSNumber*)viewRef resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    [self withMapView:viewRef block:^(MBXMapView *view) {
+        [MBXMapViewManager clearData:view resolver:resolve rejecter:reject];
+    } reject:reject methodName:@"clearData"];
+}
+
+
+RCT_EXPORT_METHOD(getCenter:(nonnull NSNumber*)viewRef resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    [self withMapView:viewRef block:^(MBXMapView *view) {
+        [MBXMapViewManager getCenter:view resolver:resolve rejecter:reject];
+    } reject:reject methodName:@"getCenter"];
+}
+
+
+RCT_EXPORT_METHOD(getCoordinateFromView:(nonnull NSNumber*)viewRef atPoint:(NSArray *)atPoint resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    [self withMapView:viewRef block:^(MBXMapView *view) {
+        NSNumber* a = [atPoint objectAtIndex:0];
+        NSNumber* b = [atPoint objectAtIndex:1];
+        
+        [MBXMapViewManager getCoordinateFromView:view atPoint:CGPointMake(a.floatValue, b.floatValue) resolver:resolve rejecter:reject];
+    } reject:reject methodName:@"getCoordinateFromView"];
+}
+
+
+RCT_EXPORT_METHOD(getPointInView:(nonnull NSNumber*)viewRef atCoordinate:(NSArray *)atCoordinate resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    [self withMapView:viewRef block:^(MBXMapView *view) {
+        [MBXMapViewManager getPointInView:view atCoordinate:atCoordinate resolver:resolve rejecter:reject];
+    } reject:reject methodName:@"getPointInView"];
+}
+
+
+RCT_EXPORT_METHOD(getVisibleBounds:(nonnull NSNumber*)viewRef resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    [self withMapView:viewRef block:^(MBXMapView *view) {
+        [MBXMapViewManager getVisibleBounds:view resolver:resolve];
+    } reject:reject methodName:@"getVisibleBounds"];
+}
+
+
+RCT_EXPORT_METHOD(getZoom:(nonnull NSNumber*)viewRef resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    [self withMapView:viewRef block:^(MBXMapView *view) {
+        [MBXMapViewManager getZoom:view resolver:resolve rejecter:reject];
+    } reject:reject methodName:@"getZoom"];
+}
+
+
+RCT_EXPORT_METHOD(queryRenderedFeaturesAtPoint:(nonnull NSNumber*)viewRef atPoint:(nonnull NSArray *)atPoint withFilter:(NSArray *)withFilter withLayerIDs:(NSArray *)withLayerIDs resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    [self withMapView:viewRef block:^(MBXMapView *view) {
+        [MBXMapViewManager queryRenderedFeaturesAtPoint:view atPoint:atPoint withFilter:withFilter withLayerIDs:withLayerIDs resolver:resolve rejecter:reject];
+    } reject:reject methodName:@"queryRenderedFeaturesAtPoint"];
+}
+
+
+RCT_EXPORT_METHOD(queryRenderedFeaturesInRect:(nonnull NSNumber*)viewRef withBBox:(NSArray *)withBBox withFilter:(NSArray *)withFilter withLayerIDs:(NSArray *)withLayerIDs resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    [self withMapView:viewRef block:^(MBXMapView *view) {
+        [MBXMapViewManager queryRenderedFeaturesInRect:view withBBox:withBBox withFilter:withFilter withLayerIDs:withLayerIDs resolver:resolve rejecter:reject];
+    } reject:reject methodName:@"queryRenderedFeaturesInRect"];
+}
+
+
+RCT_EXPORT_METHOD(queryTerrainElevation:(nonnull NSNumber*)viewRef coordinates:(NSArray *)coordinates resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    [self withMapView:viewRef block:^(MBXMapView *view) {
+        [MBXMapViewManager queryTerrainElevation:view coordinates:coordinates resolver:resolve rejecter:reject];
+    } reject:reject methodName:@"queryTerrainElevation"];
+}
+
+
+RCT_EXPORT_METHOD(setHandledMapChangedEvents:(nonnull NSNumber*)viewRef events:(NSArray *)events resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    [self withMapView:viewRef block:^(MBXMapView *view) {
+        [MBXMapViewManager setHandledMapChangedEvents:view events:events resolver:resolve rejecter:reject];
+    } reject:reject methodName:@"setHandledMapChangedEvents"];
+}
+
+
+RCT_EXPORT_METHOD(setSourceVisibility:(nonnull NSNumber*)viewRef visible:(BOOL)visible sourceId:(NSString *)sourceId sourceLayerId:(NSString *)sourceLayerId resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    [self withMapView:viewRef block:^(MBXMapView *view) {
+        [MBXMapViewManager setSourceVisibility:view visible:visible sourceId:sourceId sourceLayerId:sourceLayerId resolver:resolve rejecter:reject];
+    } reject:reject methodName:@"setSourceVisibility"];
+}
+
+RCT_EXPORT_METHOD(querySourceFeatures:(nonnull NSNumber*)viewRef sourceId:(NSString*)sourceId withFilter:(NSArray<id>*)withFilter withSourceLayerIDs:(NSArray<NSString*>*)withSourceLayerIDs resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    [self withMapView:viewRef block:^(MBXMapView *view) {
+        [MBXMapViewManager querySourceFeatures:view withSourceId:sourceId withFilter:withFilter withSourceLayerIds:withSourceLayerIDs resolver:resolve rejecter:reject];
+    } reject:reject methodName:@"querySourceFeatures"];
+}
+
+
+// Thanks to this guard, we won't compile this code when we build for the old architecture.
+#ifdef RCT_NEW_ARCH_ENABLED
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeMapViewModuleSpecJSI>(params);
+}
+#endif // RCT_NEW_ARCH_ENABLED
+
+@end

package/ios/RCTMGL-v10/MGLModule.swift

@@ -1,13 +1,25 @@
 import Foundation
 import MapboxMaps
+#if canImport(MapboxMobileEvents)
 import MapboxMobileEvents
+#endif
 
 
 let DEFAULT_SOURCE_ID = "composite";
 
 @objc(MGLModule)
 class MGLModule : NSObject {
-  static var accessToken : String?
+  #if RNMBX_11
+  static var accessToken : String? {
+    didSet {
+      if let token = accessToken {
+        MapboxOptions.accessToken = token
+      }
+    }
+  }
+  #else
+    static var accessToken : String?
+  #endif
     
   @objc
   func constantsToExport() -> [AnyHashable: Any]! {
@@ -91,7 +103,9 @@ class MGLModule : NSObject {
   }
   
   @objc func setTelemetryEnabled(_ telemetryEnabled: Bool) {
+    #if !RNMBX_11 // RNMBX_11_TODO
     UserDefaults.mme_configuration().mme_isCollectionEnabled = telemetryEnabled
+    #endif
   }
 
   @objc func setWellKnownTileServer(_ tileServer: String) {

package/ios/RCTMGL-v10/MGLSnapshotModule.swift

@@ -93,13 +93,19 @@ class MGLSnapshotModule : NSObject {
           let height = jsOptions["height"] as? NSNumber else {
       throw RCTMGLError.paramError("width, height: is not a number")
     }
-    
+    #if RNMBX_11
+    let mapSnapshotOptions = MapSnapshotOptions(
+      size: CGSize(width: width.doubleValue, height: height.doubleValue),
+      pixelRatio: 1.0
+    )
+    #else
     let resourceOptions = ResourceOptions(accessToken: MGLModule.accessToken!)
     let mapSnapshotOptions = MapSnapshotOptions(
       size: CGSize(width: width.doubleValue, height: height.doubleValue),
       pixelRatio: 1.0,
       resourceOptions: resourceOptions
     )
+    #endif
     
     return mapSnapshotOptions
   }

package/ios/RCTMGL-v10/RCTMGLAtmosphere.swift

@@ -1,5 +1,9 @@
 import MapboxMaps
 
+#if RNMBX_11
+typealias Style = StyleManager
+#endif
+
 @objc(RCTMGLAtmosphere)
 class RCTMGLAtmosphere : RCTMGLSingletonLayer, RCTMGLMapComponent, RCTMGLSourceConsumer {
   var atmosphere : Atmosphere? = nil

package/ios/RCTMGL-v10/RCTMGLBackgroundLayer.swift

@@ -5,10 +5,11 @@ class RCTMGLBackgroundLayer: RCTMGLLayer {
   typealias LayerType = BackgroundLayer
 
   override func makeLayer(style: Style) throws -> Layer {
-    let vectorSource : VectorSource = try self.layerWithSourceID(in: style)
     var layer = LayerType(id: self.id!)
+    #if !RNMBX_11
     layer.sourceLayer = self.sourceLayerID
     layer.source = sourceID
+    #endif
     return layer
   }
 

package/ios/RCTMGL-v10/RCTMGLCamera.swift

@@ -2,6 +2,15 @@ import Foundation
 import MapboxMaps
 import Turf
 
+#if RNMBX_11
+extension NSNumber {
+  /// Converts an `NSNumber` to a `CGFloat` value from its `Double` representation.
+  internal var CGFloat: CGFloat {
+    CoreGraphics.CGFloat(doubleValue)
+  }
+}
+#endif
+
 enum RemovalReason {
     case ViewRemoval, StyleChange, OnDestroy, ComponentChange, Reorder
 }
@@ -279,16 +288,26 @@ class RCTMGLCamera : RCTMGLMapComponentBase {
 
       if let locationModule = RCTMGLLocationModule.shared {
         var isSameProvider = false
+        #if !RNMBX_11
         if let currentProvider = map.location.locationProvider as? AnyObject, let newProvider = locationModule.locationProvider as? AnyObject {
           if currentProvider === newProvider {
             isSameProvider = true
           }
         }
+        #endif
         if !isSameProvider {
+          #if RNMBX_11
+          map.location.override(provider: locationModule.locationProvider)
+          #else
           map.location.overrideLocationProvider(with: locationModule.locationProvider)
+          #endif
         }
       }
+      #if RNMBX_11
+      // RNMBX_11_TODO
+      #else
       map.location.locationProvider.requestWhenInUseAuthorization()
+      #endif
       var trackingModeChanged = false
       var followOptions = FollowPuckViewportStateOptions()
       switch userTrackingMode {
@@ -427,7 +446,11 @@ class RCTMGLCamera : RCTMGLMapComponentBase {
       }
       
       withMapView { map in
+        #if RNMBX_11
+        let bounds = [sw, ne]
+        #else
         let bounds = CoordinateBounds(southwest: sw, northeast: ne)
+        #endif
         let camera = map.mapboxMap.camera(
           for: bounds,
           padding: padding,

package/ios/RCTMGL-v10/RCTMGLCircleLayer.swift

@@ -7,7 +7,11 @@ class RCTMGLCircleLayer: RCTMGLVectorLayer {
 
   override func makeLayer(style: Style) throws -> Layer {
     let _ : VectorSource = try self.layerWithSourceID(in: style)
+    #if RNMBX_11
+    var layer = LayerType(id: self.id!, source: self.sourceID!)
+    #else
     var layer = LayerType(id: self.id!)
+    #endif
     layer.sourceLayer = self.sourceLayerID
     layer.source = sourceID
     return layer

package/ios/RCTMGL-v10/RCTMGLFillExtrustionLayer.swift

@@ -6,7 +6,11 @@ class RCTMGLFillExtrusionLayer: RCTMGLVectorLayer {
 
   override func makeLayer(style: Style) throws -> Layer {
     let _ : VectorSource = try self.layerWithSourceID(in: style)
+    #if RNMBX_11
+    var layer = LayerType(id: self.id!, source:sourceID!)
+    #else
     var layer = LayerType(id: self.id!)
+    #endif
     layer.sourceLayer = self.sourceLayerID
     layer.source = sourceID
     return layer

package/ios/RCTMGL-v10/RCTMGLFillLayer.swift

@@ -6,7 +6,11 @@ class RCTMGLFillLayer: RCTMGLVectorLayer {
 
   override func makeLayer(style: Style) throws -> Layer {
     let _ : VectorSource = try self.layerWithSourceID(in: style)
+    #if RNMBX_11
+    var layer: Layer = FillLayer(id: self.id!, source: sourceID!)
+    #else
     var layer: Layer = FillLayer(id: self.id!)
+    #endif
     
     setOptions(&layer)
     

package/ios/RCTMGL-v10/RCTMGLHeatmapLayer.swift

@@ -6,8 +6,11 @@ class RCTMGLHeatmapLayer: RCTMGLVectorLayer {
 
   override func makeLayer(style: Style) throws -> Layer {
     let _ : VectorSource = try self.layerWithSourceID(in: style)
+    #if RNMBX_11
+    var layer: Layer = LayerType(id: self.id!, source: self.sourceID!)
+    #else
     var layer: Layer = LayerType(id: self.id!)
-    
+    #endif
     setOptions(&layer)
     
     return layer

package/ios/RCTMGL-v10/RCTMGLImageSource.swift

@@ -35,7 +35,11 @@ class RCTMGLImageSource : RCTMGLSource {
 
   override func makeSource() -> Source
   {
+    #if RNMBX_11
+    var result = ImageSource(id: self.id)
+    #else
     var result = ImageSource()
+    #endif
     if let url = url {
       result.url = url
     }

package/ios/RCTMGL-v10/RCTMGLImages.swift

@@ -4,6 +4,18 @@ protocol RCTMGLImageSetter : AnyObject {
   func addImage(name: String, image: UIImage, sdf: Bool?, stretchX: [[NSNumber]], stretchY: [[NSNumber]], content: [NSNumber]?, log: String) -> Bool
 }
 
+func hasImage(style: Style, name: String) -> Bool {
+  #if RNMBX_11
+  return style.imageExists(withId: name)
+  #else
+  return (style.styleManager.getStyleImage(forImageId: name) != nil)
+  #endif
+}
+
+#if RNMBX_11
+typealias StyleImageMissingPayload = StyleImageMissing
+#endif
+
 class RCTMGLImages : UIView, RCTMGLMapComponent {
   
   weak var bridge : RCTBridge! = nil
@@ -104,7 +116,7 @@ class RCTMGLImages : UIView, RCTMGLMapComponent {
         if !sameImage(oldValue: oldImages[name], newValue: images[name]) {
           missingImages[name] = images[name]
         } else {
-          if style.styleManager.getStyleImage(forImageId: name) == nil {
+          if !hasImage(style: style, name: name) {
             logged("RCTMGLImages.addImagePlaceholder") {
               try? style.addImage(placeholderImage, id: name, stretchX: [], stretchY: [])
               missingImages[name] = images[name]
@@ -231,7 +243,7 @@ class RCTMGLImages : UIView, RCTMGLMapComponent {
   func addNativeImages(style: Style, nativeImages: [NativeImageInfo]) {
     for imageInfo in nativeImages {
       let imageName = imageInfo.name
-      if style.styleManager.getStyleImage(forImageId: imageInfo.name) == nil {
+      if !hasImage(style: style, name: imageInfo.name) {
         if let image = UIImage(named: imageName) {
           logged("RCTMGLImage.addNativeImage: \(imageName)") {
             try style.addImage(image, id: imageName, sdf: imageInfo.sdf,