@maplibre/maplibre-react-native 11.0.0-beta.19 → 11.0.0-beta.20

package/android/src/main/java/org/maplibre/reactnative/MLRNPackage.kt

@@ -28,6 +28,7 @@ import org.maplibre.reactnative.modules.MLRNLogModule
 import org.maplibre.reactnative.modules.MLRNNetworkModule
 import org.maplibre.reactnative.modules.MLRNOfflineModule
 import org.maplibre.reactnative.modules.MLRNStaticMapModule
+import org.maplibre.reactnative.modules.MLRNTransformRequestModule
 import org.maplibre.reactnative.utils.ReactTagResolver
 
 class MLRNPackage : BaseReactPackage() {
@@ -65,6 +66,8 @@ class MLRNPackage : BaseReactPackage() {
             MLRNLogModule.NAME -> return MLRNLogModule(reactContext)
 
             MLRNNetworkModule.NAME -> return MLRNNetworkModule(reactContext)
+
+            MLRNTransformRequestModule.NAME -> return MLRNTransformRequestModule(reactContext)
         }
 
         return null
@@ -164,6 +167,16 @@ class MLRNPackage : BaseReactPackage() {
                     isTurboModule = true,
                 )
 
+            moduleInfos[MLRNTransformRequestModule.NAME] =
+                ReactModuleInfo(
+                    MLRNTransformRequestModule.NAME,
+                    MLRNTransformRequestModule.NAME,
+                    canOverrideExistingModule = false,
+                    needsEagerInit = false,
+                    isCxxModule = false,
+                    isTurboModule = true,
+                )
+
             moduleInfos
         }
 

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

@@ -3,10 +3,12 @@ package org.maplibre.reactnative.modules
 import android.util.Log
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
 import org.maplibre.android.log.Logger
 import org.maplibre.android.log.LoggerDefinition
 import org.maplibre.reactnative.NativeLogModuleSpec
 
+@ReactModule(name = MLRNLogModule.NAME)
 class MLRNLogModule(
     reactContext: ReactApplicationContext,
 ) : NativeLogModuleSpec(

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/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/modules/logging/MLRNLogging.h

@@ -20,4 +20,8 @@
 
 - (void)setLogLevel:(nonnull NSString*)logLevel;
 
+- (void)forwardLog:(nonnull NSString*)level
+               tag:(nonnull NSString*)tag
+           message:(nonnull NSString*)message;
+
 @end

package/ios/modules/logging/MLRNLogging.m

@@ -66,6 +66,14 @@
   }
 }
 
+- (void)forwardLog:(nonnull NSString *)level
+               tag:(nonnull NSString *)tag
+           message:(nonnull NSString *)message {
+  if (self.delegate) {
+    [self.delegate logging:self didReceiveLogWithLevel:level filePath:tag line:0 message:message];
+  }
+}
+
 - (void)setLogLevel:(nonnull NSString *)logLevel {
   MLNLoggingLevel mlnLogLevel = MLNLoggingLevelNone;
   if ([logLevel isEqualToString:@"none"]) {

package/ios/modules/network/MLRNNetworkModule.mm

@@ -1,7 +1,5 @@
 #import "MLRNNetworkModule.h"
 
-#import "MLRNNetworkHTTPHeaders.h"
-
 @implementation MLRNNetworkModule
 
 + (NSString *)moduleName {
@@ -13,14 +11,6 @@
   return std::make_shared<facebook::react::NativeNetworkModuleSpecJSI>(params);
 }
 
-- (void)addRequestHeader:(NSString *)name value:(NSString *)value match:(NSString *_Nullable)match {
-  [MLRNNetworkHTTPHeaders.sharedInstance addRequestHeader:name value:value match:match];
-}
-
-- (void)removeRequestHeader:(NSString *)name {
-  [MLRNNetworkHTTPHeaders.sharedInstance removeRequestHeader:name];
-}
-
 - (void)setConnected:(BOOL)connected {
   // Android only
 }

package/ios/modules/transform-request/MLRNTransformRequest.h

@@ -0,0 +1,38 @@
+#import <Foundation/Foundation.h>
+#import <MapLibre/MLNNetworkConfiguration.h>
+
+@interface MLRNTransformRequest : NSObject <MLNNetworkConfigurationDelegate>
+
++ (MLRNTransformRequest *_Nonnull)sharedInstance;
+
+@property (nonatomic, copy, nullable) void (^logCallback)
+    (NSString *_Nonnull level, NSString *_Nonnull tag, NSString *_Nonnull message);
+
+- (void)addUrlTransform:(nonnull NSString *)transformId
+                  match:(nullable NSString *)match
+                   find:(nonnull NSString *)find
+                replace:(nonnull NSString *)replace;
+
+- (void)removeUrlTransform:(nonnull NSString *)transformId;
+
+- (void)clearUrlTransforms;
+
+- (void)addUrlSearchParam:(nonnull NSString *)transformId
+                    match:(nullable NSString *)match
+                     name:(nonnull NSString *)name
+                    value:(nonnull NSString *)value;
+
+- (void)removeUrlSearchParam:(nonnull NSString *)transformId;
+
+- (void)clearUrlSearchParams;
+
+- (void)addHeader:(nonnull NSString *)transformId
+            match:(nullable NSString *)match
+             name:(nonnull NSString *)name
+            value:(nonnull NSString *)value;
+
+- (void)removeHeader:(nonnull NSString *)transformId;
+
+- (void)clearHeaders;
+
+@end