@rnmapbox/maps 10.0.0-beta.62 → 10.0.0-beta.65

package/android/install.md

@@ -4,7 +4,7 @@
 
   - mapbox: v10 latest mapbox implementation - *recommended*, not opensource requires access for download
   - maplibre: *DEFAULT* open source fork of older open source mapbox libraries with many improvements, will be removed in next version
-  - mapbox-gl: classic mapbox libraries - should work but will be dropped, recent versions are not open source and requires acess for download, will be removed in next version
+  - mapbox-gl: classic mapbox libraries - should work but will be dropped, recent versions are not open source and requires access for download, will be removed in next version
 
 ## Mapbox Maps SDK v10
 

package/android/rctmgl/.settings/org.eclipse.buildship.core.prefs

@@ -1,2 +1,13 @@
-connection.project.dir=../../example/android
+arguments=--init-script /var/folders/nf/xt27lc4j4sv73tqskhkd_8xc0000gn/T/d146c9752a26f79b52047fb6dc6ed385d064e120494f96f08ca63a317c41f94c.gradle --init-script /var/folders/nf/xt27lc4j4sv73tqskhkd_8xc0000gn/T/52cde0cfcf3e28b8b7510e992210d9614505e0911af0c190bd590d7158574963.gradle
+auto.sync=false
+build.scans.enabled=false
+connection.gradle.distribution=GRADLE_DISTRIBUTION(VERSION(7.4.2))
+connection.project.dir=
 eclipse.preferences.version=1
+gradle.user.home=
+java.home=/Library/Java/JavaVirtualMachines/jdk-11.0.14.jdk/Contents/Home
+jvm.arguments=
+offline.mode=false
+override.workspace.settings=true
+show.console.view=true
+show.executions.view=true

package/android/rctmgl/src/main/java-mapboxgl/common/com/mapbox/rctmgl/modules/RCTMGLLocationModule.java

@@ -94,6 +94,11 @@ public class RCTMGLLocationModule extends ReactContextBaseJavaModule {
         }
     }
 
