@rnmapbox/maps 10.0.15-rc.1 → 10.1.0-beta.2

package/android/src/main/old-arch/com/mapbox/rctmgl/NativeMapViewModuleSpec.java

@@ -0,0 +1,88 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+* This file should be updated after modifying `NativeMapViewModule.ts`.
+ *
+ * @generated by codegen project: GenerateModuleJavaSpec.js
+ *
+ * @nolint
+ */
+
+package com.mapbox.rctmgl;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReactModuleWithSpec;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.turbomodule.core.interfaces.TurboModule;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public abstract class NativeMapViewModuleSpec extends ReactContextBaseJavaModule implements ReactModuleWithSpec, TurboModule {
+  public static final String NAME = "MBXMapViewModule";
+
+  public NativeMapViewModuleSpec(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public @Nonnull String getName() {
+    return NAME;
+  }
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void takeSnap(@Nullable Double viewRef, boolean writeToDisk, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void queryTerrainElevation(@Nullable Double viewRef, ReadableArray coordinates, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void setSourceVisibility(@Nullable Double viewRef, boolean visible, String sourceId, String sourceLayerId, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void getCenter(@Nullable Double viewRef, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void getCoordinateFromView(@Nullable Double viewRef, ReadableArray atPoint, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void getPointInView(@Nullable Double viewRef, ReadableArray atCoordinate, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void getZoom(@Nullable Double viewRef, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void getVisibleBounds(@Nullable Double viewRef, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void queryRenderedFeaturesAtPoint(@Nullable Double viewRef, ReadableArray atPoint, ReadableArray withFilter, ReadableArray withLayerIDs, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void queryRenderedFeaturesInRect(@Nullable Double viewRef, ReadableArray withBBox, ReadableArray withFilter, ReadableArray withLayerIDs, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void setHandledMapChangedEvents(@Nullable Double viewRef, ReadableArray events, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void clearData(@Nullable Double viewRef, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void querySourceFeatures(@Nullable Double viewRef, String sourceId, ReadableArray withFilter, ReadableArray withSourceLayerIDs, Promise promise);
+}

package/ios/RCTMGL-v10/CustomHttpHeaders.swift

@@ -10,11 +10,20 @@ class CustomHttpHeaders : HttpServiceInterceptorInterface {
   var customHeaders : [String:String] = [:]
 
   func install() {
+    #if RNMBX_11
+    HttpServiceFactory.setHttpServiceInterceptorForInterceptor(self)
+    #else
     HttpServiceFactory.getInstance().setInterceptorForInterceptor(self)
+    #endif
   }
 
   func reset() {
+    #if RNMBX_11
+    HttpServiceFactory.setHttpServiceInterceptorForInterceptor(nil)
+    #else
     HttpServiceFactory.getInstance().setInterceptorForInterceptor(nil)
+
+    #endif
   }
 
   // MARK: - HttpServiceInterceptorInterface
@@ -36,4 +45,13 @@ class CustomHttpHeaders : HttpServiceInterceptorInterface {
   func onResponse(for response: HttpResponse) -> HttpResponse {
     return response
   }
+  
+  #if RNMBX_11
+  func onUpload(forUpload upload: UploadOptions) -> UploadOptions {
+    customHeaders.forEach {(key,value) in
+      upload.headers[key] = value
+    }
+    return upload
+  }
+  #endif
 }

package/ios/RCTMGL-v10/MBXMapViewComponentView.h

@@ -0,0 +1,18 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <UIKit/UIKit.h>
+
+#import <React/RCTUIManager.h>
+#import <React/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface MBXMapViewComponentView : RCTViewComponentView
+
+- (void)dispatchCameraChangedEvent:(NSDictionary*)event;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // RCT_NEW_ARCH_ENABLED

package/ios/RCTMGL-v10/MBXMapViewComponentView.mm

@@ -0,0 +1,203 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import "MBXMapViewComponentView.h"
+
+#import <React/RCTConversions.h>
+#import <React/RCTFabricComponentsPlugins.h>
+
+#import <react/renderer/components/rnmapbox_maps_specs/ComponentDescriptors.h>
+#import <react/renderer/components/rnmapbox_maps_specs/EventEmitters.h>
+#import <react/renderer/components/rnmapbox_maps_specs/Props.h>
+#import <react/renderer/components/rnmapbox_maps_specs/RCTComponentViewHelpers.h>
+// needed for compilation for some reason
+#import <CoreFoundation/CoreFoundation.h>
+#import <CoreLocation/CoreLocation.h>
+
+@interface MapView : UIView
+@end
+
+#import <rnmapbox_maps-Swift.h>
+
+using namespace facebook::react;
+
+@interface MBXMapViewComponentView () <RCTMBXMapViewViewProtocol>
+@end
+
+@interface MBXMapViewEventDispatcher : NSObject<RCTEventDispatcherProtocol>
+@end
+
+@implementation MBXMapViewEventDispatcher {
+    MBXMapViewComponentView* _componentView;
+}
+
+- (instancetype)initWithComponentView:(MBXMapViewComponentView*)componentView {
+    if (self = [super init]) {
+        _componentView = componentView;
+    }
+
+    return self;
+}
+
+- (void)sendEvent:(id<RCTEvent>)event {
+    NSDictionary* payload = [event arguments][2];
+    [_componentView dispatchCameraChangedEvent:payload];
+}
+
+@end
+
+@implementation MBXMapViewComponentView {
+    MBXMapView *_view;
+    MBXMapViewEventDispatcher *_eventDispatcher;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const MBXMapViewProps>();
+    _props = defaultProps;
+    _eventDispatcher = [[MBXMapViewEventDispatcher alloc] initWithComponentView:self];
+      _view =  [[MBXMapView alloc] initWithFrame:frame eventDispatcher:_eventDispatcher];
+      
+      // just need to pass something, it won't really be used on fabric, but it's used to create events (it won't impact sending them)
+      _view.reactTag = @-1;
+      
+      // capture weak self reference to prevent retain cycle
+      __weak __typeof__(self) weakSelf = self;
+      
+      [_view setReactOnPress:^(NSDictionary* event) {
+          __typeof__(self) strongSelf = weakSelf;
+
+          if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+              const auto [type, json] = [MBXMapViewComponentView stringifyEventData:event];
+              std::dynamic_pointer_cast<const facebook::react::MBXMapViewEventEmitter>(strongSelf->_eventEmitter)->onPress({type, json});
+            }
+      }];
+
+      [_view setReactOnLongPress:^(NSDictionary* event) {
+          __typeof__(self) strongSelf = weakSelf;
+
+          if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+              const auto [type, json] = [MBXMapViewComponentView stringifyEventData:event];
+              std::dynamic_pointer_cast<const facebook::react::MBXMapViewEventEmitter>(strongSelf->_eventEmitter)->onLongPress({type, json});
+            }
+      }];
+
+      [_view setReactOnMapChange:^(NSDictionary* event) {
+          __typeof__(self) strongSelf = weakSelf;
+
+          if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+              const auto [type, json] = [MBXMapViewComponentView stringifyEventData:event];
+              std::dynamic_pointer_cast<const facebook::react::MBXMapViewEventEmitter>(strongSelf->_eventEmitter)->onMapChange({type, json});
+            }
+      }];
+
+    self.contentView = _view;
+  }
+
+  return self;
+}
+
+- (void)dispatchCameraChangedEvent:(NSDictionary*)event {
+    const auto [type, json] = [MBXMapViewComponentView stringifyEventData:event];
+    std::dynamic_pointer_cast<const facebook::react::MBXMapViewEventEmitter>(self->_eventEmitter)->onCameraChanged({type, json});
+}
+
++ (std::tuple<std::string, std::string>)stringifyEventData:(NSDictionary*)event {
+    std::string type = [event valueForKey:@"type"] == nil ? "" : std::string([[event valueForKey:@"type"] UTF8String]);
+    std::string json = "{}";
+
+    NSError *error;
+    NSData *jsonData = nil;
+
+    if ([event valueForKey:@"payload"] != nil) {
+        jsonData = [NSJSONSerialization dataWithJSONObject:[event valueForKey:@"payload"]
+                                                           options:0
+                                                             error:&error];
+    }
+
+    if (jsonData) {
+        json = std::string([[[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding] UTF8String]);
+    }
+
+    return {type, json};
+}
+
+- (NSDictionary*)convertPositionToDictionary:(const folly::dynamic*)position {
+    NSMutableDictionary<NSString*, NSNumber*>* result = [[NSMutableDictionary alloc] init];
+
+    if (!position->isNull()) {
+        for (auto& pair : position->items()) {
+            NSString* key = [NSString stringWithUTF8String:pair.first.getString().c_str()];
+            NSNumber* value = [[NSNumber alloc] initWithInt:pair.second.getDouble()];
+            [result setValue:value forKey:key];
+        }
+    }
+
+    return result;
+}
+
+- (NSDictionary*)convertLocalizeLabels:(const MBXMapViewLocalizeLabelsStruct*)labels {
+    NSMutableDictionary* result = [[NSMutableDictionary alloc] init];
+    NSMutableArray* ids = [[NSMutableArray alloc] init];
+
+    [result setValue:[NSString stringWithUTF8String:labels->locale.c_str()] forKey:@"locale"];
+
+    for (auto& layerId : labels->layerIds) {
+        NSString* value = [NSString stringWithUTF8String:layerId.c_str()];
+        [ids addObject:value];
+    }
+
+    [result setValue:ids forKey:@"layerIds"];
+
+    return result;
+}
+
+
+#pragma mark - RCTComponentViewProtocol
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<MBXMapViewComponentDescriptor>();
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  const auto &newProps = *std::static_pointer_cast<const MBXMapViewProps>(props);
+    [_view setReactAttributionEnabled:newProps.attributionEnabled];
+    [_view setReactAttributionPosition:[self convertPositionToDictionary:&newProps.attributionPosition]];
+
+    [_view setReactLogoEnabled:newProps.logoEnabled];
+    [_view setReactLogoPosition:[self convertPositionToDictionary:&newProps.logoPosition]];
+
+    [_view setReactCompassEnabled:newProps.compassEnabled];
+    [_view setReactCompassFadeWhenNorth:newProps.compassFadeWhenNorth];
+    [_view setReactCompassPosition:[self convertPositionToDictionary:&newProps.compassPosition]];
+    [_view setReactCompassViewPosition:newProps.compassViewPosition];
+    [_view setReactCompassViewMargins:CGPointMake(newProps.compassViewMargins.x, newProps.compassViewMargins.y)];
+    [_view setReactCompassImage:[NSString stringWithUTF8String:newProps.compassImage.c_str()]];
+
+    [_view setReactScaleBarEnabled:newProps.scaleBarEnabled];
+    [_view setReactScaleBarPosition:[self convertPositionToDictionary:&newProps.scaleBarPosition]];
+
+    [_view setReactZoomEnabled:newProps.zoomEnabled];
+    [_view setReactScrollEnabled:newProps.scrollEnabled];
+    [_view setReactRotateEnabled:newProps.rotateEnabled];
+    [_view setReactPitchEnabled:newProps.pitchEnabled];
+
+    [_view setReactProjection:newProps.projection == MBXMapViewProjection::Mercator ? @"mercator" : @"globe"];
+    [_view setReactStyleURL:[NSString stringWithUTF8String:newProps.styleURL.c_str()]];
+
+    if (!newProps.localizeLabels.locale.empty()) {
+        [_view setReactLocalizeLabels:[self convertLocalizeLabels:&newProps.localizeLabels]];
+    }
+  [super updateProps:props oldProps:oldProps];
+}
+
+@end
+
+Class<RCTComponentViewProtocol> MBXMapViewCls(void)
+{
+  return MBXMapViewComponentView.class;
+}
+
+#endif // RCT_NEW_ARCH_ENABLED

package/ios/RCTMGL-v10/MBXMapViewManager.m

@@ -0,0 +1,37 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_REMAP_MODULE(MBXMapView, MBXMapViewManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(onCameraChanged, RCTDirectEventBlock)
+
+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(compassImage, reactCompassImage, NSString)
+
+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(projection, reactProjection, NSString)
+RCT_REMAP_VIEW_PROPERTY(localizeLabels, reactLocalizeLabels, NSDictionary)
+
+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)
+
+@end

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
+