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

package/src/modules/transform-request/NativeTransformRequestModule.ts

@@ -0,0 +1,41 @@
+import type { TurboModule } from "react-native";
+import { TurboModuleRegistry } from "react-native";
+
+export interface Spec extends TurboModule {
+  addUrlTransform(
+    id: string,
+    match: string | null,
+    find: string,
+    replace: string,
+  ): void;
+
+  removeUrlTransform(id: string): void;
+
+  clearUrlTransforms(): void;
+
+  addUrlSearchParam(
+    id: string,
+    match: string | null,
+    name: string,
+    value: string,
+  ): void;
+
+  removeUrlSearchParam(id: string): void;
+
+  clearUrlSearchParams(): void;
+
+  addHeader(
+    id: string,
+    match: string | null,
+    name: string,
+    value: string,
+  ): void;
+
+  removeHeader(id: string): void;
+
+  clearHeaders(): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>(
+  "MLRNTransformRequestModule",
+);

package/src/modules/transform-request/TransformRequestManager.ts

@@ -0,0 +1,292 @@
+import NativeTransformRequestModule from "./NativeTransformRequestModule";
+
+export interface TransformOptions {
+  /**
+   * The id is used to identify a transform. Can be used to remove or update it.
+   * When omitted it will be auto-generated.
+   */
+  id?: string;
+
+  /**
+   * Optional regex to be used as the condition, if the transform should be
+   * applied. When omitted the transform will always be applied.
+   *
+   * Global flags are (like `/i`) are not supported. Supports only inline flags, e.g. `(?i)` for case-insensitive matching.
+   */
+  match?: RegExp | string;
+}
+
+/**
+ * A serializable transform for rewriting MapLibre request URLs.
+ *
+ * Transforms are applied as a pipeline in the order they were added: transform N+1 sees
+ * the URL *after* transform N has possibly changed it.
+ */
+export interface UrlTransformOptions extends TransformOptions {
+  /**
+   * Regex to find the portion of the URL to replace.
+   * Supports capture groups that can be back-referenced in `replace` as `$1`, `$2`, …
+   *
+   * Global flags are (like `/i`) are not supported. Supports only inline flags, e.g. `(?i)` for case-insensitive matching.
+   */
+  find: RegExp | string;
+
+  /**
+   * Replacement string. Reference capture groups from `find` with `$1`, `$2`, …
+   */
+  replace: string;
+}
+
+/**
+ * A URL query parameter to append to matching map resource requests.
+ */
+export interface UrlSearchParamOptions extends TransformOptions {
+  /** The query parameter name (e.g., `"apiKey"`). */
+  name: string;
+
+  /** The query parameter value (e.g., your API key). */
+  value: string;
+}
+
+/**
+ * A HTTP header to send with matching map resource requests.
+ */
+export interface HeaderOptions extends TransformOptions {
+  /** The header name (e.g., `"Authorization"`). */
+  name: string;
+
+  /** The header value (e.g., `"Bearer token123"`). */
+  value: string;
+}
+
+/**
+ * TransformRequestManager provides methods for managing HTTP requests made by MapLibre.
+ *
+ * Transformations are possible in three ways:
+ *
+ * 1. Transforming the URL with search and replace
+ * 2. Adding URL search params
+ * 3. Adding HTTP headers
+ *
+ * Transforms are applied in this order. The `match` conditions are applied to
+ * possibly already transformed URLs.
+ *
+ * @remarks
+ * To gain insight into which transforms are applied set the log level to
+ * `"debug"` via {@link LogManager}:
+ *
+ * ```ts
+ * LogManager.setLogLevel("debug");
+ * ```
+ */
+class TransformRequestManager {
+  /**
+   * Adds or updates a URL transform identified by `id`.
+   *
+   * Transforms execute in insertion order. Therefore `match` and `find` regexes
+   * are matched against possibly already modified URL by previous transforms.
+   *
+   * Re-adding an existing `id` updates the transform
+   * **in-place**, preserving its position in the pipeline. This makes it safe to
+   * refresh tokens or swap domains without disrupting the order of other transforms.
+   *
+   * URL transforms are applied before `addUrlSearchParam` and `addHeader`.
+   *
+   * @example
+   * // Upgrade all requests to HTTPS
+   * TransformRequestManager.addUrlTransform({
+   *   id: "force-https",
+   *   find: "^http://",
+   *   replace: "https://",
+   * });
+   *
+   * @example
+   * // Redirect a specific domain through a proxy
+   * TransformRequestManager.addUrlTransform({
+   *   id: "proxy",
+   *   match: "tiles\\.example\\.com",
+   *   find: "tiles\\.example\\.com",
+   *   replace: "proxy.example.com",
+   * });
+   *
+   * @example
+   * // Inject an API key into the path using a capture group
+   * TransformRequestManager.addUrlTransform({
+   *   id: "api-key",
+   *   match: "api\\.example\\.com",
+   *   find: "(https://api\\.example\\.com/)(.*)",
+   *   replace: "$1mySecretKey/$2",
+   * });
+   *
+   * @param options The transform. Set {@link TransformOptions.id} to a stable string to
+   *   enable in-place updates; if omitted an id is auto-generated and returned.
+   *
+   * @returns The id of the transform (the value of `transform.id` when provided, otherwise
+   *   the auto-generated one). Pass it to {@link removeUrlTransform} to remove it later.
+   */
+  addUrlTransform(options: UrlTransformOptions): string {
+    const id = options.id ?? this.getId();
+
+    NativeTransformRequestModule.addUrlTransform(
+      id,
+      TransformRequestManager.toRegexString(options.match),
+      TransformRequestManager.toRegexString(options.find) ?? "",
+      options.replace,
+    );
+
+    return id;
+  }
+
+  /**
+   * Removes the URL transform with the given `id`.
+   * No-op if the id is not registered.
+   *
+   * @param id The identifier passed to/returned from {@link addUrlTransform}.
+   */
+  removeUrlTransform(id: string): void {
+    NativeTransformRequestModule.removeUrlTransform(id);
+  }
+
+  /**
+   * Removes all registered URL transforms
+   */
+  clearUrlTransforms(): void {
+    NativeTransformRequestModule.clearUrlTransforms();
+  }
+
+  /**
+   * Adds or updates a URL query parameter identified by `id` that will be appended to all
+   * matching map resource requests. Re-adding an existing `id` updates the param in-place.
+   *
+   * @example
+   * // Add apiKey to for a specific domain
+   * TransformRequestManager.addUrlSearchParam({
+   *   match: /tiles\.example\.com/,
+   *   name: "apiKey",
+   *   value: "your-api-key",
+   * });
+   *
+   * // Add apiKey to all requests (no match = applies to all)
+   * TransformRequestManager.addUrlSearchParam({ name: "apiKey", value: "your-api-key" });
+   *
+   * @param options The options. Set {@link TransformOptions.id} to a stable string to
+   *   enable in-place updates; if omitted an id is auto-generated and returned.
+   *
+   * @returns The id of the options. Pass it to {@link removeUrlSearchParam} to remove it later.
+   */
+  addUrlSearchParam(options: UrlSearchParamOptions): string {
+    const id = options.id ?? this.getId();
+
+    NativeTransformRequestModule.addUrlSearchParam(
+      id,
+      TransformRequestManager.toRegexString(options.match),
+      options.name,
+      options.value,
+    );
+
+    return id;
+  }
+
+  /**
+   * Removes a previously added URL query parameter by its `id`.
+   *
+   * @param id The identifier passed to/returned from {@link addUrlSearchParam}.
+   */
+  removeUrlSearchParam(id: string): void {
+    NativeTransformRequestModule.removeUrlSearchParam(id);
+  }
+
+  /**
+   * Adds or updates an HTTP header identified by `id` that will be sent with all
+   * matching map resource requests. Re-adding an existing `id` updates the header in-place.
+   *
+   * @example
+   * // Add header to all requests
+   * TransformRequestManager.addHeader({ name: "Authorization", value: "Bearer token123" });
+   *
+   * // Add header only to requests matching a pattern
+   * TransformRequestManager.addHeader({
+   *   name: "X-API-Key",
+   *   value: "key123",
+   *   match: /https:\/\/api\.example\.com\/tiles\//,
+   * });
+   *
+   * @param options The options. Set {@link TransformOptions.id} to a stable string to
+   *   enable in-place updates; if omitted an id is auto-generated and returned.
+   *
+   * @returns The id of the options. Pass it to {@link removeHeader} to remove it later.
+   */
+  addHeader(options: HeaderOptions): string {
+    const id = options.id ?? this.getId();
+
+    NativeTransformRequestModule.addHeader(
+      id,
+      TransformRequestManager.toRegexString(options.match),
+      options.name,
+      options.value,
+    );
+
+    return id;
+  }
+
+  /**
+   * Removes all registered URL search params.
+   */
+  clearUrlSearchParams(): void {
+    NativeTransformRequestModule.clearUrlSearchParams();
+  }
+
+  /**
+   * Removes a previously added HTTP header by its `id`.
+   *
+   * @param id The identifier passed to/returned from {@link addHeader}.
+   */
+  removeHeader(id: string): void {
+    NativeTransformRequestModule.removeHeader(id);
+  }
+
+  /**
+   * Removes all registered HTTP headers.
+   */
+  clearHeaders(): void {
+    NativeTransformRequestModule.clearHeaders();
+  }
+
+  /**
+   * Removes all registered URL transforms, URL search params and HTTP headers.
+   */
+  clear(): void {
+    this.clearUrlTransforms();
+    this.clearUrlSearchParams();
+    this.clearHeaders();
+  }
+
+  private lastId: number = -1;
+
+  private getId() {
+    this.lastId++;
+
+    return "transform-request-" + this.lastId;
+  }
+
+  private static toRegexString(
+    value: string | RegExp | undefined,
+  ): string | null {
+    let result: string | undefined = undefined;
+    if (value instanceof RegExp) {
+      if (value.flags) {
+        throw new Error("Regex flags are not supported");
+      }
+
+      result = value.source;
+    } else {
+      result = value;
+    }
+
+    return result || null;
+  }
+}
+
+const transformRequestManager = new TransformRequestManager();
+
+export { transformRequestManager as TransformRequestManager };

package/android/src/main/java/org/maplibre/reactnative/http/RequestHeadersInterceptor.kt

@@ -1,65 +0,0 @@
-package org.maplibre.reactnative.http
-
-import android.util.Log
-import okhttp3.Interceptor
-import okhttp3.Response
-import java.io.IOException
-
-data class HeaderConfig(
-    val value: String,
-    val matchRegex: Regex?,
-)
-
-class RequestHeadersInterceptor : Interceptor {
-    private val requestHeaders: MutableMap<String, HeaderConfig> = HashMap()
-
-    fun addHeader(
-        name: String,
-        value: String,
-        match: String?,
-    ) {
-        val regex =
-            if (match != null) {
-                try {
-                    Regex(match)
-                } catch (e: Exception) {
-                    Log.e(
-                        "RequestHeadersInterceptor",
-                        "Invalid regex pattern '$match': ${e.message}",
-                    )
-                    null
-                }
-            } else {
-                null
-            }
-
-        requestHeaders[name] = HeaderConfig(value, regex)
-    }
-
-    fun removeHeader(name: String) {
-        requestHeaders.remove(name)
-    }
-
-    @Throws(IOException::class)
-    override fun intercept(chain: Interceptor.Chain): Response {
-        val modifiedHeaderBuilder = chain.request().newBuilder()
-        val requestUrl = chain.request().url.toString()
-
-        for (entry in requestHeaders.entries) {
-            val config = entry.value
-            val shouldApply =
-                config.matchRegex == null || config.matchRegex.containsMatchIn(requestUrl)
-
-            if (shouldApply) {
-                modifiedHeaderBuilder.addHeader(entry.key, config.value)
-            }
-        }
-
-        val request = modifiedHeaderBuilder.build()
-        return chain.proceed(request)
-    }
-
-    companion object {
-        val INSTANCE: RequestHeadersInterceptor = RequestHeadersInterceptor()
-    }
-}

package/ios/modules/network/MLRNNetworkHTTPHeaders.h

@@ -1,14 +0,0 @@
-#import <Foundation/Foundation.h>
-#import <MapLibre/MLNNetworkConfiguration.h>
-
-@interface MLRNNetworkHTTPHeaders : NSObject <MLNNetworkConfigurationDelegate>
-
-+ (id _Nonnull)sharedInstance;
-
-- (void)addRequestHeader:(nonnull NSString *)name
-                   value:(nonnull NSString *)value
-                   match:(nullable NSString *)match;
-
-- (void)removeRequestHeader:(nonnull NSString *)header;
-
-@end

package/ios/modules/network/MLRNNetworkHTTPHeaders.m

@@ -1,97 +0,0 @@
-#import "MLRNNetworkHTTPHeaders.h"
-#import <MapLibre/MLNNetworkConfiguration.h>
-#import <MapLibre/MapLibre.h>
-
-@interface HeaderConfig : NSObject
-@property (nonatomic, strong) NSString *value;
-@property (nonatomic, strong, nullable) NSRegularExpression *matchRegex;
-
-- (instancetype)initWithValue:(NSString *)value match:(nullable NSString *)match;
-@end
-
-@implementation HeaderConfig
-
-- (instancetype)initWithValue:(NSString *)value match:(nullable NSString *)match {
-  if (self = [super init]) {
-    _value = value;
-
-    if (match != nil) {
-      NSError *error = nil;
-      _matchRegex = [NSRegularExpression regularExpressionWithPattern:match options:0 error:&error];
-      if (error != nil) {
-        NSLog(@"[MLRNNetworkHTTPHeaders] Invalid regex pattern '%@': %@", match,
-              error.localizedDescription);
-        _matchRegex = nil;
-      }
-    } else {
-      _matchRegex = nil;
-    }
-  }
-  return self;
-}
-
-@end
-
-@implementation MLRNNetworkHTTPHeaders {
-  NSMutableDictionary<NSString *, HeaderConfig *> *requestHeaders;
-}
-
-- (instancetype)init {
-  if (self = [super init]) {
-    requestHeaders = [[NSMutableDictionary alloc] init];
-    [[MLNNetworkConfiguration sharedManager] setDelegate:self];
-  }
-
-  return self;
-}
-
-+ (id)sharedInstance {
-  static MLRNNetworkHTTPHeaders *networkHttpHeaders;
-  static dispatch_once_t onceToken;
-
-  dispatch_once(&onceToken, ^{
-    networkHttpHeaders = [[self alloc] init];
-  });
-
-  return networkHttpHeaders;
-}
-
-- (void)addRequestHeader:(NSString *)name value:(NSString *)value match:(nullable NSString *)match {
-  HeaderConfig *config = [[HeaderConfig alloc] initWithValue:value match:match];
-  [requestHeaders setObject:config forKey:name];
-}
-
-- (void)removeRequestHeader:(NSString *)header {
-  [requestHeaders removeObjectForKey:header];
-}
-
-#pragma mark - MLNNetworkConfigurationDelegate
-
-- (NSMutableURLRequest *)willSendRequest:(NSMutableURLRequest *)request {
-  NSDictionary<NSString *, HeaderConfig *> *currentHeaders = [requestHeaders copy];
-
-  if (currentHeaders != nil && [currentHeaders count] > 0) {
-    NSString *requestUrl = request.URL.absoluteString;
-
-    for (NSString *headerName in currentHeaders) {
-      HeaderConfig *config = currentHeaders[headerName];
-      BOOL shouldApply = YES;
-
-      if (config.matchRegex != nil) {
-        NSRange range =
-            [config.matchRegex rangeOfFirstMatchInString:requestUrl
-                                                 options:0
-                                                   range:NSMakeRange(0, requestUrl.length)];
-        shouldApply = (range.location != NSNotFound);
-      }
-
-      if (shouldApply) {
-        [request setValue:config.value forHTTPHeaderField:headerName];
-      }
-    }
-  }
-
-  return request;
-}
-
-@end