+    @ReactMethod
+    public void setRequestsAlwaysUse(boolean requestsAlwaysUse) {
+        // IOS only. Ignored on Android.
+    }
+
     @ReactMethod
     public void stop() {
         stopLocationManager();

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/mapview/RCTMGLMapView.kt

@@ -733,19 +733,23 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
     }
 
     fun queryRenderedFeaturesAtPoint(callbackID: String?, point: PointF, filter: Expression?, layerIDs: List<String>?) {
-        mMap?.queryRenderedFeatures(
-            ScreenCoordinate(point.x.toDouble(), point.y.toDouble()),
-            RenderedQueryOptions(layerIDs, filter)
-        ) { features ->
+        if (mMap == null) {
+            Logger.e("queryRenderedFeaturesAtPoint", "mapbox map is null")
+            return
+        }
+        val screenCoordinate = ScreenCoordinate(point.x.toDouble(), point.y.toDouble())
+        val queryGeometry = RenderedQueryGeometry(screenCoordinate)
+        val layers = layerIDs?.takeUnless { it.isEmpty() } ?: null;
+        val queryOptions = RenderedQueryOptions(layers, filter)
+        mMap.queryRenderedFeatures(queryGeometry, queryOptions) { features ->
             if (features.isValue) {
                 val featuresList = ArrayList<Feature?>()
                 for (i in features.value!!) {
                     featuresList.add(i.feature)
                 }
-
-                sendResponse(callbackID, {
+                sendResponse(callbackID) {
                     it.putString("data", FeatureCollection.fromFeatures(featuresList).toJson())
-                })
+                }
             } else {
                 Logger.e("queryRenderedFeaturesAtPoint", features.error ?: "n/a")
             }

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/styles/sources/RCTMGLVectorSource.java

@@ -73,9 +73,6 @@ public class RCTMGLVectorSource extends RCTMGLTileSource<VectorSource> {
             return;
         }
 
-
-        WritableMap payload = new WritableNativeMap();
-
         mMap.querySourceFeatures(
                 getID(),
                 new SourceQueryOptions(layerIDs, filter),
@@ -83,6 +80,7 @@ public class RCTMGLVectorSource extends RCTMGLTileSource<VectorSource> {
                 new QueryFeaturesCallback() {
                     @Override
                     public void run(@NonNull Expected<String, List<QueriedFeature>> queriedFeatures) {
+                        WritableMap payload = new WritableNativeMap();
                         if (queriedFeatures.isError()) {
                             //V10todo
                             payload.putString("error", queriedFeatures.getError());
@@ -93,11 +91,10 @@ public class RCTMGLVectorSource extends RCTMGLTileSource<VectorSource> {
                             }
                             payload.putString("data", FeatureCollection.fromFeatures(features).toJson());
                         }
+                        AndroidCallbackEvent event = new AndroidCallbackEvent(RCTMGLVectorSource.this, callbackID, payload);
+                        mManager.handleEvent(event);
                     }
                 }
         );
-
-        AndroidCallbackEvent event = new AndroidCallbackEvent(this, callbackID, payload);
-        mManager.handleEvent(event);
     }
 }

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/modules/RCTMGLLocationModule.kt

@@ -87,6 +87,11 @@ class RCTMGLLocationModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    @ReactMethod
+    fun setRequestsAlwaysUse(requestsAlwaysUse: Boolean) {
+        // IOS only. Ignored on Android.
+    }
+
     @ReactMethod
     fun stop() {
         stopLocationManager()

package/index.d.ts

@@ -612,6 +612,7 @@ export interface UserLocationProps {
   animated?: boolean;
   children?: ReactNode;
   minDisplacement?: number;
+  requestsAlwaysUse?: boolean;
   onPress?: () => void;
   onUpdate?: (location: MapboxGL.Location) => void;
   renderMode?: 'normal' | 'native';

package/ios/RCTMGL-v10/RCTMGLCamera.swift

@@ -123,28 +123,35 @@ class RCTMGLCamera : RCTMGLMapComponentBase, LocationConsumer {
       _updateCameraFromTrackingMode()
     }
   }
+
   @objc var followUserMode: String? {
     didSet {
       _updateCameraFromTrackingMode()
     }
   }
+
   @objc var followUserLocation : Bool = false {
     didSet {
       _updateCameraFromTrackingMode()
     }
   }
+
   @objc var followZoomLevel: NSNumber? {
     didSet {
       _updateCameraFromTrackingMode()
     }
   }
+
   @objc var maxZoomLevel: NSNumber? {
     didSet { _updateMaxBounds() }
   }
+
   @objc var minZoomLevel: NSNumber? {
     didSet { _updateMaxBounds() }
   }
+
   @objc var onUserTrackingModeChange: RCTBubblingEventBlock? = nil
+
   @objc var stop: [String: Any]? {
     didSet {
       _updateCamera()
@@ -319,6 +326,7 @@ class RCTMGLCamera : RCTMGLMapComponentBase, LocationConsumer {
       }
       let followState = map.viewport.makeFollowPuckViewportState(options: followOptions)
       map.viewport.transition(to: followState)
+      map.viewport.addStatusObserver(self)
       map.mapboxMap.setCamera(to: _camera)
     }
   }
@@ -468,6 +476,11 @@ class RCTMGLCamera : RCTMGLMapComponentBase, LocationConsumer {
     map.reactCamera = self
   }
   
+  override func removeFromMap(_ map: RCTMGLMapView) {
+    map.viewport.removeStatusObserver(self)
+    super.removeFromMap(map)
+  }
+
   // MARK: - LocationConsumer
   
   func locationUpdate(newLocation: Location) {
@@ -495,6 +508,106 @@ class RCTMGLCamera : RCTMGLMapComponentBase, LocationConsumer {
   }
 }
 
+// MARK: - ViewportStatusObserver
+
+extension RCTMGLCamera : ViewportStatusObserver {
+  func toDict(_ status: ViewportStatus) -> [String: Any] {
+    switch (status) {
+    case .idle:
+      return ["state":"idle"]
+    case .state(let state):
+      return ["state":String(describing: type(of: state))]
+    case .transition(let transition, toState: let toState):
+      return [
+        "transition": String(describing: type(of: transition)),
+        "state":String(describing: type(of: toState))
+      ]
+    }
+  }
+
+  func toFollowUserLocation(_ status: ViewportStatus) -> Bool {
+    switch status {
+    case .idle:
+      return false
+    case .state(_):
+      return true
+    case .transition(_, toState: _):
+      return true
+    }
+  }
+
+  func toFollowUserMode(_ state: ViewportState) -> String? {
+    if let state = state as? FollowPuckViewportState {
+      switch state.options.bearing {
+      case .heading:
+        return "compass"
+      case .course:
+        return "course"
+      case .some(let bearing):
+        return "constant"
+      case .none:
+        return "normal"
+      }
+    } else if let state = state as? OverviewViewportState {
+      return "overview"
+    } else {
+      return "custom"
+    }
+  }
+
+  func toFollowUserMode(_ status: ViewportStatus) -> String? {
+    switch status {
+    case .idle:
+      return nil
+    case .state(let state):
+      return toFollowUserMode(state)
+    case .transition(_, toState: let state):
+      return toFollowUserMode(state)
+    }
+  }
+
+  func toString(_ reason: ViewportStatusChangeReason) -> String {
+    if reason == .idleRequested {
+      return "idleRequested"
+    } else if reason == .transitionFailed {
+      return "transitionFailied"
+    } else if reason == .transitionStarted {
+      return "transitionStarted"
+    } else if reason == .transitionSucceeded {
+      return "transitionSucceeded"
+    } else if reason == .userInteraction {
+      return "userInteraction"
+    } else {
+      return "unkown \(reason)"
+    }
+  }
+
+  func viewportStatusDidChange(from fromStatus: ViewportStatus,
+                               to toStatus: ViewportStatus,
+                               reason: ViewportStatusChangeReason)
+  {
+    if (reason == .userInteraction) {
+      followUserLocation = toFollowUserLocation(toStatus)
+
+      if let onUserTrackingModeChange = onUserTrackingModeChange {
+        let event = RCTMGLEvent(
+          type: .onUserTrackingModeChange,
+          payload: [
+            "followUserMode": toFollowUserMode(toStatus) as Any,
+            "followUserLocation": followUserLocation,
+            "fromViewportStatus": toDict(fromStatus),
+            "toViewportState": toDict(toStatus),
+            "reason": toString(reason)
+          ]
+        )
+
+        onUserTrackingModeChange(event.toJSON())
+      }
+    }
+  }
+}
+
 private func toSeconds(_ ms: Double) -> TimeInterval {
   return ms * 0.001
 }
+

package/ios/RCTMGL-v10/RCTMGLLocationModule.m

@@ -10,6 +10,7 @@ RCT_EXTERN_METHOD(stop)
 RCT_EXTERN_METHOD(getLastKnownLocation)
 
 RCT_EXTERN_METHOD(setMinDisplacement:(CLLocationDistance)minDisplacement)
+RCT_EXTERN_METHOD(setRequestsAlwaysUse:(BOOL)requestsAlwaysUse)
 
 
 @end

package/ios/RCTMGL-v10/RCTMGLLocationModule.swift

@@ -7,6 +7,8 @@ class RCTMGLLocation: NSObject {
   
   var heading : CLHeading? = nil
 
+  var timestamp: Date? = nil
+
   func toJSON() -> [String:Any] {
     return [
       "coords": [
@@ -18,7 +20,7 @@ class RCTMGLLocation: NSObject {
         "course": location.course,
         "speed": location.speed,
       ],
-      "timestamp": location.timestamp.timeIntervalSince1970 * 1000
+      "timestamp": (timestamp ?? location.timestamp).timeIntervalSince1970 * 1000
     ]
   }
 }
@@ -41,16 +43,20 @@ protocol RCTMGLLocationManagerDelegate : AnyObject {
 }
 
 class RCTMGLLocationManager : LocationProviderDelegate {
+  enum LocationUpdateType {
+    case heading
+    case location
+  }
+
   var provider: LocationProvider
   
   var lastKnownLocation : CLLocation?
   var lastKnownHeading : CLHeading?
+  var shouldRequestAlwaysAuthorization: Bool?
   
   weak var delegate: RCTMGLLocationManagerDelegate?
   weak var locationProviderDelage: LocationProviderDelegate?
   
-  var listeners: [RCTMGLLocationBlock] = []
-  
   init() {
     provider = AppleLocationProvider()
     provider.setDelegate(self)
@@ -62,8 +68,14 @@ class RCTMGLLocationManager : LocationProviderDelegate {
     provider.locationProviderOptions = options
   }
   
+  func setRequestsAlwaysUse(_ requestsAlwaysUse: Bool) {
+    shouldRequestAlwaysAuthorization = requestsAlwaysUse;
+  }
+
   func start() {
-    provider.requestAlwaysAuthorization()
+    if shouldRequestAlwaysAuthorization == true {
+      provider.requestAlwaysAuthorization()
+    }
     provider.requestWhenInUseAuthorization()
     provider.setDelegate(self)
     provider.startUpdatingHeading()
@@ -76,7 +88,7 @@ class RCTMGLLocationManager : LocationProviderDelegate {
     provider.setDelegate(EmptyLocationProviderDelegate())
   }
   
-  func _convertToMapboxLocation(_ location: CLLocation?) -> RCTMGLLocation {
+  func _convertToMapboxLocation(_ location: CLLocation?, type: LocationUpdateType) -> RCTMGLLocation {
     guard let location = location else {
       return RCTMGLLocation()
     }
@@ -84,19 +96,22 @@ class RCTMGLLocationManager : LocationProviderDelegate {
     let userLocation = RCTMGLLocation()
     userLocation.location = location;
     userLocation.heading = lastKnownHeading
+    switch type {
+    case .location:
+      userLocation.timestamp = location.timestamp
+    case .heading:
+      userLocation.timestamp = lastKnownHeading!.timestamp
+    }
     return userLocation;
   }
   
-  func _updateDelegate() {
+  func _updateDelegate(type: LocationUpdateType) {
     if delegate == nil {
       return;
     }
 
-    let userLocation = _convertToMapboxLocation(lastKnownLocation)
+    let userLocation = _convertToMapboxLocation(lastKnownLocation, type: type)
 
-    for listener in listeners {
-      listener(userLocation)
-    }
     delegate?.locationManager(self, didUpdateLocation: userLocation)
   }
   
@@ -104,14 +119,14 @@ class RCTMGLLocationManager : LocationProviderDelegate {
   
   func locationProvider(_ provider: LocationProvider, didUpdateLocations locations: [CLLocation]) {
     lastKnownLocation = locations.last
-    self._updateDelegate()
+    self._updateDelegate(type: .location)
     
     locationProviderDelage?.locationProvider(provider, didUpdateLocations: locations)
   }
   
   func locationProvider(_ provider: LocationProvider, didUpdateHeading newHeading: CLHeading) {
     lastKnownHeading = newHeading
-    self._updateDelegate()
+    self._updateDelegate(type: .heading)
     
     locationProviderDelage?.locationProvider(provider, didUpdateHeading: newHeading)
   }
@@ -233,9 +248,7 @@ class RCTMGLLocationModule: RCTEventEmitter, RCTMGLLocationManagerDelegate {
   
   @objc
   override func constantsToExport() -> [AnyHashable: Any]! {
-    return [
-      "foo": "bar"
-    ];
+    return [:];
   }
 
   @objc override func supportedEvents() -> [String]
@@ -260,6 +273,10 @@ class RCTMGLLocationModule: RCTEventEmitter, RCTMGLLocationManagerDelegate {
     locationManager.setDistanceFilter(minDisplacement)
   }
   
+  @objc func setRequestsAlwaysUse(_ requestsAlwaysUse: Bool) {
+    locationManager.setRequestsAlwaysUse(requestsAlwaysUse);
+  }
+
   @objc
   override func startObserving() {
     super.startObserving()
@@ -272,7 +289,6 @@ class RCTMGLLocationModule: RCTEventEmitter, RCTMGLLocationManagerDelegate {
     hasListener = false
   }
   
-  
   func locationManager(_ locationManager: RCTMGLLocationManager, didUpdateLocation location: RCTMGLLocation) {
     guard hasListener else {
       return
@@ -281,8 +297,7 @@ class RCTMGLLocationModule: RCTEventEmitter, RCTMGLLocationManagerDelegate {
     guard let _ = bridge else {
       return
     }
-   
+
     self.sendEvent(withName: RCT_MAPBOX_USER_LOCATION_UPDATE, body: location.toJSON())
   }
-
 }

package/ios/RCTMGL-v10/RCTMGLMapView.swift

@@ -33,7 +33,9 @@ open class RCTMGLMapView : MapView {
   var layerWaiters : [String:[(String) -> Void]] = [:]
   
   lazy var pointAnnotationManager : PointAnnotationManager = {
-    return PointAnnotationManager(annotations: annotations, mapView: mapView)
+    let result = PointAnnotationManager(annotations: annotations, mapView: mapView)
+    self._removeMapboxLongPressGestureRecognizer()
+    return result
   }()
 
   lazy var calloutAnnotationManager : MapboxMaps.PointAnnotationManager = {
@@ -221,8 +223,8 @@ open class RCTMGLMapView : MapView {
     }
   }
   
-  @objc func setReactCompassViewPosition(_ position: NSNumber) {
-    mapView.ornaments.options.compass.position = toOrnamentPositon(Int(truncating: position))
+  @objc func setReactCompassViewPosition(_ position: NSInteger) {
+    mapView.ornaments.options.compass.position = toOrnamentPositon(Int(truncating: NSNumber(value: position)))
   }
   
   @objc func setReactCompassViewMargins(_ margins: CGPoint) {
@@ -329,6 +331,14 @@ open class RCTMGLMapView : MapView {
     
     return nil
   }
+
+  func _removeMapboxLongPressGestureRecognizer() {
+    mapView.gestureRecognizers?.forEach { recognizer in
+      if (String(describing: type(of:recognizer)) == "MapboxLongPressGestureRecognizer") {
+        mapView.removeGestureRecognizer(recognizer)
+      }
+    }
+  }
 }
 
 // MARK: - event handlers
@@ -992,23 +1002,16 @@ class PointAnnotationManager : AnnotationInteractionDelegate {
               }
 
       case .changed:
-          guard let annotation = self.draggedAnnotation else {
+          guard var annotation = self.draggedAnnotation else {
               return
           }
         
           self.onDragHandler(self.manager, didDetectDraggedAnnotations: [annotation], dragState: .changed, targetPoint: targetPoint)
 
-          // For some reason Mapbox doesn't let us update the geometry of an existing annotation
-          // so we have to create a whole new one.
-          var newAnnotation = PointAnnotation(id: annotation.id, coordinate: targetPoint)
-          newAnnotation.image = annotation.image
-          newAnnotation.userInfo = annotation.userInfo
-          
-          var newAnnotations = self.manager.annotations.filter { an in
-              return an.id != annotation.id
+          let idx = self.manager.annotations.firstIndex { an in return an.id == annotation.id }
+          if let idx = idx {
+            self.manager.annotations[idx].point = Point(targetPoint)
           }
-          newAnnotations.append(newAnnotation)
-          manager.annotations = newAnnotations
       case .cancelled, .ended:
         guard let annotation = self.draggedAnnotation else {
             return
@@ -1023,7 +1026,6 @@ class PointAnnotationManager : AnnotationInteractionDelegate {
       }
   }
   
-  
   func remove(_ annotation: PointAnnotation) {
     manager.annotations.removeAll(where: {$0.id == annotation.id})
   }
@@ -1032,15 +1034,16 @@ class PointAnnotationManager : AnnotationInteractionDelegate {
     manager.annotations.append(annotation)
     manager.syncSourceAndLayerIfNeeded()
   }
-
-  func refresh(_ annotation: PointAnnotation) {
+  
+  func update(_ annotation: PointAnnotation) {
     let index = manager.annotations.firstIndex { $0.id == annotation.id }
-    if let index = index {
-      manager.annotations[index] = annotation
-      manager.syncSourceAndLayerIfNeeded()
-    } else {
-      Logger.log(level: .warn, message: "RCTMGL - PointAnnotation.refresh: expected annotation already there - adding")
-      add(annotation)
+    
+    guard let index = index else {
+      Logger.log(level: .warn, message: "RCTMGL - PointAnnotation.refresh: annotation not found")
+      return
     }
+    
+    manager.annotations[index] = annotation
+    manager.syncSourceAndLayerIfNeeded()
   }
 }

package/ios/RCTMGL-v10/RCTMGLMapViewManager.swift

@@ -29,7 +29,7 @@ extension RCTMGLMapViewManager {
       self.bridge.uiManager.addUIBlock { (manager, viewRegistry) in
         let view = viewRegistry![reactTag]
 
-        guard let view = view! as? RCTMGLMapView else {
+        guard let view = view, let view = view as? RCTMGLMapView else {
           RCTMGLLogError("Invalid react tag, could not find RCTMGLMapView");
           rejecter(name, "Unknown find reactTag: \(reactTag)", nil)
           return;
@@ -188,7 +188,7 @@ extension RCTMGLMapViewManager {
         let point = CGPoint(x: CGFloat(point[0].floatValue), y: CGFloat(point[1].floatValue))
 
         logged("queryRenderedFeaturesAtPoint.option", rejecter: rejecter) {
-          let options = try RenderedQueryOptions(layerIds: layerIDs, filter: filter?.asExpression())
+          let options = try RenderedQueryOptions(layerIds: (layerIDs ?? []).isEmpty ? nil : layerIDs, filter: filter?.asExpression())
           
           mapboxMap.queryRenderedFeatures(with: point, options: options) { result in
             switch result {

package/ios/RCTMGL-v10/RCTMGLMarkerView.swift

@@ -195,6 +195,7 @@ class RCTMGLMarkerView: UIView, RCTMGLMapComponent {
   
   private func remove() {
     annotationManager?.remove(self)
+    didAddToMap = false
   }
   
   // MARK: - Helper functions

package/ios/RCTMGL-v10/RCTMGLOfflineModule.swift

@@ -46,6 +46,15 @@ class RCTMGLOfflineModule: RCTEventEmitter {
   
   lazy var tileRegionPacks : [String: TileRegionPack] = [:]
   
+  var progressEventThrottle : (
+    waitBetweenEvents: Double?,
+    lastSentTimestamp: Double?,
+    lastSentState: State?
+  ) = (
+    300,
+    nil,
+    nil
+  )
   
   @objc override
   func startObserving() {
@@ -301,12 +310,8 @@ class RCTMGLOfflineModule: RCTEventEmitter {
     RCTMGLEvent(type: .offlineProgress, payload: self._makeRegionStatusPayload(name, progress: progress, state: state, metadata: nil))
   }
   
-  func shouldSendProgressEvent() -> Bool {
-    return true
-  }
-  
   func offlinePackProgressDidChange(progress: TileRegionLoadProgress, metadata: [String:Any], state: State) {
-    if self.shouldSendProgressEvent() {
+    if self.shouldSendProgressEvent(progress: progress, state: state) {
       let event = makeProgressEvent(metadata["name"] as! String, progress: progress, state: state)
       self._sendEvent(Callbacks.progress.rawValue, event: event)
     }
@@ -364,13 +369,17 @@ class RCTMGLOfflineModule: RCTEventEmitter {
         }) { result in
           switch result {
           case .success(let value):
-            if let progess = lastProgress {
-              self.offlinePackProgressDidChange(progress: progess, metadata: metadata, state: .complete)
+            DispatchQueue.main.async {
+              if let progess = lastProgress {
+                self.offlinePackProgressDidChange(progress: progess, metadata: metadata, state: .complete)
+              }
+              self.tileRegionPacks[id]!.state = .complete
             }
-            self.tileRegionPacks[id]!.state = .complete
           case .failure(let error):
-            self.tileRegionPacks[id]!.state = .inactive
-            self.offlinePackDidReceiveError(name: id, error: error)
+            DispatchQueue.main.async {
+              self.tileRegionPacks[id]!.state = .inactive
+              self.offlinePackDidReceiveError(name: id, error: error)
+            }
           }
         }
 
@@ -436,12 +445,7 @@ class RCTMGLOfflineModule: RCTEventEmitter {
   
   @objc
   func setTileCountLimit(_ limit: NSNumber) {
-    //v10todo
-  }
-  
-  @objc
-  func setProgressEventThrottle(_ throttleValue: NSNumber) {
-    // v10todo improve progress event listener
+    RCTMGLLogWarn("setTileCountLimit is not yet implemented on v10")
   }
   
   
@@ -482,3 +486,38 @@ class RCTMGLOfflineModule: RCTEventEmitter {
     }
   }
 }
+
+// MARK: progress throttle
+
+extension RCTMGLOfflineModule {
+  @objc
+  func setProgressEventThrottle(_ throttleValue: NSNumber) {
+    progressEventThrottle.waitBetweenEvents = throttleValue.doubleValue
+  }
+  
+
+  func shouldSendProgressEvent(progress: TileRegionLoadProgress, state: State) -> Bool
+  {
+    let currentTimestamp: Double = CACurrentMediaTime() * 1000.0
+    
+    guard let lastSentState = progressEventThrottle.lastSentState, lastSentState == state else {
+      progressEventThrottle.lastSentState = state
+      progressEventThrottle.lastSentTimestamp = currentTimestamp
+      return true
+    }
+    
+    guard let waitBetweenEvents = progressEventThrottle.waitBetweenEvents,
+          let lastSentTimestamp = progressEventThrottle.lastSentTimestamp else {
+      progressEventThrottle.lastSentTimestamp = currentTimestamp
+      return true;
+    }
+    
+    if (currentTimestamp - lastSentTimestamp > waitBetweenEvents) {
+      progressEventThrottle.lastSentTimestamp = currentTimestamp
+      return true;
+    }
+     
+    return false;
+  }
+}
+