@maplibre/maplibre-react-native 10.4.0 → 11.0.0-alpha.10

package/android/src/main/java/org/maplibre/reactnative/modules/MLRNModule.java

@@ -3,20 +3,15 @@ package org.maplibre.reactnative.modules;
 import android.os.Handler;
 import android.util.Log;
 
-import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.common.MapBuilder;
 import com.facebook.react.module.annotations.ReactModule;
+
 import org.maplibre.android.MapLibre;
-import org.maplibre.android.WellKnownTileServer;
-import org.maplibre.reactnative.components.camera.constants.CameraMode;
-import org.maplibre.reactnative.components.styles.sources.MLRNSource;
-import org.maplibre.reactnative.events.constants.EventTypes;
+import org.maplibre.reactnative.components.sources.MLRNSource;
 import org.maplibre.reactnative.http.CustomHeadersInterceptor;
-import org.maplibre.reactnative.location.UserLocationVerticalAlignment;
-import org.maplibre.reactnative.location.UserTrackingMode;
 
 import okhttp3.Dispatcher;
 import okhttp3.OkHttpClient;
@@ -61,45 +56,6 @@ public class MLRNModule extends ReactContextBaseJavaModule {
         Map<String, String> styleURLS = new HashMap<>();
         styleURLS.put("Default", DEFAULT_STYLE_URL);
 
-        // events
-        Map<String, String> eventTypes = new HashMap<>();
-        eventTypes.put("MapClick", EventTypes.MAP_CLICK);
-        eventTypes.put("MapLongClick", EventTypes.MAP_LONG_CLICK);
-        eventTypes.put("RegionWillChange", EventTypes.REGION_WILL_CHANGE);
-        eventTypes.put("RegionIsChanging", EventTypes.REGION_IS_CHANGING);
-        eventTypes.put("RegionDidChange", EventTypes.REGION_DID_CHANGE);
-        eventTypes.put("UserLocationUpdated", EventTypes.USER_LOCATION_UPDATED);
-        eventTypes.put("WillStartLoadingMap", EventTypes.WILL_START_LOADING_MAP);
-        eventTypes.put("DidFinishLoadingMap", EventTypes.DID_FINISH_LOADING_MAP);
-        eventTypes.put("DidFailLoadingMap", EventTypes.DID_FAIL_LOADING_MAP);
-        eventTypes.put("WillStartRenderingFrame", EventTypes.WILL_START_RENDERING_FRAME);
-        eventTypes.put("DidFinishRenderingFrame", EventTypes.DID_FINISH_RENDERING_FRAME);
-        eventTypes.put("DidFinishRenderingFrameFully", EventTypes.DID_FINISH_RENDERING_FRAME_FULLY);
-        eventTypes.put("WillStartRenderingMap", EventTypes.WILL_START_RENDERING_MAP);
-        eventTypes.put("DidFinishRenderingMap", EventTypes.DID_FINISH_RENDERING_MAP);
-        eventTypes.put("DidFinishRenderingMapFully", EventTypes.DID_FINISH_RENDERING_MAP_FULLY);
-        eventTypes.put("DidFinishLoadingStyle", EventTypes.DID_FINISH_LOADING_STYLE);
-
-        // user tracking modes
-        Map<String, Integer> userTrackingModes = new HashMap<>();
-        userTrackingModes.put("None", UserTrackingMode.NONE);
-        userTrackingModes.put("Follow", UserTrackingMode.FOLLOW);
-        userTrackingModes.put("FollowWithCourse", UserTrackingMode.FollowWithCourse);
-        userTrackingModes.put("FollowWithHeading", UserTrackingMode.FollowWithHeading);
-
-        // user location vertical alignment
-        Map<String, Integer> userLocationVerticalAlignment = new HashMap<>();
-        userLocationVerticalAlignment.put("Center", UserLocationVerticalAlignment.CENTER);
-        userLocationVerticalAlignment.put("Top", UserLocationVerticalAlignment.TOP);
-        userLocationVerticalAlignment.put("Bottom", UserLocationVerticalAlignment.BOTTOM);
-
-        // camera modes
-        Map<String, Integer> cameraModes = new HashMap<>();
-        cameraModes.put("Flight", CameraMode.FLIGHT);
-        cameraModes.put("Ease", CameraMode.EASE);
-        cameraModes.put("Linear", CameraMode.LINEAR);
-        cameraModes.put("None", CameraMode.NONE);
-
         // style source constants
         Map<String, String> styleSourceConsts = new HashMap<>();
         styleSourceConsts.put("DefaultSourceID", MLRNSource.DEFAULT_ID);
@@ -121,10 +77,6 @@ public class MLRNModule extends ReactContextBaseJavaModule {
 
         return MapBuilder.<String, Object>builder()
                 .put("StyleURL", styleURLS)
-                .put("EventTypes", eventTypes)
-                .put("UserTrackingModes", userTrackingModes)
-                .put("UserLocationVerticalAlignment", userLocationVerticalAlignment)
-                .put("CameraModes", cameraModes)
                 .put("StyleSource", styleSourceConsts)
                 .put("OfflinePackDownloadState", offlinePackDownloadStates)
                 .put("OfflineCallbackName", offlineModuleCallbackNames)
@@ -132,25 +84,6 @@ public class MLRNModule extends ReactContextBaseJavaModule {
                 .build();
     }
 
-    /**
-     * @deprecated This will be removed in the next major version.
-     * @see https://github.com/maplibre/maplibre-react-native/issues/25#issuecomment-1382382044
-     */
-    @Deprecated
-    @ReactMethod
-    public void setAccessToken(final String accessToken) {
-        mReactContext.runOnUiQueueThread(new Runnable() {
-            @Override
-            public void run() {
-                if (accessToken == null) {
-                    MapLibre.getInstance(getReactApplicationContext());
-                } else {
-                    MapLibre.getInstance(getReactApplicationContext(), accessToken, WellKnownTileServer.Mapbox);
-                }
-            }
-        });
-    }
-
     @ReactMethod
     public void removeCustomHeader(final String headerName) {
         mReactContext.runOnUiQueueThread(new Runnable() {
@@ -179,21 +112,6 @@ public class MLRNModule extends ReactContextBaseJavaModule {
         });
     }
 
-    /**
-     * @deprecated This will be removed in the next major version.
-     * @see https://github.com/maplibre/maplibre-react-native/issues/25#issuecomment-1382382044
-     */
-    @Deprecated
-    @ReactMethod
-    public void getAccessToken(Promise promise) {
-        String token = MapLibre.getApiKey();
-        if(token == null) {
-            promise.reject("missing_access_token", "No access token has been set");
-        } else {
-            promise.resolve(token);
-        }
-    }
-
     @ReactMethod
     public void setConnected(final boolean connected) {
         mReactContext.runOnUiQueueThread(new Runnable() {

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

@@ -0,0 +1,114 @@
+package org.maplibre.reactnative.modules
+
+import android.graphics.Bitmap
+import android.util.Log
+import android.util.TypedValue
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.module.annotations.ReactModule
+import org.maplibre.android.camera.CameraPosition
+import org.maplibre.android.maps.Style
+import org.maplibre.android.snapshotter.MapSnapshot
+import org.maplibre.android.snapshotter.MapSnapshotter
+import org.maplibre.geojson.Feature
+import org.maplibre.geojson.FeatureCollection
+import org.maplibre.geojson.Point
+import org.maplibre.reactnative.NativeSnapshotModuleSpec
+import org.maplibre.reactnative.utils.BitmapUtils
+import org.maplibre.reactnative.utils.GeoJSONUtils
+import java.util.UUID
+
+@ReactModule(name = MLRNSnapshotModule.NAME)
+class MLRNSnapshotModule(reactContext: ReactApplicationContext) :
+    NativeSnapshotModuleSpec(reactContext) {
+    companion object {
+        const val NAME = "MLRNSnapshotModule"
+    }
+
+    override fun getName() = NAME
+
+    private val context: ReactApplicationContext = reactContext
+
+    // Prevent garbage collection
+    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(context, getOptions(jsOptions))
+            snapshotterMap[snapshotterID] = snapshotter
+            snapshotter.start(object :
+                MapSnapshotter.SnapshotReadyCallback {
+                override fun onSnapshotReady(snapshot: MapSnapshot) {
+                    val bitmap: Bitmap = snapshot.bitmap
+                    val result: String? = if (jsOptions.getBoolean("writeToDisk")) {
+                        BitmapUtils.createTempFile(
+                            context, bitmap
+                        )
+                    } else {
+                        BitmapUtils.createBase64(bitmap)
+                    }
+
+                    if (result == null) {
+                        promise.reject(
+                            NAME,
+                            "Could not generate snapshot, please check Android logs for more info."
+                        )
+                        return
+                    }
+
+                    promise.resolve(result)
+                    snapshotterMap.remove(snapshotterID)
+                }
+            }) { error ->
+                Log.w(NAME, error)
+                snapshotterMap.remove(snapshotterID)
+            }
+        }
+    }
+
+    private fun getOptions(jsOptions: ReadableMap): MapSnapshotter.Options {
+        val options: MapSnapshotter.Options =
+            MapSnapshotter.Options(
+                jsOptions.getDouble("width").toInt(), jsOptions.getDouble("height").toInt()
+            )
+
+        options.withLogo(jsOptions.getBoolean("withLogo"))
+        jsOptions.getString("styleURL")?.let { styleUrl ->
+            options.withStyleBuilder(
+                Style.Builder().fromUri(styleUrl)
+            )
+        }
+        options.withPixelRatio(
+            TypedValue.applyDimension(
+                TypedValue.COMPLEX_UNIT_DIP,
+                1f,
+                context.resources.displayMetrics
+            )
+        )
+
+        if (jsOptions.hasKey("bounds")) {
+            val bounds = jsOptions.getString("bounds")?.let { boundsStr ->
+                FeatureCollection.fromJson(boundsStr)
+            }
+            bounds?.let {
+                options.withRegion(GeoJSONUtils.toLatLngBounds(it))
+            }
+        } else {
+            val centerPoint = jsOptions.getString("centerCoordinate")?.let { coordStr ->
+                Feature.fromJson(coordStr)
+            }
+            val cameraPosition: CameraPosition =
+                CameraPosition.Builder()
+                    .target(GeoJSONUtils.toLatLng(centerPoint?.geometry() as Point?))
+                    .tilt(jsOptions.getDouble("pitch")).bearing(jsOptions.getDouble("heading"))
+                    .zoom(jsOptions.getDouble("zoomLevel")).build()
+            options.withCameraPosition(cameraPosition)
+        }
+
+        return options
+    }
+}

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

@@ -203,15 +203,8 @@ public class ConvertUtils {
         return list;
     }
 
-    public static PointF toPointF(ReadableArray array) {
-        PointF pointF = new PointF();
-
-        if (array == null) {
-            return pointF;
-        }
-
-        pointF.set((float)array.getDouble(0), (float)array.getDouble(1));
-        return pointF;
+    public static PointF toPointF(ReadableMap map) {
+        return new PointF((float) map.getDouble("locationX"), (float) map.getDouble("locationY"));
     }
 
     public static RectF toRectF(ReadableArray array) {

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

@@ -0,0 +1,322 @@
+package org.maplibre.reactnative.utils
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeArray
+import com.facebook.react.bridge.WritableNativeMap
+import org.maplibre.android.geometry.LatLng
+import org.maplibre.android.geometry.LatLngBounds
+import org.maplibre.android.geometry.LatLngQuad
+import org.maplibre.android.log.Logger
+import org.maplibre.geojson.Feature
+import org.maplibre.geojson.FeatureCollection
+import org.maplibre.geojson.Geometry
+import org.maplibre.geojson.GeometryCollection
+import org.maplibre.geojson.LineString
+import org.maplibre.geojson.MultiLineString
+import org.maplibre.geojson.MultiPoint
+import org.maplibre.geojson.MultiPolygon
+import org.maplibre.geojson.Point
+import org.maplibre.geojson.Polygon
+import org.maplibre.turf.TurfMeasurement
+import java.util.stream.Collectors
+
+object GeoJSONUtils {
+    const val LOG_TAG: String = "GeoJSONUtils"
+
+    @JvmStatic
+    fun fromFeature(feature: Feature): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "Feature")
+        map.putString("id", feature.id())
+
+        val geometry = feature.geometry()
+        if (geometry == null) {
+            map.putNull("geometry")
+        } else {
+            map.putMap("geometry", fromGeometry(geometry))
+        }
+
+        val properties = feature.properties()
+        if (properties == null) {
+            map.putNull("properties")
+        } else {
+            map.putMap("properties", ConvertUtils.toWritableMap(properties))
+        }
+
+        return map
+    }
+
+    fun fromGeometry(geometry: Geometry): WritableMap? {
+        val type = geometry.type()
+
+        return when (type) {
+            "Point" -> fromPoint(geometry as Point)
+            "LineString" -> fromLineString(geometry as LineString)
+            "Polygon" -> fromPolygon(geometry as Polygon)
+            "MultiPoint" -> fromMultiPoint(geometry as MultiPoint)
+            "MultiLineString" -> fromMultiLineString(geometry as MultiLineString)
+            "MultiPolygon" -> fromMultiPolygon(geometry as MultiPolygon)
+            "GeometryCollection" -> fromGeometryCollection(geometry as GeometryCollection)
+            else -> {
+                Logger.w(LOG_TAG, "GeoJSONUtils.fromGeometry unsupported type: \"$type\"")
+
+                null
+            }
+        }
+    }
+
+    fun fromPoint(point: Point?): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "Point")
+        map.putArray("coordinates", getCoordinates(point))
+        return map
+    }
+
+    fun fromLineString(lineString: LineString): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "LineString")
+        map.putArray("coordinates", getCoordinates(lineString))
+        return map
+    }
+
+    fun fromPolygon(polygon: Polygon): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "Polygon")
+        map.putArray("coordinates", getCoordinates(polygon))
+        return map
+    }
+
+    fun fromMultiPoint(multiPoint: MultiPoint): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "MultiPoint")
+        map.putArray("coordinates", getCoordinates(multiPoint))
+        return map
+    }
+
+    fun fromMultiLineString(multiLineString: MultiLineString): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "MultiLineString")
+        map.putArray("coordinates", getCoordinates(multiLineString))
+        return map
+    }
+
+    fun fromMultiPolygon(multiPolygon: MultiPolygon): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "MultiPolygon")
+        map.putArray("coordinates", getCoordinates(multiPolygon))
+        return map
+    }
+
+    fun fromGeometryCollection(geometryCollection: GeometryCollection): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "GeometryCollection")
+
+        map.putArray(
+            "geometries",
+            Arguments.fromList(
+                geometryCollection.geometries().stream()
+                    .map<WritableMap?> { obj: Geometry -> fromGeometry(obj) }
+                    .collect(Collectors.toList())))
+
+        return map
+    }
+
+    fun getCoordinates(point: Point?): WritableArray {
+        return Arguments.fromArray(pointToDoubleArray(point))
+    }
+
+    fun getCoordinates(lineString: LineString): WritableArray {
+        val array = Arguments.createArray()
+
+        val points = lineString.coordinates()
+        for (point in points) {
+            array.pushArray(Arguments.fromArray(pointToDoubleArray(point)))
+        }
+
+        return array
+    }
+
+    fun getCoordinates(polygon: Polygon): WritableArray {
+        val array = Arguments.createArray()
+
+        val points = polygon.coordinates()
+
+        for (curPoint in points) {
+            val innerArray = Arguments.createArray()
+
+            for (point in curPoint) {
+                innerArray.pushArray(Arguments.fromArray(pointToDoubleArray(point)))
+            }
+
+            array.pushArray(innerArray)
+        }
+
+        return array
+    }
+
+    fun getCoordinates(multiPoint: MultiPoint): WritableArray {
+        val array = Arguments.createArray()
+
+        val points = multiPoint.coordinates()
+        for (point in points) {
+            array.pushArray(Arguments.fromArray(pointToDoubleArray(point)))
+        }
+
+        return array
+    }
+
+    fun getCoordinates(multiLineString: MultiLineString): WritableArray {
+        val array = Arguments.createArray()
+
+        val lines = multiLineString.coordinates()
+        for (line in lines) {
+            val lineArray = Arguments.createArray()
+
+            for (point in line) {
+                lineArray.pushArray(Arguments.fromArray(pointToDoubleArray(point)))
+            }
+
+            array.pushArray(lineArray)
+        }
+
+        return array
+    }
+
+    fun getCoordinates(multiPolygon: MultiPolygon): WritableArray {
+        val array = Arguments.createArray()
+
+        val polygons = multiPolygon.coordinates()
+        for (polygon in polygons) {
+            val polygonArray = Arguments.createArray()
+
+            for (ring in polygon) {
+                val ringArray = Arguments.createArray()
+
+                for (point in ring!!) {
+                    ringArray.pushArray(Arguments.fromArray(pointToDoubleArray(point)))
+                }
+
+                polygonArray.pushArray(ringArray)
+            }
+
+            array.pushArray(polygonArray)
+        }
+
+        return array
+    }
+
+    @JvmStatic
+    fun toPointFeature(latLng: LatLng, properties: WritableMap?): WritableMap {
+        val map: WritableMap = WritableNativeMap()
+        map.putString("type", "Feature")
+        map.putMap("geometry", toPointGeometry(latLng))
+        map.putMap("properties", properties)
+        return map
+    }
+
+    fun toPointGeometry(latLng: LatLng): WritableMap {
+        val geometry: WritableMap = WritableNativeMap()
+        geometry.putString("type", "Point")
+        geometry.putArray("coordinates", fromLatLng(latLng))
+        return geometry
+    }
+
+    fun fromLatLng(latLng: LatLng): WritableArray {
+        val coords = doubleArrayOf(latLng.longitude, latLng.latitude)
+        val writableCoords: WritableArray = WritableNativeArray()
+        writableCoords.pushDouble(coords[0])
+        writableCoords.pushDouble(coords[1])
+        return writableCoords
+    }
+
+    @JvmStatic
+    fun toLatLng(point: Point?): LatLng? {
+        if (point == null) {
+            return null
+        }
+        return LatLng(point.latitude(), point.longitude())
+    }
+
+    fun toLatLng(coordinates: ReadableArray?): LatLng? {
+        if (coordinates == null || coordinates.size() < 2) {
+            return null
+        }
+        return LatLng(coordinates.getDouble(1), coordinates.getDouble(0))
+    }
+
+    @JvmStatic
+    fun toPointGeometry(featureJSONString: String): Point? {
+        val feature = Feature.fromJson(featureJSONString)
+        if (feature == null) {
+            return null
+        }
+        return feature.geometry() as Point?
+    }
+
+    @JvmStatic
+    fun fromLatLngBounds(latLngBounds: LatLngBounds): WritableArray {
+        val array = Arguments.createArray()
+        array.pushDouble(latLngBounds.getLonWest())
+        array.pushDouble(latLngBounds.getLatSouth())
+        array.pushDouble(latLngBounds.getLonEast())
+        array.pushDouble(latLngBounds.getLatNorth())
+
+        return array
+    }
+
+    private fun toGeometryCollection(features: MutableList<Feature>): GeometryCollection {
+        val geometries = ArrayList<Geometry?>()
+        geometries.ensureCapacity(features.size)
+        for (feature in features) {
+            geometries.add(feature.geometry())
+        }
+        return GeometryCollection.fromGeometries(geometries)
+    }
+
+    @JvmStatic
+    fun toLatLngBounds(featureCollection: FeatureCollection): LatLngBounds {
+        val features = featureCollection.features()
+
+        val bbox = TurfMeasurement.bbox(toGeometryCollection(features!!))
+
+        return LatLngBounds.from(bbox[3], bbox[2], bbox[1], bbox[0])
+    }
+
+    @JvmStatic
+    fun toLatLngBounds(array: ReadableArray?): LatLngBounds? {
+        if (array != null && array.size() == 4) {
+            return LatLngBounds.from(
+                array.getDouble(3),
+                array.getDouble(2),
+                array.getDouble(1),
+                array.getDouble(0)
+            )
+        }
+
+        return null;
+    }
+
+    @JvmStatic
+    fun toLatLngQuad(array: ReadableArray?): LatLngQuad? {
+        // [top left, top right, bottom right, bottom left]
+        if (array == null || array.size() < 4) {
+            return null
+        }
+        return LatLngQuad(
+            toLatLng(array.getArray(0))!!,
+            toLatLng(array.getArray(1))!!,
+            toLatLng(array.getArray(2))!!,
+            toLatLng(array.getArray(3))!!
+        )
+    }
+
+    fun pointToDoubleArray(point: Point?): DoubleArray {
+        if (point == null) {
+            return doubleArrayOf(0.0, 0.0)
+        }
+        return doubleArrayOf(point.longitude(), point.latitude())
+    }
+}

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

