@maplibre/maplibre-react-native 11.0.0-beta.8 → 11.0.0

package/android/src/main/java/org/maplibre/reactnative/modules/MLRNNetworkModule.kt

@@ -1,14 +1,9 @@
 package org.maplibre.reactnative.modules
 
-import android.util.Log
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.module.annotations.ReactModule
-import okhttp3.Dispatcher
-import okhttp3.OkHttpClient
 import org.maplibre.android.MapLibre
-import org.maplibre.android.module.http.HttpRequestUtil
 import org.maplibre.reactnative.NativeNetworkModuleSpec
-import org.maplibre.reactnative.http.RequestHeadersInterceptor
 
 @ReactModule(name = MLRNNetworkModule.NAME)
 class MLRNNetworkModule(
@@ -16,52 +11,15 @@ class MLRNNetworkModule(
 ) : NativeNetworkModuleSpec(reactContext) {
     companion object {
         const val NAME = "MLRNNetworkModule"
-        private var requestHeadersInterceptorAdded = false
     }
 
     override fun getName() = NAME
 
     private val context: ReactApplicationContext = reactContext
 
-    override fun addRequestHeader(
-        name: String,
-        value: String,
-        match: String?,
-    ) {
-        context.runOnUiQueueThread {
-            if (!requestHeadersInterceptorAdded) {
-                Log.i("MLRNNetworkModule", "Add interceptor")
-                val httpClient =
-                    OkHttpClient
-                        .Builder()
-                        .addInterceptor(RequestHeadersInterceptor.INSTANCE)
-                        .dispatcher(getDispatcher())
-                        .build()
-                HttpRequestUtil.setOkHttpClient(httpClient)
-                requestHeadersInterceptorAdded = true
-            }
-
-            RequestHeadersInterceptor.INSTANCE.addHeader(name, value, match)
-        }
-    }
-
-    override fun removeRequestHeader(name: String) {
-        context.runOnUiQueueThread {
-            RequestHeadersInterceptor.INSTANCE.removeHeader(name)
-        }
-    }
-
     override fun setConnected(connected: Boolean) {
         context.runOnUiQueueThread {
             MapLibre.setConnected(connected)
         }
     }
-
-    private fun getDispatcher(): Dispatcher {
-        val dispatcher = Dispatcher()
-        // Matches core limit set on
-        // https://github.com/mapbox/mapbox-gl-native/blob/master/platform/android/src/http_file_source.cpp#L192
-        dispatcher.maxRequestsPerHost = 20
-        return dispatcher
-    }
 }

package/android/src/main/java/org/maplibre/reactnative/modules/MLRNOfflineModule.kt

@@ -36,6 +36,8 @@ class MLRNOfflineModule(
     private val context: Context = reactContext.applicationContext
     private var progressEventThrottle = 300.0
 
+    private val regions = HashMap<String, OfflineRegion>()
+
     override fun initialize() {
         Handler(Looper.getMainLooper()).post {
             runMigrations()
@@ -72,12 +74,14 @@ class MLRNOfflineModule(
             metadataBytes,
             object : OfflineManager.CreateOfflineRegionCallback {
                 override fun onCreate(offlineRegion: OfflineRegion) {
+                    regions[packId] = offlineRegion
                     val pack = fromOfflineRegion(offlineRegion)
                     promise.resolve(pack)
                     setOfflineRegionObserver(packId, offlineRegion)
                 }
 
                 override fun onError(error: String) {
+                    promise.reject("createPack", error)
                     emitOnError(makeErrorPayload(packId, error))
                     Log.e(NAME, "createPack error: $error")
                 }
@@ -165,6 +169,7 @@ class MLRNOfflineModule(
         offlineManager.resetDatabase(
             object : OfflineManager.FileSourceCallback {
                 override fun onSuccess() {
+                    clearRegions()
                     promise.resolve(null)
                 }
 
@@ -231,6 +236,7 @@ class MLRNOfflineModule(
                     val hasRegion = region != null
 
                     if (hasRegion) {
+                        regions[id] = region
                         setOfflineRegionObserver(id, region)
                     }
 
@@ -254,7 +260,7 @@ class MLRNOfflineModule(
         offlineManager.listOfflineRegions(
             object : OfflineManager.ListOfflineRegionsCallback {
                 override fun onList(offlineRegions: Array<OfflineRegion>?) {
-                    val region = getRegionById(id, offlineRegions)
+                    val region = regions[id] ?: getRegionById(id, offlineRegions)
 
                     if (region == null) {
                         promise.resolve(null)
@@ -292,7 +298,7 @@ class MLRNOfflineModule(
         offlineManager.listOfflineRegions(
             object : OfflineManager.ListOfflineRegionsCallback {
                 override fun onList(offlineRegions: Array<OfflineRegion>?) {
-                    val region = getRegionById(id, offlineRegions)
+                    val region = regions[id] ?: getRegionById(id, offlineRegions)
 
                     if (region == null) {
                         promise.resolve(null)
@@ -304,6 +310,7 @@ class MLRNOfflineModule(
                     region.delete(
                         object : OfflineRegion.OfflineRegionDeleteCallback {
                             override fun onDelete() {
+                                regions.remove(id)
                                 promise.resolve(null)
                             }
 
@@ -331,7 +338,7 @@ class MLRNOfflineModule(
         offlineManager.listOfflineRegions(
             object : OfflineManager.ListOfflineRegionsCallback {
                 override fun onList(offlineRegions: Array<OfflineRegion>?) {
-                    val offlineRegion = getRegionById(id, offlineRegions)
+                    val offlineRegion = regions[id] ?: getRegionById(id, offlineRegions)
 
                     if (offlineRegion == null) {
                         promise.reject("pauseRegionDownload", "Unknown offline region")
@@ -361,7 +368,8 @@ class MLRNOfflineModule(
         offlineManager.listOfflineRegions(
             object : OfflineManager.ListOfflineRegionsCallback {
                 override fun onList(offlineRegions: Array<OfflineRegion>?) {
-                    val offlineRegion = getRegionById(id, offlineRegions)
+                    val offlineRegion =
+                        regions[id] ?: getRegionById(id, offlineRegions)?.also { regions[id] = it }
 
                     if (offlineRegion == null) {
                         promise.reject("resumeRegionDownload", "Unknown offline region")
@@ -631,8 +639,23 @@ class MLRNOfflineModule(
         return null
     }
 
+    override fun invalidate() {
+        Handler(Looper.getMainLooper()).post {
+            clearRegions()
+        }
+        super.invalidate()
+    }
+
     private fun activateFileSource() {
         val fileSource = FileSource.getInstance(context)
         fileSource.activate()
     }
+
+    private fun clearRegions() {
+        for (region in regions.values) {
+            region.setDownloadState(OfflineRegion.STATE_INACTIVE)
+            region.setObserver(null)
+        }
+        regions.clear()
+    }
 }

package/android/src/main/java/org/maplibre/reactnative/modules/MLRNTransformRequestModule.kt

@@ -0,0 +1,144 @@
+package org.maplibre.reactnative.modules
+
+import android.util.Log
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import okhttp3.Dispatcher
+import okhttp3.OkHttpClient
+import org.maplibre.android.module.http.HttpRequestUtil
+import org.maplibre.reactnative.NativeTransformRequestModuleSpec
+
+@ReactModule(name = MLRNTransformRequestModule.NAME)
+class MLRNTransformRequestModule(
+    reactContext: ReactApplicationContext,
+) : NativeTransformRequestModuleSpec(reactContext) {
+    companion object {
+        const val NAME = "MLRNTransformRequestModule"
+
+        private var transformRequestInterceptorAdded = false
+    }
+
+    override fun getName() = NAME
+
+    override fun initialize() {
+        reactApplicationContext.getNativeModule(MLRNLogModule::class.java)?.let { logModule ->
+            TransformRequestInterceptor.INSTANCE.jsLogger = { level, tag, message ->
+                logModule.onLog(level, tag, message)
+            }
+        }
+    }
+
+    private fun ensureInterceptorAdded() {
+        if (!transformRequestInterceptorAdded) {
+            Log.i(NAME, "Add interceptor")
+            val httpClient =
+                OkHttpClient
+                    .Builder()
+                    .addInterceptor(TransformRequestInterceptor.INSTANCE)
+                    .dispatcher(getDispatcher())
+                    .build()
+            HttpRequestUtil.setOkHttpClient(httpClient)
+            transformRequestInterceptorAdded = true
+        }
+    }
+
+    override fun addUrlTransform(
+        id: String,
+        match: String?,
+        find: String,
+        replace: String,
+    ) {
+        requireValidRegex(match, "addUrlTransform", "match")
+        requireValidRegex(find, "addUrlTransform", "find")
+        reactApplicationContext.runOnUiQueueThread {
+            ensureInterceptorAdded()
+            TransformRequestInterceptor.INSTANCE.addUrlTransform(id, match, find, replace)
+        }
+    }
+
+    override fun removeUrlTransform(id: String) {
+        reactApplicationContext.runOnUiQueueThread {
+            TransformRequestInterceptor.INSTANCE.removeUrlTransform(id)
+        }
+    }
+
+    override fun clearUrlTransforms() {
+        reactApplicationContext.runOnUiQueueThread {
+            TransformRequestInterceptor.INSTANCE.clearUrlTransforms()
+        }
+    }
+
+    override fun addUrlSearchParam(
+        id: String,
+        match: String?,
+        key: String,
+        value: String,
+    ) {
+        requireValidRegex(match, "addUrlSearchParam", "match")
+        reactApplicationContext.runOnUiQueueThread {
+            ensureInterceptorAdded()
+            TransformRequestInterceptor.INSTANCE.addUrlSearchParam(id, match, key, value)
+        }
+    }
+
+    override fun removeUrlSearchParam(id: String) {
+        reactApplicationContext.runOnUiQueueThread {
+            TransformRequestInterceptor.INSTANCE.removeUrlSearchParam(id)
+        }
+    }
+
+    override fun clearUrlSearchParams() {
+        reactApplicationContext.runOnUiQueueThread {
+            TransformRequestInterceptor.INSTANCE.clearUrlSearchParams()
+        }
+    }
+
+    override fun addHeader(
+        id: String,
+        match: String?,
+        name: String,
+        value: String,
+    ) {
+        requireValidRegex(match, "addHeader", "match")
+        reactApplicationContext.runOnUiQueueThread {
+            ensureInterceptorAdded()
+            TransformRequestInterceptor.INSTANCE.addHeader(id, match, name, value)
+        }
+    }
+
+    override fun removeHeader(id: String) {
+        reactApplicationContext.runOnUiQueueThread {
+            TransformRequestInterceptor.INSTANCE.removeHeader(id)
+        }
+    }
+
+    override fun clearHeaders() {
+        reactApplicationContext.runOnUiQueueThread {
+            TransformRequestInterceptor.INSTANCE.clearHeaders()
+        }
+    }
+
+    private fun requireValidRegex(
+        pattern: String?,
+        methodName: String,
+        fieldName: String,
+    ) {
+        if (pattern != null) {
+            try {
+                Regex(pattern)
+            } catch (e: Exception) {
+                throw IllegalArgumentException(
+                    "[$NAME] $methodName: invalid $fieldName regex '$pattern': ${e.message}",
+                )
+            }
+        }
+    }
+
+    private fun getDispatcher(): Dispatcher {
+        val dispatcher = Dispatcher()
+        // Matches core limit set on
+        // https://github.com/mapbox/mapbox-gl-native/blob/master/platform/android/src/http_file_source.cpp#L192
+        dispatcher.maxRequestsPerHost = 20
+        return dispatcher
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/modules/TransformRequestInterceptor.kt

@@ -0,0 +1,184 @@
+package org.maplibre.reactnative.modules
+
+import android.util.Log
+import okhttp3.HttpUrl
+import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
+import okhttp3.Interceptor
+import okhttp3.Response
+import java.io.IOException
+import kotlin.collections.iterator
+
+data class UrlTransformConfig(
+    val matchRegex: Regex?,
+    val findRegex: Regex,
+    val replace: String,
+)
+
+data class UrlSearchParamConfig(
+    val matchRegex: Regex?,
+    val name: String,
+    val value: String,
+)
+
+data class HeaderConfig(
+    val matchRegex: Regex?,
+    val name: String,
+    val value: String,
+)
+
+class TransformRequestInterceptor : Interceptor {
+    private val urlTransforms: LinkedHashMap<String, UrlTransformConfig> = LinkedHashMap()
+    private val urlSearchParams: LinkedHashMap<String, UrlSearchParamConfig> = LinkedHashMap()
+    private val headers: LinkedHashMap<String, HeaderConfig> = LinkedHashMap()
+
+    @Volatile
+    var jsLogger: ((level: String, tag: String, message: String) -> Unit)? = null
+
+    private fun debugLog(message: String) {
+        if (Log.isLoggable(TAG, Log.DEBUG)) {
+            Log.d(TAG, message)
+        }
+        jsLogger?.invoke("debug", TAG, message)
+    }
+
+    private fun errorLog(message: String) {
+        Log.e(TAG, message)
+        jsLogger?.invoke("error", TAG, message)
+    }
+
+    fun addUrlTransform(
+        id: String,
+        match: String?,
+        find: String,
+        replace: String,
+    ) {
+        urlTransforms[id] = UrlTransformConfig(match?.let { Regex(it) }, Regex(find), replace)
+    }
+
+    fun removeUrlTransform(id: String) {
+        urlTransforms.remove(id)
+    }
+
+    fun clearUrlTransforms() {
+        urlTransforms.clear()
+    }
+
+    fun addUrlSearchParam(
+        id: String,
+        match: String?,
+        name: String,
+        value: String,
+    ) {
+        urlSearchParams[id] = UrlSearchParamConfig(match?.let { Regex(it) }, name, value)
+    }
+
+    fun removeUrlSearchParam(id: String) {
+        urlSearchParams.remove(id)
+    }
+
+    fun clearUrlSearchParams() {
+        urlSearchParams.clear()
+    }
+
+    fun addHeader(
+        id: String,
+        match: String?,
+        name: String,
+        value: String,
+    ) {
+        headers[id] = HeaderConfig(match?.let { Regex(it) }, name, value)
+    }
+
+    fun removeHeader(id: String) {
+        headers.remove(id)
+    }
+
+    fun clearHeaders() {
+        headers.clear()
+    }
+
+    @Throws(IOException::class)
+    override fun intercept(chain: Interceptor.Chain): Response {
+        var request = chain.request()
+
+        val hasConfig = urlTransforms.isNotEmpty() || urlSearchParams.isNotEmpty() || headers.isNotEmpty()
+        if (hasConfig) {
+            debugLog("Request: ${request.url}")
+        }
+
+        // 1. URL transforms
+        var currentUrl = request.url.toString()
+        for ((transformId, config) in urlTransforms) {
+            val urlBeforeTransform = currentUrl
+            val shouldApply = config.matchRegex == null || config.matchRegex.containsMatchIn(currentUrl)
+
+            if (!shouldApply) {
+                debugLog("  URL Transform [$transformId]${matchDescription(config.matchRegex)}: SKIPPED (no match)")
+                continue
+            }
+
+            val result = config.findRegex.replace(currentUrl, config.replace)
+            if (result.toHttpUrlOrNull() == null) {
+                errorLog(
+                    "URL Transform [$transformId]${matchDescription(config.matchRegex)}: produced invalid URL '$result', " +
+                        "using pre-transform URL",
+                )
+            } else {
+                debugLog(
+                    "  URL Transform [$transformId]${matchDescription(config.matchRegex)}: APPLIED '$urlBeforeTransform' → '$result'",
+                )
+                currentUrl = result
+            }
+        }
+
+        // 2. URL search params
+        var modifiedUrl: HttpUrl = currentUrl.toHttpUrlOrNull() ?: request.url
+        for (entry in urlSearchParams.entries) {
+            val config = entry.value
+            val shouldApply =
+                config.matchRegex == null || config.matchRegex.containsMatchIn(modifiedUrl.toString())
+
+            if (shouldApply) {
+                debugLog(
+                    "  URL Search Param [${entry.key}]${matchDescription(config.matchRegex)}: APPLIED '${config.name}=${config.value}'",
+                )
+                modifiedUrl =
+                    modifiedUrl
+                        .newBuilder()
+                        .setQueryParameter(config.name, config.value)
+                        .build()
+            } else {
+                debugLog("  URL Search Param [${entry.key}]${matchDescription(config.matchRegex)}: SKIPPED (no match)")
+            }
+        }
+
+        // 3. Headers
+        val requestBuilder = request.newBuilder().url(modifiedUrl)
+        for (entry in headers.entries) {
+            val config = entry.value
+            val shouldApply =
+                config.matchRegex == null || config.matchRegex.containsMatchIn(modifiedUrl.toString())
+
+            if (shouldApply) {
+                debugLog("  Header [${entry.key}]${matchDescription(config.matchRegex)}: APPLIED '${config.name}: ${config.value}'")
+                requestBuilder.header(config.name, config.value)
+            } else {
+                debugLog("  Header [${entry.key}]${matchDescription(config.matchRegex)}: SKIPPED (no match)")
+            }
+        }
+
+        if (hasConfig) {
+            debugLog("Final URL: $modifiedUrl")
+        }
+
+        request = requestBuilder.build()
+        return chain.proceed(request)
+    }
+
+    companion object {
+        val INSTANCE: TransformRequestInterceptor = TransformRequestInterceptor()
+        private const val TAG = "TransformRequestInterceptor"
+
+        private fun matchDescription(matchRegex: Regex?) = if (matchRegex != null) " (match='${matchRegex.pattern}')" else ""
+    }
+}

package/ios/components/annotations/point-annotation/MLRNPointAnnotation.h

@@ -20,8 +20,9 @@
 @property (nonatomic, copy) NSDictionary<NSString *, NSNumber *> *anchor;
 @property (nonatomic, copy) NSDictionary<NSString *, NSNumber *> *offset;
 
-@property (nonatomic, copy) void (^reactOnSelected)(NSDictionary *event);
-@property (nonatomic, copy) void (^reactOnDeselected)(NSDictionary *event);
+@property (nonatomic, copy) void (^reactOnPress)(NSDictionary *event);
+@property (nonatomic, copy) void (^reactOnSelect)(NSDictionary *event);
+@property (nonatomic, copy) void (^reactOnDeselect)(NSDictionary *event);
 @property (nonatomic, copy) void (^reactOnDragStart)(NSDictionary *event);
 @property (nonatomic, copy) void (^reactOnDrag)(NSDictionary *event);
 @property (nonatomic, copy) void (^reactOnDragEnd)(NSDictionary *event);

package/ios/components/annotations/point-annotation/MLRNPointAnnotation.m

@@ -1,6 +1,7 @@
 #import "MLRNPointAnnotation.h"
 #import <React/UIView+React.h>
 #import "MLRNMapTouchEvent.h"
+#import "MLRNMapView.h"
 #import "MLRNUtils.h"
 
 const float CENTER_X_OFFSET_BASE = -0.5f;
@@ -8,6 +9,9 @@ const float CENTER_Y_OFFSET_BASE = -0.5f;
 
 @implementation MLRNPointAnnotation {
   UITapGestureRecognizer *customViewTap;
+  // Finger-to-anchor offset to preserve the touch position relative to the annotation's anchor
+  CGPoint _dragFingerOffset;
+  BOOL _dragFingerOffsetCaptured;
 }
 
 - (id)init {
@@ -36,6 +40,11 @@ const float CENTER_Y_OFFSET_BASE = -0.5f;
 }
 
 - (void)reactSetFrame:(CGRect)frame {
+  // Skip frame updates while dragging
+  if (self.dragState != MLNAnnotationViewDragStateNone) {
+    return;
+  }
+
   if ([_map.annotations containsObject:self]) {
     [_map removeAnnotation:self];
   }
@@ -54,6 +63,36 @@ const float CENTER_Y_OFFSET_BASE = -0.5f;
   [self _setCenterOffset:self.frame];
 }
 
+- (void)setCenter:(CGPoint)center {
+  // Reset drag offset tracking whenever we're not in a drag
+  if (self.dragState == MLNAnnotationViewDragStateNone) {
+    _dragFingerOffsetCaptured = NO;
+    [super setCenter:center];
+    return;
+  }
+
+  if (_map != nil) {
+    CGPoint coordPoint = [_map convertCoordinate:self.coordinate toPointToView:_map];
+
+    // Reject map-redraw resets: MapLibre re-projects annotations from their
+    // coordinate on every redraw, snapping the view back mid-drag.
+    if (fabs(center.x - coordPoint.x) < 0.5 && fabs(center.y - coordPoint.y) < 0.5) {
+      return;
+    }
+
+    // Capture the finger-to-anchor offset so the view doesn't snap its center
+    // to the touch point, preserving where the user grabbed relative to the anchor.
+    if (!_dragFingerOffsetCaptured) {
+      _dragFingerOffset = CGPointMake(center.x - coordPoint.x, center.y - coordPoint.y);
+      _dragFingerOffsetCaptured = YES;
+    }
+    center.x -= _dragFingerOffset.x;
+    center.y -= _dragFingerOffset.y;
+  }
+
+  [super setCenter:center];
+}
+
 - (void)setMap:(MLNMapView *)map {
   if (map == nil) {
     [_map removeAnnotation:self];
@@ -75,6 +114,9 @@ const float CENTER_Y_OFFSET_BASE = -0.5f;
   _reactSelected = reactSelected;
 
   if (_map != nil) {
+    if ([_map isKindOfClass:[MLRNMapView class]]) {
+      ((MLRNMapView *)_map).annotationSelected = YES;
+    }
     if (_reactSelected) {
       [_map selectAnnotation:self animated:NO completionHandler:nil];
     } else {
@@ -120,8 +162,22 @@ const float CENTER_Y_OFFSET_BASE = -0.5f;
   BOOL hasCustomChildren = (self.reactSubviews.count > 0) || (self.customChildCount > 0);
 
   if (!hasCustomChildren) {
-    // default pin view
-    return nil;
+    // Replicate MLNMapView's to allow unified tap/selection behavior.
+    NSBundle *mapLibreBundle = [NSBundle bundleForClass:[MLNMapView class]];
+    UIImage *pinImage = [UIImage imageNamed:@"default_marker"
+                                   inBundle:mapLibreBundle
+              compatibleWithTraitCollection:nil];
+
+    UIImageView *pinImageView = [[UIImageView alloc] initWithImage:pinImage];
+    [pinImageView sizeToFit];
+
+    MLNAnnotationView *defaultView = [[MLNAnnotationView alloc] initWithReuseIdentifier:nil];
+    defaultView.bounds = pinImageView.bounds;
+    [defaultView addSubview:pinImageView];
+    defaultView.centerOffset = CGVectorMake(0, 0);
+    defaultView.enabled = YES;
+    [defaultView addGestureRecognizer:customViewTap];
+    return defaultView;
   } else {
     // custom view
     self.enabled = YES;
@@ -133,6 +189,7 @@ const float CENTER_Y_OFFSET_BASE = -0.5f;
       }
     }
     [self addGestureRecognizer:customViewTap];
+    self.annotation = self;
     return self;
   }
 }
@@ -143,6 +200,12 @@ const float CENTER_Y_OFFSET_BASE = -0.5f;
 }
 
 - (void)_handleTap:(UITapGestureRecognizer *)recognizer {
+  if ([_map isKindOfClass:[MLRNMapView class]]) {
+    ((MLRNMapView *)_map).annotationSelected = YES;
+  }
+  if (self.reactOnPress != nil) {
+    self.reactOnPress([self makeEventPayload]);
+  }
   [_map selectAnnotation:self animated:NO completionHandler:nil];
 }