@maplibre/maplibre-react-native 11.0.0-alpha.37 → 11.0.0-alpha.38

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

@@ -0,0 +1,172 @@
+package org.maplibre.reactnative.components.images
+
+import android.content.Context
+import android.graphics.Bitmap
+import androidx.core.content.res.ResourcesCompat
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.Event
+import com.facebook.react.uimanager.events.EventDispatcher
+import org.maplibre.android.maps.MapLibreMap
+import org.maplibre.android.utils.BitmapUtils
+import org.maplibre.reactnative.R
+import org.maplibre.reactnative.components.AbstractMapFeature
+import org.maplibre.reactnative.components.mapview.MLRNMapView
+import org.maplibre.reactnative.utils.DownloadMapImageTask
+import org.maplibre.reactnative.utils.ImageEntry
+
+class MLRNImages(
+    context: Context,
+) : AbstractMapFeature(context) {
+    companion object {
+        private var imagePlaceholder: Bitmap? = null
+    }
+
+    private val currentImages = mutableSetOf<String>()
+    private val images = mutableMapOf<String, ImageEntry>()
+    private var map: MapLibreMap? = null
+
+    init {
+        if (imagePlaceholder == null) {
+            imagePlaceholder =
+                BitmapUtils.getBitmapFromDrawable(
+                    ResourcesCompat.getDrawable(context.resources, R.drawable.empty_drawable, null),
+                )
+        }
+    }
+
+    /**
+     * Set unified images.
+     * ImageEntry.uri can be:
+     * - A native asset name (simple name like "pin")
+     * - A URL (starts with http/https/file/asset/data or /)
+     */
+    fun setImages(
+        imagesList: List<Map.Entry<String, ImageEntry>>,
+        context: Context,
+    ) {
+        val newImages = mutableMapOf<String, ImageEntry>()
+
+        for (entry in imagesList) {
+            val key = entry.key
+            val value = entry.value
+            val oldValue = images.put(key, value)
+            if (oldValue == null) {
+                newImages[key] = value
+            }
+        }
+
+        map?.let { mapInstance ->
+            if (mapInstance.style != null) {
+                processImages(newImages, mapInstance, context)
+            }
+        }
+    }
+
+    override fun removeFromMap(mapView: MLRNMapView) {
+        removeImages(mapView)
+        map = null
+        images.clear()
+        currentImages.clear()
+    }
+
+    private fun removeImages(mapView: MLRNMapView) {
+        mapView.getStyle { style ->
+            for (imageName in images.keys) {
+                style.removeImage(imageName)
+            }
+        }
+    }
+
+    override fun addToMap(mapView: MLRNMapView) {
+        // Wait for style before adding the source to the map.
+        // Only then we can pre-load required images/placeholders into the style.
+        mapView.getStyle { _ ->
+            val mapInstance = mapView.mapLibreMap
+            map = mapInstance
+            map?.let {
+                processImages(images, it, context)
+            }
+        }
+    }
+
+    private fun processImages(
+        imagesToProcess: Map<String, ImageEntry>,
+        mapInstance: MapLibreMap,
+        context: Context,
+    ) {
+        if (imagesToProcess.isEmpty()) return
+
+        val style = mapInstance.style ?: return
+        val remoteImages = mutableListOf<Map.Entry<String, ImageEntry>>()
+
+        for ((imageName, entry) in imagesToProcess) {
+            if (hasImage(imageName, mapInstance)) continue
+
+            style.addImage(imageName, imagePlaceholder!!)
+            remoteImages.add(java.util.AbstractMap.SimpleEntry(imageName, entry))
+            currentImages.add(imageName)
+        }
+
+        // Download remote images asynchronously
+        if (remoteImages.isNotEmpty()) {
+            val task = DownloadMapImageTask(context, mapInstance, null)
+            task.execute(*remoteImages.toTypedArray())
+        }
+    }
+
+    fun addMissingImageToStyle(
+        id: String,
+        mapInstance: MapLibreMap,
+    ): Boolean {
+        val entry = images[id] ?: return false
+        val style = mapInstance.style ?: return false
+
+        style.addImage(id, imagePlaceholder!!)
+        val task = DownloadMapImageTask(context, mapInstance, null)
+        task.execute(java.util.AbstractMap.SimpleEntry(id, entry))
+
+        currentImages.add(id)
+        return true
+    }
+
+    val eventDispatcher: EventDispatcher?
+        get() {
+            val reactContext = context as ReactContext
+
+            return UIManagerHelper.getEventDispatcherForReactTag(reactContext, id)
+        }
+
+    val surfaceId: Int
+        get() {
+            val reactContext = context as ReactContext
+
+            return UIManagerHelper.getSurfaceId(reactContext)
+        }
+
+    inner class OnImageMissingEvent(
+        private val eventData: WritableMap,
+    ) : Event<OnImageMissingEvent>(this@MLRNImages.surfaceId, this@MLRNImages.id) {
+        override fun getEventName() = "onImageMissing"
+
+        override fun getEventData() = eventData
+    }
+
+    fun sendImageMissingEvent(image: String) {
+        val writableMap = Arguments.createMap()
+        writableMap.putString("image", image)
+
+        eventDispatcher?.dispatchEvent(OnImageMissingEvent(writableMap))
+    }
+
+    private fun hasImage(
+        imageId: String,
+        mapInstance: MapLibreMap,
+    ): Boolean {
+        val style = mapInstance.style
+
+        return style?.getImage(imageId) != null
+    }
+}

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