@@ -0,0 +1,85 @@
+package org.maplibre.reactnative.utils
+
+import android.view.View
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.UIManager
+import com.facebook.react.uimanager.IllegalViewOperationException
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.common.UIManagerType
+import org.maplibre.android.log.Logger
+
+data class Await<V>(
+    val fn: (V) -> Unit,
+    val reject: Promise?
+)
+
+const val LOG_TAG = "ReactTagResolver"
+
+typealias ReactTag = Double
+
+// https://github.com/rnmapbox/maps/pull/3074
+open class ReactTagResolver(val context: ReactApplicationContext) {
+    private val createdViews: HashSet<Int> = hashSetOf<Int>()
+    private val awaitedViews: HashMap<Int, MutableList<Await<View?>>> = hashMapOf()
+
+    // To be called from view.setId
+    fun tagAssigned(reactTag: Int) {
+        createdViews.add(reactTag)
+
+        val list = awaitedViews[reactTag]
+        if (list != null) {
+            context.runOnUiQueueThread {
+                try {
+                    val view = manager.resolveView(reactTag)
+
+                    list.forEach { it.fn(view) }
+                } catch (err: IllegalViewOperationException) {
+                    list.forEach { it.reject?.reject(err) }
+                }
+                awaitedViews.remove(reactTag)
+            }
+        }
+    }
+
+    fun viewRemoved(reactTag: Int) {
+        awaitedViews.remove(reactTag)
+        createdViews.remove(reactTag)
+    }
+
+    private val manager: UIManager
+        get() = UIManagerHelper.getUIManager(context, UIManagerType.FABRIC)!!
+
+    fun <V> withViewResolved(reactTag: Int, promise: Promise? = null, fn: (V) -> Unit) {
+        context.runOnUiQueueThread() {
+            try {
+                val resolvedView: View? = manager.resolveView(reactTag)
+                val view = resolvedView as? V
+                if (view != null) {
+                    fn(view)
+                } else {
+                    val message =
+                        "`reactTag` $reactTag resolved to `view` $resolvedView which is null or a wrong type"
+                    Logger.e(LOG_TAG, message)
+                    promise?.reject(Throwable(message))
+                }
+            } catch (err: IllegalViewOperationException) {
+                if (!createdViews.contains(reactTag)) {
+                    awaitedViews.getOrPut(reactTag) { mutableListOf() }.add(
+                        Await({ view ->
+                            if (view != null) {
+                                fn(view as V)
+                            } else {
+                                val message = "`reactTag` $reactTag resolved null"
+                                Logger.e(LOG_TAG, message)
+                                promise?.reject(Throwable(message))
+                            }
+                        }, promise)
+                    )
+                } else {
+                    promise?.reject(err)
+                }
+            }
+        }
+    }
+}

package/ios/components/annotations/MLRNCallout.h

@@ -0,0 +1,7 @@
+#import <React/RCTView.h>
+
+#import <MapLibre/MapLibre.h>
+
+@interface MLRNCallout : RCTView <MLNCalloutView>
+
+@end