@maplibre/maplibre-react-native 11.0.0-alpha.4 → 11.0.0-alpha.6

package/MapLibreReactNative.podspec

@@ -3,7 +3,7 @@ require "json"
 package = JSON.parse(File.read(File.join(__dir__, "package.json")))
 
 # Global Variable Defaults
-$MLRN_NATIVE_VERSION ||= "6.14.0"
+$MLRN_NATIVE_VERSION ||= "6.17.1"
 $MLRN_SPM_SPEC ||= {
   url: "https://github.com/maplibre/maplibre-gl-native-distribution",
   requirement: {

package/README.md

@@ -1,4 +1,12 @@
-[![MapLibre Logo](https://maplibre.org/img/maplibre-logo-big.svg)](https://maplibre.org)
+<p align="center">
+  <a href="https://maplibre.org">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://maplibre.org/img/maplibre-logos/maplibre-logo-for-dark-bg.svg">
+      <source media="(prefers-color-scheme: light)" srcset="https://maplibre.org/img/maplibre-logos/maplibre-logo-for-light-bg.svg">
+      <img alt="MapLibre Logo" src="https://maplibre.org/img/maplibre-logos/maplibre-logo-for-light-bg.svg" width="200">
+    </picture>
+  </a>
+</p>
 
 # MapLibre React Native
 

package/android/gradle.properties

@@ -5,7 +5,7 @@ org.maplibre.reactnative.compileSdkVersion=35
 org.maplibre.reactnative.ndkVersion=27.1.12297006
 
 # MapLibre React Native
-org.maplibre.reactnative.nativeVersion=11.10.1
+org.maplibre.reactnative.nativeVersion=11.12.1
 org.maplibre.reactnative.nativeVariant=opengl
 org.maplibre.reactnative.pluginVersion=3.0.2
 org.maplibre.reactnative.turfVersion=6.0.1

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

@@ -57,50 +57,46 @@ class MLRNPackage : BaseReactPackage() {
             moduleInfos[MLRNModule.REACT_CLASS] = ReactModuleInfo(
                 MLRNModule.REACT_CLASS,
                 MLRNModule.REACT_CLASS,
-                false,  // canOverrideExistingModule
-                false,  // needsEagerInit
-                true,  // hasConstants
-                false,  // isCxxModule
-                false // isTurboModule
+                canOverrideExistingModule = false,
+                needsEagerInit = false,
+                isCxxModule = false,
+                isTurboModule = false
             )
 
             moduleInfos[MLRNOfflineModule.REACT_CLASS] = ReactModuleInfo(
                 MLRNOfflineModule.REACT_CLASS,
                 MLRNOfflineModule.REACT_CLASS,
-                false,  // canOverrideExistingModule
-                false,  // needsEagerInit
-                true,  // hasConstants
-                false,  // isCxxModule
-                false // isTurboModule
+                canOverrideExistingModule = false,
+                needsEagerInit = false,
+                isCxxModule = false,
+                isTurboModule = false
             )
 
             moduleInfos[MLRNSnapshotModule.NAME] = ReactModuleInfo(
                 MLRNSnapshotModule.NAME,
                 MLRNSnapshotModule.NAME,
-                false,  // canOverrideExistingModule
-                false,  // needsEagerInit
-                false,  // isCxxModule
-                true // isTurboModule
+                canOverrideExistingModule = false,
+                needsEagerInit = false,
+                isCxxModule = false,
+                isTurboModule = true
             )
 
             moduleInfos[MLRNLocationModule.REACT_CLASS] = ReactModuleInfo(
                 MLRNLocationModule.REACT_CLASS,
                 MLRNLocationModule.REACT_CLASS,
-                false,  // canOverrideExistingModule
-                false,  // needsEagerInit
-                true,  // hasConstants
-                false,  // isCxxModule
-                false // isTurboModule
+                canOverrideExistingModule = false,
+                needsEagerInit = false,
+                isCxxModule = false,
+                isTurboModule = false
             )
 
             moduleInfos[MLRNLogging.REACT_CLASS] = ReactModuleInfo(
                 MLRNLogging.REACT_CLASS,
                 MLRNLogging.REACT_CLASS,
-                false,  // canOverrideExistingModule
-                false,  // needsEagerInit
-                true,  // hasConstants
-                false,  // isCxxModule
-                false // isTurboModule
+                canOverrideExistingModule = false,
+                needsEagerInit = false,
+                isCxxModule = false,
+                isTurboModule = false
             )
 
             moduleInfos

package/android/src/main/java/org/maplibre/reactnative/components/images/MLRNImagesManager.java

@@ -64,6 +64,9 @@ public class MLRNImagesManager extends AbstractEventEmitter<MLRNImages> {
                 boolean hasScale = imageMap.hasKey("scale") && imageMap.getType("scale") == ReadableType.Number;
                 double scale = hasScale ? imageMap.getDouble("scale") : ImageEntry.defaultScale;
                 imageEntry = new ImageEntry(uri, scale);
+
+                boolean hasSdf = imageMap.hasKey("sdf") && imageMap.getType("sdf") == ReadableType.Boolean;
+                imageEntry.sdf = hasSdf && imageMap.getBoolean("sdf");
             } else {
                 imageEntry = new ImageEntry(map.getString(imageName));
             }

package/android/src/main/java/org/maplibre/reactnative/components/styles/sources/MLRNShapeSource.java

@@ -40,6 +40,7 @@ public class MLRNShapeSource extends MLRNSource<GeoJsonSource> {
 
     private Boolean mCluster;
     private Integer mClusterRadius;
+    private Integer mClusterMinPoints;
     private Integer mClusterMaxZoom;
     private List<Map.Entry<String, ClusterPropertyEntry>> mClusterProperties;
 
@@ -104,6 +105,10 @@ public class MLRNShapeSource extends MLRNSource<GeoJsonSource> {
         mClusterRadius = clusterRadius;
     }
 
+    public void setClusterMinPoints(int clusterMinPoints) {
+        mClusterMinPoints = clusterMinPoints;
+    }
+
     public void setClusterMaxZoom(int clusterMaxZoom) {
         mClusterMaxZoom = clusterMaxZoom;
     }
@@ -143,6 +148,10 @@ public class MLRNShapeSource extends MLRNSource<GeoJsonSource> {
             options.withClusterRadius(mClusterRadius);
         }
 
+        if (mClusterMinPoints != null) {
+            options.withClusterMinPoints(mClusterMinPoints);
+        }
+
         if (mClusterMaxZoom != null) {
             options.withClusterMaxZoom(mClusterMaxZoom);
         }

package/android/src/main/java/org/maplibre/reactnative/components/styles/sources/MLRNShapeSourceManager.java

@@ -106,6 +106,11 @@ public class MLRNShapeSourceManager extends AbstractEventEmitter<MLRNShapeSource
         source.setClusterRadius(radius);
     }
 
+    @ReactProp(name = "clusterMinPoints")
+    public void setClusterMinPoints(MLRNShapeSource source, int minPoints) {
+        source.setClusterMinPoints(minPoints);
+    }
+
     @ReactProp(name = "clusterMaxZoomLevel")
     public void setClusterMaxZoomLevel(MLRNShapeSource source, int clusterMaxZoom) {
         source.setClusterMaxZoom(clusterMaxZoom);

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

@@ -17,8 +17,6 @@ import org.maplibre.geojson.Point
 import org.maplibre.reactnative.NativeSnapshotModuleSpec
 import org.maplibre.reactnative.utils.BitmapUtils
 import org.maplibre.reactnative.utils.GeoJSONUtils
-import java.io.IOException
-import java.io.OutputStream
 import java.util.UUID
 
 @ReactModule(name = MLRNSnapshotModule.NAME)
@@ -33,15 +31,14 @@ class MLRNSnapshotModule(reactContext: ReactApplicationContext) :
     private val context: ReactApplicationContext = reactContext
 
     // Prevent garbage collection
-    private val snapshotterMap: MutableMap<String, MapSnapshotter> =
-        HashMap<String, MapSnapshotter>()
+    private val snapshotterMap: MutableMap<String, MapSnapshotter> = HashMap()
 
     override fun takeSnap(jsOptions: ReadableMap, promise: Promise) {
         org.maplibre.android.storage.FileSource.getInstance(context).activate()
 
         context.runOnUiQueueThread {
             val snapshotterID = UUID.randomUUID().toString()
-            val snapshotter: MapSnapshotter = MapSnapshotter(context, getOptions(jsOptions))
+            val snapshotter = MapSnapshotter(context, getOptions(jsOptions))
             snapshotterMap[snapshotterID] = snapshotter
             snapshotter.start(object :
                 MapSnapshotter.SnapshotReadyCallback {
@@ -114,15 +111,4 @@ class MLRNSnapshotModule(reactContext: ReactApplicationContext) :
 
         return options
     }
-
-    private fun closeSnapshotOutputStream(outputStream: OutputStream?) {
-        if (outputStream == null) {
-            return
-        }
-        try {
-            outputStream.close()
-        } catch (e: IOException) {
-            e.localizedMessage?.let { Log.w(NAME, it) }
-        }
-    }
 }

package/android/src/main/java/org/maplibre/reactnative/utils/DownloadMapImageTask.java

@@ -33,7 +33,7 @@ import java.util.Map;
 
 import javax.annotation.Nullable;
 
-public class DownloadMapImageTask extends AsyncTask<Map.Entry<String, ImageEntry>, Void, List<Map.Entry<String, Bitmap>>> {
+public class DownloadMapImageTask extends AsyncTask<Map.Entry<String, ImageEntry>, Void, List<Map.Entry<String, DownloadedImage>>> {
     public static final String LOG_TAG = "DownloadMapImageTask";
 
     private WeakReference<Context> mContext;
@@ -55,8 +55,8 @@ public class DownloadMapImageTask extends AsyncTask<Map.Entry<String, ImageEntry
 
     @SafeVarargs
     @Override
-    protected final List<Map.Entry<String, Bitmap>> doInBackground(Map.Entry<String, ImageEntry>... objects) {
-        List<Map.Entry<String, Bitmap>> images = new ArrayList<>();
+    protected final List<Map.Entry<String, DownloadedImage>> doInBackground(Map.Entry<String, ImageEntry>... objects) {
+        List<Map.Entry<String, DownloadedImage>> images = new ArrayList<>();
 
         Context context = mContext.get();
         if (context == null) return images;
@@ -95,7 +95,7 @@ public class DownloadMapImageTask extends AsyncTask<Map.Entry<String, ImageEntry
                                 // the fresco reference.
                                 .copy(Bitmap.Config.ARGB_8888, true);
                             bitmap.setDensity((int) ((double) DisplayMetrics.DENSITY_DEFAULT * imageEntry.getScaleOr(1.0)));
-                            images.add(new AbstractMap.SimpleEntry<>(object.getKey(), bitmap));
+                            images.add(new AbstractMap.SimpleEntry<>(object.getKey(), new DownloadedImage(object.getKey(), bitmap, imageEntry)));
                         } else {
                             FLog.e(LOG_TAG, "Failed to load bitmap from: " + uri);
                         }
@@ -114,7 +114,7 @@ public class DownloadMapImageTask extends AsyncTask<Map.Entry<String, ImageEntry
                 // local asset required from JS require('image.png') or import icon from 'image.png' while in release mode
                 Bitmap bitmap = BitmapUtils.getBitmapFromResource(context, uri, getBitmapOptions(metrics, imageEntry.scale));
                 if (bitmap != null) {
-                    images.add(new AbstractMap.SimpleEntry<>(object.getKey(), bitmap));
+                    images.add(new AbstractMap.SimpleEntry<>(object.getKey(), new DownloadedImage(object.getKey(), bitmap, imageEntry)));
                 } else {
                     FLog.e(LOG_TAG, "Failed to load bitmap from: " + uri);
                 }
@@ -125,16 +125,14 @@ public class DownloadMapImageTask extends AsyncTask<Map.Entry<String, ImageEntry
     }
 
     @Override
-    protected void onPostExecute(List<Map.Entry<String, Bitmap>> images) {
+    protected void onPostExecute(List<Map.Entry<String, DownloadedImage>> images) {
         MapLibreMap map = mMap.get();
         if (map != null && images != null && images.size() > 0) {
             Style style = map.getStyle();
             if (style != null) {
-                HashMap<String, Bitmap> bitmapImages = new HashMap<>();
-                for (Map.Entry<String, Bitmap> image : images) {
-                    bitmapImages.put(image.getKey(), image.getValue());
+                for (Map.Entry<String, DownloadedImage> image : images) {
+                    style.addImage(image.getKey(), image.getValue().bitmap(), image.getValue().info().sdf);
                 }
-                style.addImages(bitmapImages);
             }
         }
 

package/android/src/main/java/org/maplibre/reactnative/utils/DownloadedImage.java

@@ -0,0 +1,6 @@
+package org.maplibre.reactnative.utils;
+
+import android.graphics.Bitmap;
+
+public record DownloadedImage(String name, Bitmap bitmap, ImageEntry info) {
+}

package/android/src/main/java/org/maplibre/reactnative/utils/ImageEntry.java

@@ -4,6 +4,7 @@ public class ImageEntry {
     public String uri;
     public double scale = 1.0;
     public static final double defaultScale = 0.0;
+    public boolean sdf;
 
     public ImageEntry(String _uri, Double _scale) {
         uri = _uri;

package/ios/MLRNImageQueue.h

@@ -8,6 +8,7 @@
 - (void)cancelAllOperations;
 - (void)addImage:(NSString *)imageURL
                 scale:(double)scale
+                  sdf:(Boolean)sdf
                bridge:(RCTBridge *)bridge
     completionHandler:(RCTImageLoaderCompletionBlock)handler;
 

package/ios/MLRNImageQueue.m

@@ -33,11 +33,13 @@
 
 - (void)addImage:(NSString *)imageURL
                 scale:(double)scale
+                  sdf:(Boolean)sdf
                bridge:(RCTBridge *)bridge
     completionHandler:(RCTImageLoaderCompletionBlock)handler {
   MLRNImageQueueOperation *operation = [[MLRNImageQueueOperation alloc] init];
   operation.bridge = bridge;
   operation.urlRequest = [RCTConvert NSURLRequest:imageURL];
+  operation.sdf = sdf;
   operation.completionHandler = handler;
   operation.scale = scale;
   [imageQueue addOperation:operation];

package/ios/MLRNImageQueueOperation.h

@@ -5,6 +5,7 @@
 @property (nonatomic, weak) RCTBridge *bridge;
 @property (nonatomic, copy) RCTImageLoaderCompletionBlock completionHandler;
 @property (nonatomic, copy) NSURLRequest *urlRequest;
+@property (nonatomic) Boolean sdf;
 @property (nonatomic) double scale;
 
 @end

package/ios/MLRNImageQueueOperation.m

@@ -100,21 +100,23 @@ typedef NS_ENUM(NSInteger, MLRNImageQueueOperationState) {
   }
   __weak MLRNImageQueueOperation *weakSelf = self;
   dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
-    [weakSelf
-        setCancellationBlock:[[weakSelf.bridge moduleForName:@"ImageLoader"
-                                       lazilyLoadIfNecessary:YES]
-                                 loadImageWithURLRequest:weakSelf.urlRequest
-                                                    size:CGSizeZero
-                                                   scale:weakSelf.scale
-                                                 clipped:YES
-                                              resizeMode:RCTResizeModeStretch
-                                           progressBlock:nil
-                                        partialLoadBlock:nil
-                                         completionBlock:^void(NSError *error, UIImage *image) {
-                                           weakSelf.completionHandler(error, image);
-                                           [weakSelf setState:IOState_Finished
-                                                       except:IOState_Finished];
-                                         }]];
+    [weakSelf setCancellationBlock:
+                  [[weakSelf.bridge moduleForName:@"ImageLoader" lazilyLoadIfNecessary:YES]
+                      loadImageWithURLRequest:weakSelf.urlRequest
+                                         size:CGSizeZero
+                                        scale:weakSelf.scale
+                                      clipped:YES
+                                   resizeMode:RCTResizeModeStretch
+                                progressBlock:nil
+                             partialLoadBlock:nil
+                              completionBlock:^void(NSError *error, UIImage *image) {
+                                if (image && weakSelf.sdf) {
+                                  image = [image
+                                      imageWithRenderingMode:UIImageRenderingModeAlwaysTemplate];
+                                }
+                                weakSelf.completionHandler(error, image);
+                                [weakSelf setState:IOState_Finished except:IOState_Finished];
+                              }]];
     if ([weakSelf setState:IOState_Executing
                       only:IOState_Initial] == IOState_CancelledDoNotExecute) {
       [weakSelf callCancellationBlock];

package/ios/MLRNMapViewManager.m

@@ -45,12 +45,12 @@ RCT_EXPORT_MODULE(MLRNMapView)
   UILongPressGestureRecognizer *longPress =
       [[UILongPressGestureRecognizer alloc] initWithTarget:self action:@selector(didLongPressMap:)];
 
-  // this allows the internal annotation gestures to take precedents over the map tap gesture
+  // this allows the internal annotation gestures to take precedence over the map tap gesture
   for (int i = 0; i < mapView.gestureRecognizers.count; i++) {
-    UIGestureRecognizer *gestuerReconginer = mapView.gestureRecognizers[i];
+    UIGestureRecognizer *gestureRecognizer = mapView.gestureRecognizers[i];
 
-    if ([gestuerReconginer isKindOfClass:[UITapGestureRecognizer class]]) {
-      [tap requireGestureRecognizerToFail:gestuerReconginer];
+    if ([gestureRecognizer isKindOfClass:[UITapGestureRecognizer class]]) {
+      [tap requireGestureRecognizerToFail:gestureRecognizer];
     }
   }
 

package/ios/MLRNShapeSource.h

@@ -12,6 +12,7 @@
 
 @property (nonatomic, strong, nullable) NSNumber *cluster;
 @property (nonatomic, strong, nullable) NSNumber *clusterRadius;
+@property (nonatomic, strong, nullable) NSNumber *clusterMinPoints;
 @property (nonatomic, strong, nullable) NSNumber *clusterMaxZoomLevel;
 @property (nonatomic, strong, nullable)
     NSDictionary<NSString *, NSArray<NSExpression *> *> *clusterProperties;

package/ios/MLRNShapeSource.m

@@ -64,6 +64,10 @@ static UIImage *_placeHolderImage;
     options[MLNShapeSourceOptionClusterRadius] = _clusterRadius;
   }
 
+  if (_clusterMinPoints != nil) {
+    options[MLNShapeSourceOptionClusterMinPoints] = _clusterMinPoints;
+  }
+
   if (_clusterMaxZoomLevel != nil) {
     options[MLNShapeSourceOptionMaximumZoomLevelForClustering] = _clusterMaxZoomLevel;
   }

package/ios/MLRNShapeSourceManager.m

@@ -15,6 +15,7 @@ RCT_EXPORT_VIEW_PROPERTY(shape, NSString)
 
 RCT_EXPORT_VIEW_PROPERTY(cluster, NSNumber)
 RCT_EXPORT_VIEW_PROPERTY(clusterRadius, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(clusterMinPoints, NSNumber)
 RCT_EXPORT_VIEW_PROPERTY(clusterMaxZoomLevel, NSNumber)
 RCT_EXPORT_VIEW_PROPERTY(clusterProperties, NSDictionary)
 RCT_EXPORT_VIEW_PROPERTY(maxZoomLevel, NSNumber)

package/ios/MLRNStyle.m

@@ -56,7 +56,7 @@
       } else {
         NSString *imageURI = [styleValue getImageURI];
 
-        [MLRNUtils fetchImage:_bridge url:imageURI scale:[styleValue getImageScale] callback:^(NSError *error, UIImage *image) {
+        [MLRNUtils fetchImage:_bridge url:imageURI scale:[styleValue getImageScale] sdf:[styleValue getImageSdf] callback:^(NSError *error, UIImage *image) {
           if (image != nil) {
             dispatch_async(dispatch_get_main_queue(), ^{
               if (isValid()) {
@@ -138,7 +138,7 @@
       } else {
         NSString *imageURI = [styleValue getImageURI];
 
-        [MLRNUtils fetchImage:_bridge url:imageURI scale:[styleValue getImageScale] callback:^(NSError *error, UIImage *image) {
+        [MLRNUtils fetchImage:_bridge url:imageURI scale:[styleValue getImageScale] sdf:[styleValue getImageSdf] callback:^(NSError *error, UIImage *image) {
           if (image != nil) {
             dispatch_async(dispatch_get_main_queue(), ^{
               if (isValid()) {
@@ -200,7 +200,7 @@
       } else {
         NSString *imageURI = [styleValue getImageURI];
 
-        [MLRNUtils fetchImage:_bridge url:imageURI scale:[styleValue getImageScale] callback:^(NSError *error, UIImage *image) {
+        [MLRNUtils fetchImage:_bridge url:imageURI scale:[styleValue getImageScale] sdf:[styleValue getImageSdf] callback:^(NSError *error, UIImage *image) {
           if (image != nil) {
             dispatch_async(dispatch_get_main_queue(), ^{
               if (isValid()) {
@@ -454,7 +454,7 @@
       } else {
         NSString *imageURI = [styleValue getImageURI];
 
-        [MLRNUtils fetchImage:_bridge url:imageURI scale:[styleValue getImageScale] callback:^(NSError *error, UIImage *image) {
+        [MLRNUtils fetchImage:_bridge url:imageURI scale:[styleValue getImageScale] sdf:[styleValue getImageSdf] callback:^(NSError *error, UIImage *image) {
           if (image != nil) {
             dispatch_async(dispatch_get_main_queue(), ^{
               if (isValid()) {
@@ -592,7 +592,7 @@
       } else {
         NSString *imageURI = [styleValue getImageURI];
 
-        [MLRNUtils fetchImage:_bridge url:imageURI scale:[styleValue getImageScale] callback:^(NSError *error, UIImage *image) {
+        [MLRNUtils fetchImage:_bridge url:imageURI scale:[styleValue getImageScale] sdf:[styleValue getImageSdf] callback:^(NSError *error, UIImage *image) {
           if (image != nil) {
             dispatch_async(dispatch_get_main_queue(), ^{
               if (isValid()) {

package/ios/MLRNStyleValue.h

@@ -10,6 +10,7 @@
 - (BOOL)shouldAddImage;
 - (NSString *)getImageURI;
 - (double)getImageScale;
+- (BOOL)getImageSdf;
 - (MLNTransition)getTransition;
 - (NSExpression *)getSphericalPosition;
 - (BOOL)isVisible;

package/ios/MLRNStyleValue.m

@@ -114,6 +114,19 @@
   }
 }
 
+- (BOOL)getImageSdf {
+  if ([expressionJSON isKindOfClass:[NSDictionary class]]) {
+    id sdf = [expressionJSON valueForKey:@"sdf"];
+    if ([sdf isKindOfClass:[NSNumber class]]) {
+      return [sdf boolValue];
+    } else {
+      return false;
+    }
+  } else {
+    return false;
+  }
+}
+
 - (MLNTransition)getTransition {
   if (![expressionJSON isKindOfClass:[NSDictionary class]]) {
     return MLNTransitionMake(0.f, 0.f);

package/ios/MLRNUtils.h

@@ -16,6 +16,7 @@
 + (void)fetchImage:(RCTBridge *)bridge
                url:(NSString *)url
              scale:(double)scale
+               sdf:(Boolean)sdf
           callback:(RCTImageLoaderCompletionBlock)callback;
 + (void)fetchImages:(RCTBridge *)bridge
               style:(MLNStyle *)style

package/ios/MLRNUtils.m

@@ -79,8 +79,13 @@ static double const MS_TO_S = 0.001;
 + (void)fetchImage:(RCTBridge *)bridge
                url:(NSString *)url
              scale:(double)scale
+               sdf:(Boolean)sdf
           callback:(RCTImageLoaderCompletionBlock)callback {
-  [MLRNImageQueue.sharedInstance addImage:url scale:scale bridge:bridge completionHandler:callback];
+  [MLRNImageQueue.sharedInstance addImage:url
+                                    scale:scale
+                                      sdf:sdf
+                                   bridge:bridge
+                        completionHandler:callback];
 }
 
 + (void)fetchImages:(RCTBridge *)bridge
@@ -117,9 +122,13 @@ static double const MS_TO_S = 0.001;
       NSDictionary *image = objects[imageName];
       BOOL hasScale =
           [image isKindOfClass:[NSDictionary class]] && ([image objectForKey:@"scale"] != nil);
+      BOOL hasSdf =
+          [image isKindOfClass:[NSDictionary class]] && ([image objectForKey:@"sdf"] != nil);
       double scale = hasScale ? [[image objectForKey:@"scale"] doubleValue] : 1.0;
+      double sdf = hasSdf ? [[image objectForKey:@"sdf"] boolValue] : false;
       [MLRNImageQueue.sharedInstance addImage:objects[imageName]
                                         scale:scale
+                                          sdf:sdf
                                        bridge:bridge
                             completionHandler:^(NSError *error, UIImage *image) {
                               if (!image) {

package/lib/commonjs/MapLibreRN.js.map

@@ -1 +1 @@
-{"version":3,"names":["_MLRNModule","require","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_Camera","_MapView","_Light","_PointAnnotation","_Annotation","_Callout","_requestAndroidLocationPermissions","_UserLocation","_VectorSource","_ShapeSource","_RasterSource","_ImageSource","_Images","_FillLayer","_FillExtrusionLayer","_HeatmapLayer","_LineLayer","_CircleLayer","_SymbolLayer","_RasterLayer","_BackgroundLayer","_MarkerView","_LocationManager","_OfflineManager","_OfflinePack","_OfflineCreatePackOptions","_SnapshotManager","_Animated","_Logger"],"sourceRoot":"../../src","sources":["MapLibreRN.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,WAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,WAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAL,WAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAb,WAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AACA,IAAAS,OAAA,GAAAb,OAAA;AAQA,IAAAc,QAAA,GAAAd,OAAA;AAKA,IAAAe,MAAA,GAAAf,OAAA;AACA,IAAAgB,gBAAA,GAAAhB,OAAA;AAEA,IAAAiB,WAAA,GAAAjB,OAAA;AACA,IAAAkB,QAAA,GAAAlB,OAAA;AACA,IAAAmB,kCAAA,GAAAnB,OAAA;AACA,IAAAoB,aAAA,GAAApB,OAAA;AAKA,IAAAqB,aAAA,GAAArB,OAAA;AACA,IAAAsB,YAAA,GAAAtB,OAAA;AAEA,IAAAuB,aAAA,GAAAvB,OAAA;AACA,IAAAwB,YAAA,GAAAxB,OAAA;AACA,IAAAyB,OAAA,GAAAzB,OAAA;AACA,IAAA0B,UAAA,GAAA1B,OAAA;AACA,IAAA2B,mBAAA,GAAA3B,OAAA;AACA,IAAA4B,aAAA,GAAA5B,OAAA;AACA,IAAA6B,UAAA,GAAA7B,OAAA;AACA,IAAA8B,YAAA,GAAA9B,OAAA;AACA,IAAA+B,YAAA,GAAA/B,OAAA;AACA,IAAAgC,YAAA,GAAAhC,OAAA;AACA,IAAAiC,gBAAA,GAAAjC,OAAA;AACA,IAAAkC,WAAA,GAAAlC,OAAA;AAEA,IAAAmC,gBAAA,GAAAnC,OAAA;AAIA,IAAAoC,eAAA,GAAApC,OAAA;AAGA,IAAAqC,YAAA,GAAArC,OAAA;AACA,IAAAsC,yBAAA,GAAAtC,OAAA;AACA,IAAAuC,gBAAA,GAAAvC,OAAA;AAoBA,IAAAwC,SAAA,GAAAxC,OAAA;AACA,IAAAyC,OAAA,GAAAzC,OAAA","ignoreList":[]}
+{"version":3,"names":["_MLRNModule","require","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_Camera","_MapView","_Light","_PointAnnotation","_Annotation","_Callout","_requestAndroidLocationPermissions","_UserLocation","_VectorSource","_ShapeSource","_RasterSource","_ImageSource","_Images","_FillLayer","_FillExtrusionLayer","_HeatmapLayer","_LineLayer","_CircleLayer","_SymbolLayer","_RasterLayer","_BackgroundLayer","_MarkerView","_LocationManager","_OfflineManager","_OfflinePack","_OfflineCreatePackOptions","_SnapshotManager","_Animated","_Logger"],"sourceRoot":"../../src","sources":["MapLibreRN.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,WAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,WAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAL,WAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAb,WAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AACA,IAAAS,OAAA,GAAAb,OAAA;AASA,IAAAc,QAAA,GAAAd,OAAA;AAKA,IAAAe,MAAA,GAAAf,OAAA;AACA,IAAAgB,gBAAA,GAAAhB,OAAA;AAEA,IAAAiB,WAAA,GAAAjB,OAAA;AACA,IAAAkB,QAAA,GAAAlB,OAAA;AACA,IAAAmB,kCAAA,GAAAnB,OAAA;AACA,IAAAoB,aAAA,GAAApB,OAAA;AAKA,IAAAqB,aAAA,GAAArB,OAAA;AACA,IAAAsB,YAAA,GAAAtB,OAAA;AAEA,IAAAuB,aAAA,GAAAvB,OAAA;AACA,IAAAwB,YAAA,GAAAxB,OAAA;AACA,IAAAyB,OAAA,GAAAzB,OAAA;AACA,IAAA0B,UAAA,GAAA1B,OAAA;AACA,IAAA2B,mBAAA,GAAA3B,OAAA;AACA,IAAA4B,aAAA,GAAA5B,OAAA;AACA,IAAA6B,UAAA,GAAA7B,OAAA;AACA,IAAA8B,YAAA,GAAA9B,OAAA;AACA,IAAA+B,YAAA,GAAA/B,OAAA;AACA,IAAAgC,YAAA,GAAAhC,OAAA;AACA,IAAAiC,gBAAA,GAAAjC,OAAA;AACA,IAAAkC,WAAA,GAAAlC,OAAA;AAEA,IAAAmC,gBAAA,GAAAnC,OAAA;AAIA,IAAAoC,eAAA,GAAApC,OAAA;AAGA,IAAAqC,YAAA,GAAArC,OAAA;AACA,IAAAsC,yBAAA,GAAAtC,OAAA;AACA,IAAAuC,gBAAA,GAAAvC,OAAA;AAoBA,IAAAwC,SAAA,GAAAxC,OAAA;AACA,IAAAyC,OAAA,GAAAzC,OAAA","ignoreList":[]}

package/lib/commonjs/components/Images.js

@@ -4,21 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.NATIVE_MODULE_NAME = exports.Images = void 0;
+var _react = require("react");
 var _reactNative = require("react-native");
 var _jsxRuntime = require("react/jsx-runtime");
 const NATIVE_MODULE_NAME = exports.NATIVE_MODULE_NAME = "MLRNImages";
-function _isUrlOrPath(value) {
-  return (typeof value === "string" || value instanceof String) && (value.startsWith("file://") || value.startsWith("http://") || value.startsWith("https://") || value.startsWith("data:") || value.startsWith("asset://") || value.startsWith("/"));
-}
-function _isImageSourcePropType(value) {
-  if (typeof value === "number" || value instanceof Number) {
-    return true;
-  }
-  const valueAsSource = value;
-  return !!valueAsSource.uri && typeof valueAsSource.uri === "string";
-}
 /**
- * Images defines the images used in Symbol etc layers
+ * Images defines the images used in Symbol layers
  */
 const Images = ({
   images,
@@ -27,45 +18,40 @@ const Images = ({
   id,
   children
 }) => {
-  const _getImages = () => {
-    if (!images && !nativeAssetImages) {
-      return {};
-    }
-    const imagesResult = {};
-    let nativeImages = [];
-    if (images) {
-      const imageNames = Object.keys(images);
-      for (const imageName of imageNames) {
-        const value = images[imageName];
-        if (value && _isUrlOrPath(value)) {
-          imagesResult[imageName] = value;
-        } else if (value && _isImageSourcePropType(value)) {
-          const res = _reactNative.Image.resolveAssetSource(value);
-          if (res && res.uri) {
-            imagesResult[imageName] = res;
+  const props = (0, _react.useMemo)(() => {
+    const getImages = () => {
+      if (!images && !nativeAssetImages) {
+        return {};
+      }
+      const imagesResult = {};
+      if (images) {
+        Object.entries(images).forEach(([imageName, value]) => {
+          if (typeof value === "string") {
+            imagesResult[imageName] = value;
+          } else if (typeof value === "object" && "source" in value && value.source) {
+            imagesResult[imageName] = {
+              ..._reactNative.Image.resolveAssetSource(value.source),
+              sdf: value.sdf
+            };
+          } else {
+            imagesResult[imageName] = _reactNative.Image.resolveAssetSource(value);
           }
-        }
+        });
       }
-    }
-    if (nativeAssetImages) {
-      nativeImages = nativeAssetImages;
-    }
+      return imagesResult;
+    };
     return {
-      images: imagesResult,
-      nativeImages
+      id,
+      hasOnImageMissing: !!onImageMissing,
+      onImageMissing: event => {
+        if (onImageMissing) {
+          onImageMissing(event.nativeEvent.payload.imageKey);
+        }
+      },
+      images: getImages(),
+      nativeImages: nativeAssetImages ?? []
     };
-  };
-  const _onImageMissing = event => {
-    if (onImageMissing) {
-      onImageMissing(event.nativeEvent.payload.imageKey);
-    }
-  };
-  const props = {
-    id,
-    hasOnImageMissing: !!onImageMissing,
-    onImageMissing: _onImageMissing,
-    ..._getImages()
-  };
+  }, [id, onImageMissing, images, nativeAssetImages]);
   return /*#__PURE__*/(0, _jsxRuntime.jsx)(MLRNImages, {
     ...props,
     children: children