@rnmapbox/maps 10.0.15 → 10.1.0-beta.10

package/ios/RNMBX/RNMBXMapViewModule.mm

@@ -0,0 +1,152 @@
+#import <React/RCTBridge.h>
+#import <React/RCTUIManager.h>
+#import <React/RCTUIManagerUtils.h>
+
+#import "RNMBXMapViewModule.h"
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "RNMBXMapViewComponentView.h"
+#endif // RCT_NEW_ARCH_ENABLED
+
+#import "rnmapbox_maps-Swift.pre.h"
+
+@implementation RNMBXMapViewModule
+
+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 (^)(RNMBXMapView *))block reject:(RCTPromiseRejectBlock)reject methodName:(NSString *)methodName
+{
+//    void (^upperBlock)(void) = ^{
+#ifdef RCT_NEW_ARCH_ENABLED
+    [self.viewRegistry_DEPRECATED addUIBlock:^(RCTViewRegistry *viewRegistry) {
+        RNMBXMapViewComponentView *componentView = [self.viewRegistry_DEPRECATED viewForReactTag:viewRef];
+        RNMBXMapView *view = componentView.contentView;
+        
+#else
+    [self.bridge.uiManager
+     addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        RNMBXMapView *view = [uiManager viewForReactTag:viewRef];
+#endif // RCT_NEW_ARCH_ENABLED
+        if (view != nil) {
+           block(view);
+        } else {
+            reject(methodName, [NSString stringWithFormat:@"Unknown reactTag: %@", viewRef], nil);
+        }
+    }];
+}
+
+
+RCT_EXPORT_METHOD(takeSnap:(nonnull NSNumber*)viewRef writeToDisk:(BOOL)writeToDisk resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+{
+    [self withMapView:viewRef block:^(RNMBXMapView *view) {
+        [RNMBXMapViewManager 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:^(RNMBXMapView *view) {
+        [RNMBXMapViewManager 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:^(RNMBXMapView *view) {
+        [RNMBXMapViewManager 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:^(RNMBXMapView *view) {
+        NSNumber* a = [atPoint objectAtIndex:0];
+        NSNumber* b = [atPoint objectAtIndex:1];
+        
+        [RNMBXMapViewManager 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:^(RNMBXMapView *view) {
+        [RNMBXMapViewManager 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:^(RNMBXMapView *view) {
+        [RNMBXMapViewManager 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:^(RNMBXMapView *view) {
+        [RNMBXMapViewManager 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:^(RNMBXMapView *view) {
+        [RNMBXMapViewManager 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:^(RNMBXMapView *view) {
+        [RNMBXMapViewManager 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:^(RNMBXMapView *view) {
+        [RNMBXMapViewManager 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:^(RNMBXMapView *view) {
+        [RNMBXMapViewManager 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:^(RNMBXMapView *view) {
+        [RNMBXMapViewManager 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:^(RNMBXMapView *view) {
+        [RNMBXMapViewManager 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/RNMBX/RNMBXMarkerView.swift

@@ -0,0 +1,266 @@
+import MapboxMaps
+import UIKit
+
+/// dummy parent of RNMBXMarkerView, so react-native changes visibility on RNMBXMarkerView,
+/// and Mapbox changes visibility on RNMBXMarkerViewParentViewAnnotation
+class RNMBXMarkerViewParentViewAnnotation : UIView {
+  required init(marker: RNMBXMarkerView) {
+    super.init(frame: marker.bounds)
+    insertSubview(marker, at: 0)
+  }
+  
+  required init?(coder: NSCoder) {
+    fatalError("not implented")
+  }
+
+  func remove(marker: RNMBXMarkerView) {
+    marker.removeFromSuperview()
+  }
+
+  func updateSize(_ size: CGSize, oldOffset: CGVector, newOffset: CGVector) {
+    let actSize = self.frame.size
+    if actSize.width != size.width || actSize.height != size.height {
+      let dx = ((size.width/2.0) - newOffset.dx) - ((actSize.width/2.0) - oldOffset.dx)
+      let dy = ((size.height/2.0) + newOffset.dy) - ((actSize.height/2.0) + oldOffset.dy)
+      print(" => size=\(size) actSize=\(actSize) newOffset=\(newOffset) oldOffset=\(oldOffset)  dx=\(dx) dy=\(dy)")
+      var frame = self.frame
+      frame = frame.offsetBy(dx: -dx, dy: -dy)
+      frame.size = size
+      self.frame = frame
+    }
+  }
+}
+
+class RNMBXMarkerView: UIView, RNMBXMapComponent {
+  // MARK: - Instance variables
+  
+  static let key = "RNMBXMarkerView"
+  let id: String = "marker-\(UUID().uuidString)"
+  
+  weak var map: RNMBXMapView?
+  weak var _annotationView: RNMBXMarkerViewParentViewAnnotation?
+  
+  var didAddToMap = false
+  
+  @objc var coordinate: String? {
+    didSet {
+      update()
+    }
+  }
+  
+  @objc var anchor: [String: NSNumber]? {
+    didSet {
+      update()
+    }
+  }
+  
+  @objc var allowOverlap: Bool = false {
+    didSet {
+      update()
+    }
+  }
+  
+  @objc var isSelected: Bool = false {
+    didSet {
+      update()
+    }
+  }
+
+  // MARK: - Derived variables
+  
+  var annotationManager: ViewAnnotationManager? {
+    self.map?.viewAnnotations
+  }
+
+  var point: Point? {
+    guard let _coordinate = coordinate else {
+      Logger.log(level: .error, message: "[getPoint] No coordinates were set")
+      return nil
+    }
+     
+    guard let _data = _coordinate.data(using: .utf8) else {
+      Logger.log(level: .error, message: "[getPoint] Cannot serialize coordinate")
+      return nil
+    }
+     
+    guard let _feature = try? JSONDecoder().decode(Feature.self, from: _data) else {
+      Logger.log(level: .error, message: "[getPoint] Cannot parse serialized coordinate")
+      return nil
+    }
+     
+    guard let _geometry = _feature.geometry else {
+      Logger.log(level: .error, message: "[getPoint] Invalid geometry")
+      return nil
+    }
+
+    guard case .point(let _point) = _geometry else {
+      Logger.log(level: .error, message: "[getPoint] Invalid point")
+      return nil
+    }
+
+    return _point
+  }
+
+  // MARK: - RNMBXMapComponent methods
+
+  func addToMap(_ map: RNMBXMapView, style: Style) {
+    self.map = map
+    add()
+  }
+
+  func removeFromMap(_ map: RNMBXMapView, reason: RemovalReason) -> Bool {
+    remove()
+    return true
+  }
+  
+  // MARK: - React methods
+  
+  override var isHidden: Bool {
+    get {
+      return super.isHidden
+    }
+    set {
+      super.isHidden = newValue
+    }
+  }
+  
+  override func reactSetFrame(_ frame: CGRect) {
+    let prev = self.frame
+    var next = frame
+    
+    let frameDidChange = !next.equalTo(prev)
+    if frameDidChange {
+      next = CGRect(
+        x: 0,
+        y: 0,
+        width: next.width,
+        height: next.height
+      )
+    }
+
+    super.reactSetFrame(next)
+    if frameDidChange {
+      annotationView.updateSize(next.size, oldOffset:calcOffset(size: prev.size), newOffset: calcOffset(size: next.size))
+    }
+    addOrUpdate()
+  }
+  
+  override func insertReactSubview(_ subview: UIView, at atIndex: Int) {
+    super.insertReactSubview(subview, at: atIndex)
+  }
+  
+  override func removeReactSubview(_ subview: UIView) {
+    super.removeReactSubview(subview)
+  }
+  
+  func waitForStyleLoad() -> Bool {
+    true
+  }
+
+  // MARK: - Create, update, and remove methods
+
+    private func addOrUpdate() {
+      if didAddToMap {
+        update()
+      } else {
+        add()
+      }
+    }
+  
+  /// Because the necessary data to add an annotation arrives from different sources at unpredictable times, we let the arrival of each value trigger an attempt to add the annotation, which we only do if all of the data exists, and the annotation not been added already.
+  private func add() {
+    if didAddToMap {
+      return
+    }
+    
+    guard let annotationManager = annotationManager, let _ = point else {
+      return
+    }
+
+    do {
+      let options = getOptions()
+      try annotationManager.add(annotationView, id: id, options: options)
+      didAddToMap = true
+    } catch {
+      Logger.log(level: .error, message: "[MarkerView] Error adding annotation", error: error)
+    }
+  }
+
+  private func update() {
+    if !didAddToMap {
+      return
+    }
+    
+    guard let annotationManager = annotationManager else {
+      return
+    }
+    
+    do {
+      let options = getOptions()
+      try annotationManager.update(annotationView, options: options)
+    } catch {
+      Logger.log(level: .error, message: "[MarkerView] Error updating annotation", error: error)
+    }
+  }
+  
+  private func remove() {
+    annotationManager?.remove(annotationView)
+    annotationView.remove(marker: self)
+    self._annotationView = nil
+    didAddToMap = false
+  }
+  
+  // MARK: - Helper functions
+  
+  private func getOptions() -> ViewAnnotationOptions {
+    var geometry: GeometryConvertible?
+    if let point = point {
+      geometry = Geometry.point(point)
+    }
+    
+    let size = self.bounds.size
+    let offset = calcOffset(size: size)
+  
+    let options = ViewAnnotationOptions(
+      geometry: geometry,
+      width: size.width,
+      height: size.height,
+      allowOverlap: allowOverlap,
+      offsetX: offset.dx,
+      offsetY: offset.dy,
+      selected: isSelected
+    )
+    return options
+  }
+  
+  private func calcOffset(size: CGSize) -> CGVector {
+    guard let anchor = anchor, let anchorX = anchor["x"]?.CGFloat, let anchorY = anchor["y"]?.CGFloat else {
+      return .zero
+    }
+          
+    let x = (anchorX * 2 - 1) * (size.width / 2) * -1
+    let y = (anchorY * 2 - 1) * (size.height / 2)
+
+    return CGVector(dx: x, dy: y)
+  }
+  
+  var annotationView : RNMBXMarkerViewParentViewAnnotation {
+    if let result = _annotationView {
+      return result
+    }
+    let result = RNMBXMarkerViewParentViewAnnotation(marker: self)
+    _annotationView = result
+    return result
+  }
+
+  @objc override func didMoveToSuperview() {
+    // React tends to add back us to our original superview,
+    // https://github.com/facebook/react-native/blob/11ece22fc6955d169def9ef9f2809c24bc457ba8/React/Views/UIView%2BReact.m#L172-L177
+    // fix that if we see that
+    if let expectedParent = _annotationView {
+      if superview != nil && superview != expectedParent {
+        expectedParent.addSubview(self)
+      }
+    }
+  }
+}

package/ios/RNMBX/RNMBXMarkerViewManager.m

@@ -0,0 +1,12 @@
+#import "React/RCTBridgeModule.h"
+#import <React/RCTViewManager.h>
+#import <Foundation/Foundation.h>
+
+@interface RCT_EXTERN_REMAP_MODULE(RNMBXMarkerView, RNMBXMarkerViewManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(coordinate, NSString)
+RCT_EXPORT_VIEW_PROPERTY(anchor, NSDictionary)
+RCT_EXPORT_VIEW_PROPERTY(allowOverlap, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(isSelected, BOOL)
+
+@end

package/ios/RNMBX/RNMBXMarkerViewManager.swift

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

package/ios/RNMBX/RNMBXModule.m

@@ -0,0 +1,14 @@
+#import "React/RCTBridgeModule.h"
+
+@interface RCT_EXTERN_MODULE(RNMBXModule, NSObject)
+
+RCT_EXTERN_METHOD(setAccessToken:(NSString *)accessToken resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(addCustomHeader:(NSString *)headerName forHeaderValue:(NSString *) headerValue)
+RCT_EXTERN_METHOD(removeCustomHeader:(NSString *)headerName)
+
+RCT_EXTERN_METHOD(setTelemetryEnabled:(BOOL)telemetryEnabled)
+RCT_EXTERN_METHOD(setWellKnownTileServer:(NSString *)tileServer)
+
+
+@end

package/ios/RNMBX/RNMBXModule.swift

@@ -0,0 +1,116 @@
+import Foundation
+import MapboxMaps
+#if canImport(MapboxMobileEvents)
+import MapboxMobileEvents
+#endif
+
+
+let DEFAULT_SOURCE_ID = "composite";
+
+@objc(RNMBXModule)
+class RNMBXModule : NSObject {
+  #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]! {
+    return [
+      "MapboxV10":true,
+      "StyleURL":
+        [
+          "Street": StyleURI.streets.rawValue,
+          "Outdoors": StyleURI.outdoors.rawValue,
+          "Light": StyleURI.light.rawValue,
+          "Dark": StyleURI.dark.rawValue,
+          "Satellite": StyleURI.satellite.rawValue,
+          "SatelliteStreet": StyleURI.satelliteStreets.rawValue,
+        ],
+      "OfflinePackDownloadState":
+        [
+          "Inactive": RNMBXOfflineModule.State.inactive.rawValue,
+          "Active": RNMBXOfflineModule.State.active.rawValue,
+          "Complete": RNMBXOfflineModule.State.complete.rawValue,
+          "Unknown": RNMBXOfflineModule.State.unknown.rawValue,
+        ],
+      "StyleSource":
+        ["DefaultSourceID": DEFAULT_SOURCE_ID],
+      "LineJoin":
+        [
+          "Bevel": LineJoin.bevel.rawValue,
+          "Round": LineJoin.round.rawValue,
+          "Miter": LineJoin.miter.rawValue,
+        ],
+      "LocationCallbackName":
+        ["Update": RCT_MAPBOX_USER_LOCATION_UPDATE],
+      "CameraModes":
+        [
+          "Flight": CameraMode.flight.rawValue,
+          "Ease": CameraMode.ease.rawValue,
+          "Linear": CameraMode.linear.rawValue,
+          "Move": CameraMode.none.rawValue
+        ],
+      "EventTypes":
+        [
+          "RegionIsChanging" : RNMBXEvent.EventType.regionIsChanging.rawValue,
+          "RegionDidChange" : RNMBXEvent.EventType.regionDidChange.rawValue,
+          "CameraChanged" : RNMBXEvent.EventType.cameraChanged.rawValue,
+          "MapIdle" : RNMBXEvent.EventType.mapIdle.rawValue,
+          "WillStartLoadingMap": RNMBXEvent.EventType.willStartLoadingMap.rawValue,
+          "DidFinishLoadingStyle": RNMBXEvent.EventType.didFinishLoadingStyle.rawValue,
+          "DidFinishLoadingMap": RNMBXEvent.EventType.didFinishLoadingMap.rawValue,
+          "MapLoadingError": RNMBXEvent.EventType.mapLoadingError.rawValue,
+          "DidFinishRenderingFrameFully":  RNMBXEvent.EventType.didFinishRenderingFully.rawValue,
+          "DidFinishRenderingFrame": RNMBXEvent.EventType.didFinishRendering.rawValue,
+        ],
+      "OfflineCallbackName":
+        [
+          "Error": RNMBXOfflineModule.Callbacks.error.rawValue,
+          "Progress": RNMBXOfflineModule.Callbacks.progress.rawValue
+        ],
+      "TileServers":
+        ["Mapbox": "mapbox"]
+    ];
+  }
+
+  @objc
+  static func requiresMainQueueSetup() -> Bool {
+      return true
+  }
+
+  @objc func setAccessToken(
+    _ token: String, 
+    resolver: RCTPromiseResolveBlock,
+    rejecter: RCTPromiseRejectBlock) {
+      RNMBXModule.accessToken = token
+      resolver(token)
+  }
+
+  @objc func addCustomHeader(_ headerName: String, forHeaderValue headerValue: String ) {
+    CustomHttpHeaders.shared.customHeaders[headerName] = headerValue
+  }
+
+  @objc func removeCustomHeader(_ headerName: String) {
+    CustomHttpHeaders.shared.customHeaders[headerName] = nil
+  }
+  
+  @objc func setTelemetryEnabled(_ telemetryEnabled: Bool) {
+    #if !RNMBX_11 // RNMBX_11_TODO
+    UserDefaults.mme_configuration().mme_isCollectionEnabled = telemetryEnabled
+    #endif
+  }
+
+  @objc func setWellKnownTileServer(_ tileServer: String) {
+    if tileServer != "mapbox" {
+      Logger.error("setWellKnownTileServer: \(tileServer) should be mapbox")
+    }
+  }
+}

package/ios/RNMBX/RNMBXNativeUserLocation.swift

@@ -0,0 +1,52 @@
+import MapboxMaps
+
+@objc
+class RNMBXNativeUserLocation : UIView, RNMBXMapComponent {
+  weak var map : RNMBXMapView! = nil
+  
+  let locationLayerId = "location-layer"
+
+  var locationLayer : LocationIndicatorLayer? = nil
+
+  @objc
+  var iosShowsUserHeadingIndicator : Bool = false {
+    didSet {
+      if let map = self.map { _applySettings(map) }
+    }
+  }
+  
+  func _applySettings(_ map: RNMBXMapView) {
+    map.location.options.puckType = .puck2D(.makeDefault(showBearing: iosShowsUserHeadingIndicator))
+    if (iosShowsUserHeadingIndicator) {
+      #if RNMBX_11
+      map.location.options.puckBearing = .heading
+      #else
+      map.location.options.puckBearingSource = .heading
+      #endif
+      map.location.options.puckBearingEnabled = true
+    } else {
+      map.location.options.puckBearingEnabled = false
+    }
+  }
+
+  func addToMap(_ map: RNMBXMapView, style: Style) {
+    self.map = map
+    _applySettings(map)
+  }
+
+  func removeFromMap(_ map: RNMBXMapView, reason: RemovalReason) -> Bool {
+    map.location.options.puckType = nil
+    guard let mapboxMap = map.mapboxMap else {
+      return true
+    }
+    let style = mapboxMap.style
+    map.location.options.puckType = .none
+    self.map = nil
+
+    return true
+  }
+  
+  func waitForStyleLoad() -> Bool {
+    return true
+  }
+}

package/ios/RNMBX/RNMBXNativeUserLocationManager.m

@@ -0,0 +1,9 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_MODULE(RNMBXNativeUserLocationManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(iosShowsUserHeadingIndicator, BOOL);
+
+@end
+

package/ios/RNMBX/RNMBXNativeUserLocationManager.swift

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

package/ios/RNMBX/RNMBXOfflineModule.m

@@ -0,0 +1,34 @@
+#import "React/RCTBridgeModule.h"
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(RNMBXOfflineModule, RCTEventEmitter<RCTBridgeModule>)
+
+RCT_EXTERN_METHOD(getPacks:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(createPack:(NSDictionary *) options resolver: (RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(resumePackDownload:(NSString *)name
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(pausePackDownload:(NSString *)name
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(setTileCountLimit:(nonnull NSNumber *)limit)
+
+RCT_EXTERN_METHOD(setProgressEventThrottle:(nonnull NSNumber *)throttleValue)
+
+RCT_EXTERN_METHOD(getPackStatus:(NSString *)name
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+
+RCT_EXTERN_METHOD(deletePack:(NSString *)name
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(migrateOfflineCache:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(resetDatabase:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+
+@end