@@ -0,0 +1,73 @@
+package org.maplibre.reactnative.components.images
+
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.MLRNImagesManagerDelegate
+import com.facebook.react.viewmanagers.MLRNImagesManagerInterface
+import org.maplibre.reactnative.utils.ImageEntry
+
+@ReactModule(name = MLRNImagesManager.REACT_CLASS)
+class MLRNImagesManager(
+    private val context: ReactApplicationContext,
+) : ViewGroupManager<MLRNImages>(),
+    MLRNImagesManagerInterface<MLRNImages> {
+    companion object {
+        const val REACT_CLASS = "MLRNImages"
+    }
+
+    private val delegate: MLRNImagesManagerDelegate<MLRNImages, MLRNImagesManager> =
+        MLRNImagesManagerDelegate(this)
+
+    override fun getDelegate(): ViewManagerDelegate<MLRNImages> = delegate
+
+    override fun getName(): String = REACT_CLASS
+
+    override fun createViewInstance(context: ThemedReactContext): MLRNImages = MLRNImages(context)
+
+    @ReactProp(name = "images")
+    override fun setImages(
+        view: MLRNImages,
+        value: Dynamic,
+    ) {
+        val readableMap = value.asMap()
+
+        if (readableMap == null) {
+            view.setImages(emptyList(), context)
+            return
+        }
+
+        val imagesList = mutableListOf<Map.Entry<String, ImageEntry>>()
+        val iterator = readableMap.keySetIterator()
+
+        while (iterator.hasNextKey()) {
+            val imageName = iterator.nextKey()
+            val imageEntry: ImageEntry =
+                when (readableMap.getType(imageName)) {
+                    ReadableType.Map -> {
+                        val imageMap = readableMap.getMap(imageName)!!
+
+                        val uri = imageMap.getString("uri")
+                        val scale =
+                            if (imageMap.hasKey("scale")) imageMap.getDouble("scale") else null
+                        val sdf = imageMap.hasKey("sdf") && imageMap.getBoolean("sdf")
+
+                        ImageEntry(uri, scale, sdf)
+                    }
+
+                    else -> {
+                        continue
+                    }
+                }
+
+            imagesList.add(java.util.AbstractMap.SimpleEntry(imageName, imageEntry))
+        }
+
+        view.setImages(imagesList, context)
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/components/layers/style/MLRNStyle.java

@@ -57,7 +57,7 @@ public class MLRNStyle {
     }
 
     public ImageEntry imageEntry(MLRNStyleValue styleValue) {
-        return new ImageEntry(styleValue.getImageURI(), styleValue.getImageScale());
+        return new ImageEntry(styleValue.getImageURI(), styleValue.getImageScale(), false);
     }
 
     public void addImage(MLRNStyleValue styleValue, DownloadMapImageTask.OnAllImagesLoaded callback) {

package/android/src/main/java/org/maplibre/reactnative/components/layers/style/MLRNStyleValue.java

@@ -22,7 +22,7 @@ public class MLRNStyleValue {
 
     private String imageURI = "";
     private boolean isAddImage;
-    private Double imageScale = ImageEntry.defaultScale;
+    private Double imageScale = ImageEntry.DEFAULT_SCALE;
 
     public static final int InterpolationModeExponential = 100;
     public static final int InterpolationModeInterval = 101;
@@ -34,7 +34,7 @@ public class MLRNStyleValue {
         mPayload = config.getMap("stylevalue");
 
         if ("image".equals(mType)) {
-            imageScale = ImageEntry.defaultScale;
+            imageScale = ImageEntry.DEFAULT_SCALE;
             if ("hashmap".equals(mPayload.getString("type"))) {
                 ReadableMap map = getMap();
                 imageURI = map.getMap("uri").getString("value");

package/android/src/main/java/org/maplibre/reactnative/components/mapview/MLRNMapView.kt

@@ -710,8 +710,9 @@ open class MLRNMapView(
                 return
             }
         }
+
         for (images in images) {
-            images.sendImageMissingEvent(id, this.mapLibreMap!!)
+            images.sendImageMissingEvent(id)
         }
     }
 

package/android/src/main/java/org/maplibre/reactnative/events/constants/EventKeys.java

@@ -15,9 +15,6 @@ public class EventKeys {
     public static final String POINT_ANNOTATION_DRAG = ns("pointannotation.drag");
     public static final String POINT_ANNOTATION_DRAG_END = ns("pointannotation.dragend");
 
-    // images event
-    public static final String IMAGES_MISSING = ns("images.missing");
-
 
     private static String ns(String name) {
         return String.format("%s.%s", NAMESPACE, name);

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

@@ -20,6 +20,7 @@ import com.facebook.imagepipeline.image.CloseableStaticBitmap;
 import com.facebook.imagepipeline.request.ImageRequest;
 import com.facebook.imagepipeline.request.ImageRequestBuilder;
 import com.facebook.react.views.imagehelper.ImageSource;
+
 import org.maplibre.android.maps.MapLibreMap;
 import org.maplibre.android.maps.Style;
 
@@ -27,7 +28,6 @@ import java.io.File;
 import java.lang.ref.WeakReference;
 import java.util.AbstractMap;
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
@@ -94,7 +94,7 @@ public class DownloadMapImageTask extends AsyncTask<Map.Entry<String, ImageEntry
                                 // Copy the bitmap to make sure it doesn't get recycled when we release
                                 // the fresco reference.
                                 .copy(Bitmap.Config.ARGB_8888, true);
-                            bitmap.setDensity((int) ((double) DisplayMetrics.DENSITY_DEFAULT * imageEntry.getScaleOr(1.0)));
+                            bitmap.setDensity((int) ((double) DisplayMetrics.DENSITY_DEFAULT * imageEntry.scale));
                             images.add(new AbstractMap.SimpleEntry<>(object.getKey(), new DownloadedImage(object.getKey(), bitmap, imageEntry)));
                         } else {
                             FLog.e(LOG_TAG, "Failed to load bitmap from: " + uri);
@@ -111,7 +111,7 @@ public class DownloadMapImageTask extends AsyncTask<Map.Entry<String, ImageEntry
                     }
                 }
             } else {
-                // local asset required from JS require('image.png') or import icon from 'image.png' while in release mode
+                // 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(), new DownloadedImage(object.getKey(), bitmap, imageEntry)));
@@ -145,9 +145,11 @@ public class DownloadMapImageTask extends AsyncTask<Map.Entry<String, ImageEntry
         BitmapFactory.Options options = new BitmapFactory.Options();
         options.inScreenDensity = metrics.densityDpi;
         options.inTargetDensity = metrics.densityDpi;
-        if (scale != ImageEntry.defaultScale) {
+
+        if (scale != ImageEntry.DEFAULT_SCALE) {
             options.inDensity = (int) ((double) DisplayMetrics.DENSITY_DEFAULT * scale);
         }
+
         return options;
     }
 }

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

@@ -0,0 +1,14 @@
+package org.maplibre.reactnative.utils
+
+class ImageEntry(
+    @JvmField var uri: String?,
+    scale: Double?,
+    @JvmField var sdf: Boolean,
+) {
+    @JvmField
+    var scale: Double = scale ?: DEFAULT_SCALE
+
+    companion object {
+        const val DEFAULT_SCALE: Double = 1.0
+    }
+}

package/ios/components/images/MLRNImageQueueOperation.m

@@ -100,23 +100,28 @@ 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) {
-                                if (image && weakSelf.sdf) {
-                                  image = [image
-                                      imageWithRenderingMode:UIImageRenderingModeAlwaysTemplate];
-                                }
-                                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:^(int64_t progress, int64_t total) {
+                                   // No-op
+                                 }
+                                 partialLoadBlock:^(UIImage *image) {
+                                   // No-op
+                                 }
+                                 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/components/images/MLRNImages.h

@@ -10,15 +10,20 @@
 
 @property (nonatomic, weak) RCTBridge *bridge;
 
-@property (nonatomic, strong) MLRNMapView *map;
+@property (nonatomic, strong) MLRNMapView * _Nullable map;
+@property (nonatomic, strong, nonnull) NSMutableArray<id<RCTComponent>> *reactSubviews;
 
-@property (nonatomic, strong) NSDictionary<NSString *, NSString *> *images;
-@property (nonatomic, strong) NSArray<NSString *> *nativeImages;
+@property (nonatomic, strong, nonnull) NSDictionary * images;
 
-@property (nonatomic, copy) RCTBubblingEventBlock onImageMissing;
-@property (nonatomic, assign) BOOL hasOnImageMissing;
+@property (nonatomic, copy, nullable) RCTDirectEventBlock onImageMissing;
 
-- (BOOL)addMissingImageToStyle:(NSString *)imageName;
-- (void)sendImageMissingEvent:(NSString *)imageName;
+- (void)addToMap;
+- (void)removeFromMap;
+
+- (BOOL)addMissingImageToStyle:(NSString *_Nonnull)imageName;
+- (void)sendImageMissingEvent:(NSString *_Nonnull)imageName;
+
+- (void)insertReactSubview:(id<RCTComponent>_Nullable)subview atIndex:(NSInteger)atIndex;
+- (void)removeReactSubview:(id<RCTComponent>_Nullable)subview;
 
 @end

package/ios/components/images/MLRNImages.m

@@ -9,76 +9,149 @@
 
 static UIImage *_placeHolderImage;
 
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    _reactSubviews = [[NSMutableArray alloc] init];
+  }
+  return self;
+}
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wobjc-missing-super-calls"
+- (void)insertReactSubview:(id<RCTComponent>)subview atIndex:(NSInteger)atIndex {
+  [_reactSubviews insertObject:subview atIndex:atIndex];
+}
+#pragma clang diagnostic pop
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wobjc-missing-super-calls"
+- (void)removeReactSubview:(id<RCTComponent>)subview {
+  [_reactSubviews removeObject:subview];
+}
+#pragma clang diagnostic pop
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wobjc-missing-super-calls"
+- (NSArray<id<RCTComponent>> *)reactSubviews {
+  return _reactSubviews;
+}
+#pragma clang diagnostic pop
+
 - (void)addToMap {
   if (self.map.style == nil) {
     return;
   }
-  [self _addNativeImages:_nativeImages];
-  [self _addRemoteImages:_images];
+  [self _processImages:_images];
 }
 
 - (void)removeFromMap {
   if (self.map.style == nil) {
     return;
   }
-
   [self _removeImages];
 }
 
 - (void)_removeImages {
-  if ([self _hasImages]) {
-    NSArray<NSString *> *imageNames = _images.allKeys;
+  if (_images == nil || _images.count == 0) {
+    return;
+  }
 
-    for (NSString *imageName in imageNames) {
-      [self.map.style removeImageForName:imageName];
-    }
+  for (NSString *imageName in _images.allKeys) {
+    [self.map.style removeImageForName:imageName];
   }
+}
+
+- (BOOL)_isNativeImageString:(NSString *)value {
+  return [UIImage imageNamed:value] != nil;
+}
+
+- (void)_processImages:(NSDictionary *)images {
+  if (!images || images.count == 0) return;
 
-  if ([self _hasNativeImages]) {
-    for (NSString *imageName in _nativeImages) {
-      [self.map.style removeImageForName:imageName];
+  NSMutableDictionary *nativeAssets = [NSMutableDictionary new];
+  NSMutableDictionary *remoteImages = [NSMutableDictionary new];
+
+  for (NSString *imageName in images.allKeys) {
+    id value = images[imageName];
+
+    if ([value isKindOfClass:[NSString class]]) {
+      NSString *stringValue = (NSString *)value;
+      if ([self _isNativeImageString:stringValue]) {
+        nativeAssets[imageName] = stringValue;
+      } else {
+        remoteImages[imageName] = @{@"uri" : stringValue};
+      }
+    } else if ([value isKindOfClass:[NSDictionary class]]) {
+      remoteImages[imageName] = value;
     }
   }
+
+  // Add native assets first (synchronous)
+  if (nativeAssets.count > 0) {
+    [self _addNativeImages:nativeAssets];
+  }
+
+  // Then add remote images (may be async)
+  if (remoteImages.count > 0) {
+    [self _addRemoteImages:remoteImages];
+  }
 }
 
 - (BOOL)addMissingImageToStyle:(NSString *)imageName {
-  if (_nativeImages && [_nativeImages containsObject:imageName]) {
-    [self _addNativeImages:@[ imageName ]];
-    return true;
-  }
+  if (_images == nil) return false;
+
+  id value = _images[imageName];
+  if (value == nil) return false;
 
-  NSString *remoteImage = _images != nil ? [_images objectForKey:imageName] : nil;
-  if (remoteImage) {
-    [self _addRemoteImages:@{imageName : remoteImage}];
+  if ([value isKindOfClass:[NSString class]]) {
+    NSString *stringValue = (NSString *)value;
+    if ([self _isNativeImageString:stringValue]) {
+      [self _addNativeImages:@{imageName : stringValue}];
+    } else {
+      [self _addRemoteImages:@{imageName : @{@"uri" : stringValue}}];
+    }
+    return true;
+  } else if ([value isKindOfClass:[NSDictionary class]]) {
+    [self _addRemoteImages:@{imageName : value}];
     return true;
   }
+
   return false;
 }
 
 - (void)sendImageMissingEvent:(NSString *)imageName {
-  NSDictionary *payload = @{@"imageKey" : imageName};
+  NSDictionary *payload = @{@"image" : imageName};
   MLRNEvent *event = [MLRNEvent makeEvent:RCT_MLRN_MISSING_IMAGE withPayload:payload];
   if (_onImageMissing) {
     _onImageMissing([event toJSON]);
   }
 }
 
-- (void)_addNativeImages:(NSArray<NSString *> *)nativeImages {
-  if (!nativeImages) return;
+- (void)_addNativeImages:(NSDictionary *)nativeImages {
+  if (!nativeImages || nativeImages.count == 0) return;
 
-  for (NSString *imageName in nativeImages) {
-    // only add native images if they are not in the style yet (similar to [MLRNUtils fetchImages:
-    // style:])
+  for (NSString *imageName in nativeImages.allKeys) {
     if (![self.map.style imageForName:imageName]) {
-      UIImage *image = [UIImage imageNamed:imageName];
-      [self.map.style setImage:image forName:imageName];
+      // Get the asset name from the dictionary value
+      NSString *assetName = nativeImages[imageName];
+      if ([assetName isKindOfClass:[NSString class]]) {
+        UIImage *image = [UIImage imageNamed:assetName];
+        if (image) {
+          [self.map.style setImage:image forName:imageName];
+        }
+      }
     }
   }
 }
 
-- (void)_addRemoteImages:(NSDictionary<NSString *, NSString *> *)remoteImages {
-  if (!remoteImages) return;
-  NSDictionary<NSString *, NSString *> *missingImages = [NSMutableDictionary new];
+/**
+ * Add remote images with async loading.
+ * remoteImages is a dictionary where values are { uri: string, scale?: number, sdf?: boolean }
+ */
+- (void)_addRemoteImages:(NSDictionary *)remoteImages {
+  if (!remoteImages || remoteImages.count == 0) return;
+
+  NSMutableDictionary *missingImages = [NSMutableDictionary new];
 
   // Add image placeholder for images that are not yet available in the style. This way
   // we can load the images asynchronously and add the GeoJSONSource to the map without delay.
@@ -90,7 +163,7 @@ static UIImage *_placeHolderImage;
   for (NSString *imageName in remoteImages.allKeys) {
     if (![self.map.style imageForName:imageName]) {
       [self.map.style setImage:[MLRNImages placeholderImage] forName:imageName];
-      [missingImages setValue:_images[imageName] forKey:imageName];
+      missingImages[imageName] = remoteImages[imageName];
     }
   }
 
@@ -98,21 +171,13 @@ static UIImage *_placeHolderImage;
     // forceUpdate to ensure the placeholder images are updated
     [MLRNUtils fetchImages:_bridge
                      style:self.map.style
-                   objects:_images
+                   objects:missingImages
                forceUpdate:true
                   callback:^{
                   }];
   }
 }
 
-- (BOOL)_hasImages {
-  return _images != nil && _images.count > 0;
-}
-
-- (BOOL)_hasNativeImages {
-  return _nativeImages != nil && _nativeImages.count > 0;
-}
-
 + (UIImage *)placeholderImage {
   if (_placeHolderImage) return _placeHolderImage;
   UIGraphicsBeginImageContextWithOptions(CGSizeMake(1, 1), NO, 0.0);

package/ios/components/images/MLRNImagesComponentView.h

@@ -0,0 +1,9 @@
+#import <React/RCTViewComponentView.h>
+
+@class MLRNImages;
+
+@interface MLRNImagesComponentView : RCTViewComponentView
+
+@property (nonatomic, readonly) MLRNImages *images;
+
+@end