@maplibre/maplibre-react-native 10.0.0-alpha.9 → 10.0.0-beta.10

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

@@ -0,0 +1,74 @@
+package org.maplibre.reactnative.utils;
+
+import com.facebook.react.bridge.Dynamic;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.google.gson.JsonArray;
+import org.maplibre.android.style.expressions.Expression;
+import org.maplibre.android.style.expressions.Expression.Converter;
+
+import org.json.JSONArray;
+
+import java.util.Locale;
+
+import javax.annotation.Nullable;
+
+public class ExpressionParser {
+    static final String TYPE_STRING = "string";
+    static final String TYPE_ARRAY = "array";
+    static final String TYPE_NUMBER = "number";
+    static final String TYPE_MAP = "hashmap";
+    static final String TYPE_BOOL = "boolean";
+
+    public static @Nullable Expression from(@Nullable  ReadableArray rawExpressions) {
+        if (rawExpressions == null || rawExpressions.size() == 0) {
+            return null;
+        }
+
+        return Expression.Converter.convert(ConvertUtils.toJsonArray(rawExpressions));
+    }
+
+    public static Expression fromTyped(ReadableMap rawExpressions) {
+        JsonArray array = (JsonArray)ConvertUtils.typedToJsonElement(rawExpressions);
+        return Expression.Converter.convert(array);
+    }
+
+
+
+    public static Expression from(ReadableMap rawExpression) {
+        return Expression.raw("[" + stringExpression(rawExpression) + "]");
+    }
+
+    private static String stringExpression(ReadableMap item) {
+        String expression = "";
+        String type = item.getString("type");
+
+        if (TYPE_STRING.equals(type)) {
+            String value = item.getString("value");
+            expression = String.format(Locale.ENGLISH, "\"%s\"", value);
+        } else if (TYPE_NUMBER.equals(type)) {
+            Double value = item.getDouble("value");
+            expression = String.format(Locale.ENGLISH, "%f", value);
+        } else if (TYPE_BOOL.equals(type)) {
+            Boolean value = item.getBoolean("value");
+            expression = String.format(Locale.ENGLISH, "%b", value);
+        } else if (TYPE_ARRAY.equals(type)) {
+            ReadableArray entries = item.getArray("value");
+
+            expression += "[";
+
+            for (int i = 0; i < entries.size(); i++) {
+                String entryExpression = stringExpression(entries.getMap(i));
+                expression += entryExpression;
+
+                if (i < entries.size() - 1) {
+                    expression += ",";
+                }
+            }
+
+            expression += "]";
+        }
+
+        return expression;
+    }
+}

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

@@ -0,0 +1,285 @@
+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.geojson.Feature;
+import org.maplibre.geojson.FeatureCollection;
+import org.maplibre.geojson.Geometry;
+import org.maplibre.geojson.GeometryCollection;
+import org.maplibre.geojson.MultiLineString;
+import org.maplibre.geojson.LineString;
+import org.maplibre.geojson.MultiPoint;
+import org.maplibre.geojson.Point;
+import org.maplibre.geojson.MultiPolygon;
+import org.maplibre.geojson.Polygon;
+import org.maplibre.android.geometry.LatLng;
+import org.maplibre.android.geometry.LatLngBounds;
+import org.maplibre.android.geometry.LatLngQuad;
+import org.maplibre.android.style.light.Position;
+import org.maplibre.turf.TurfMeasurement;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class GeoJSONUtils {
+    public static WritableMap fromFeature(Feature feature) {
+        WritableMap map = Arguments.createMap();
+        map.putString("type", "Feature");
+        map.putString("id", feature.id());
+
+        WritableMap geometry = fromGeometry(feature.geometry());
+        map.putMap("geometry", geometry);
+
+        WritableMap properties = ConvertUtils.toWritableMap(feature.properties());
+        map.putMap("properties", properties);
+
+        return map;
+    }
+
+    public static WritableMap fromGeometry(Geometry geometry) {
+        final String type = geometry.type();
+
+        switch (type) {
+            case "Point":
+                return fromPoint((Point) geometry);
+            case "LineString":
+                return fromLineString((LineString) geometry);
+            case "Polygon":
+                return fromPolygon((Polygon) geometry);
+            case "MultiPoint":
+                return fromMultiPoint((MultiPoint) geometry);
+            case "MultiLineString":
+                return fromMultiLineString((MultiLineString) geometry);
+            case "MultiPolygon":
+                return fromMultiPolygon((MultiPolygon) geometry);
+            default:
+                return null;
+        }
+    }
+
+    public static WritableMap fromPoint(Point point) {
+        WritableMap map = Arguments.createMap();
+        map.putString("type", "Point");
+        map.putArray("coordinates", getCoordinates(point));
+        return map;
+    }
+
+    public static WritableMap fromLineString(LineString lineString) {
+        WritableMap map = Arguments.createMap();
+        map.putString("type", "LineString");
+        map.putArray("coordinates", getCoordinates(lineString));
+        return map;
+    }
+
+    public static WritableMap fromPolygon(Polygon polygon) {
+        WritableMap map = Arguments.createMap();
+        map.putString("type", "Polygon");
+        map.putArray("coordinates", getCoordinates(polygon));
+        return map;
+    }
+
+    public static WritableMap fromMultiPoint(MultiPoint multiPoint) {
+        WritableMap map = Arguments.createMap();
+        map.putString("type", "MultiPoint");
+        map.putArray("coordinates", getCoordinates(multiPoint));
+        return map;
+    }
+
+    public static WritableMap fromMultiLineString(MultiLineString multiLineString) {
+        WritableMap map = Arguments.createMap();
+        map.putString("type", "MultiLineString");
+        map.putArray("coordinates", getCoordinates(multiLineString));
+        return map;
+    }
+
+    public static WritableMap fromMultiPolygon(MultiPolygon multiPolygon) {
+        WritableMap map = Arguments.createMap();
+        map.putString("type", "MultiPolygon");
+        map.putArray("coordinates", getCoordinates(multiPolygon));
+        return map;
+    }
+
+    public static WritableArray getCoordinates(Point point) {
+        return Arguments.fromArray(pointToDoubleArray(point));
+    }
+
+    public static WritableArray getCoordinates(LineString lineString) {
+        WritableArray array = Arguments.createArray();
+
+        List<Point> points = lineString.coordinates();
+        for (Point point : points) {
+            array.pushArray(Arguments.fromArray(pointToDoubleArray(point)));
+        }
+
+        return array;
+    }
+
+    public static WritableArray getCoordinates(Polygon polygon) {
+        WritableArray array = Arguments.createArray();
+
+        List<List<Point>> points = polygon.coordinates();
+        if (points == null) {
+            return array;
+        }
+
+        for (List<Point> curPoint : points) {
+            WritableArray innerArray = Arguments.createArray();
+
+            for (Point point : curPoint) {
+                innerArray.pushArray(Arguments.fromArray(pointToDoubleArray(point)));
+            }
+
+            array.pushArray(innerArray);
+        }
+
+        return array;
+    }
+
+    public static WritableArray getCoordinates(MultiPoint multiPoint) {
+        WritableArray array = Arguments.createArray();
+
+        List<Point> points = multiPoint.coordinates();
+        for (Point point : points) {
+            array.pushArray(Arguments.fromArray(pointToDoubleArray(point)));
+        }
+
+        return array;
+    }
+
+    public static WritableArray getCoordinates(MultiLineString multiLineString) {
+        WritableArray array = Arguments.createArray();
+
+        List<List<Point>> lines = multiLineString.coordinates();
+        for (List<Point> line : lines) {
+            WritableArray lineArray = Arguments.createArray();
+
+            for (Point point : line) {
+                lineArray.pushArray(Arguments.fromArray(pointToDoubleArray(point)));
+            }
+
+            array.pushArray(lineArray);
+        }
+
+        return array;
+    }
+
+    public static WritableArray getCoordinates(MultiPolygon multiPolygon) {
+        WritableArray array = Arguments.createArray();
+
+        List<List<List<Point>>> polygons = multiPolygon.coordinates();
+        for (List<List<Point>> polygon : polygons) {
+            WritableArray polygonArray = Arguments.createArray();
+
+            for (List<Point> ring : polygon) {
+                WritableArray ringArray = Arguments.createArray();
+
+                for (Point point : ring) {
+                    ringArray.pushArray(Arguments.fromArray(pointToDoubleArray(point)));
+                }
+
+                polygonArray.pushArray(ringArray);
+            }
+
+            array.pushArray(polygonArray);
+        }
+
+        return array;
+    }
+
+    public static WritableMap toPointFeature(LatLng latLng, WritableMap properties) {
+        WritableMap map = new WritableNativeMap();
+        map.putString("type", "Feature");
+        map.putMap("geometry", toPointGeometry(latLng));
+        map.putMap("properties", properties);
+        return map;
+    }
+
+    public static WritableMap toPointGeometry(LatLng latLng) {
+        WritableMap geometry = new WritableNativeMap();
+        geometry.putString("type", "Point");
+        geometry.putArray("coordinates", fromLatLng(latLng));
+        return geometry;
+    }
+
+    public static WritableArray fromLatLng(LatLng latLng) {
+        double[] coords = new double[]{ latLng.getLongitude(), latLng.getLatitude() };
+        WritableArray writableCoords = new WritableNativeArray();
+        writableCoords.pushDouble(coords[0]);
+        writableCoords.pushDouble(coords[1]);
+        return writableCoords;
+    }
+
+    public static LatLng toLatLng(Point point) {
+        if (point == null) {
+            return null;
+        }
+        return new LatLng(point.latitude(), point.longitude());
+    }
+
+    public static LatLng toLatLng(ReadableArray coordinates) {
+        if (coordinates == null || coordinates.size() < 2) {
+            return null;
+        }
+        return new LatLng(coordinates.getDouble(1), coordinates.getDouble(0));
+    }
+
+    public static Point toPointGeometry(String featureJSONString) {
+        Feature feature = Feature.fromJson(featureJSONString);
+        if (feature == null) {
+            return null;
+        }
+        return (Point)feature.geometry();
+    }
+
+    public static WritableArray fromLatLngBounds(LatLngBounds latLngBounds) {
+        WritableArray array = Arguments.createArray();
+
+        LatLng[] latLngs = latLngBounds.toLatLngs();
+        for (LatLng latLng : latLngs) {
+            array.pushArray(fromLatLng(latLng));
+        }
+
+        return array;
+    }
+
+    private static GeometryCollection toGeometryCollection(List<Feature> features) {
+        ArrayList<Geometry> geometries = new ArrayList<>();
+        geometries.ensureCapacity(features.size());
+        for (Feature feature : features) {
+            geometries.add(feature.geometry());
+        }
+        return GeometryCollection.fromGeometries(geometries);
+    }
+
+    public static LatLngBounds toLatLngBounds(FeatureCollection featureCollection) {
+        List<Feature> features = featureCollection.features();
+
+        double[] bbox = TurfMeasurement.bbox(toGeometryCollection(features));
+
+        return LatLngBounds.from(bbox[3], bbox[2], bbox[1], bbox[0]);
+    }
+
+    public static LatLngQuad toLatLngQuad(ReadableArray array) {
+        // [top left, top right, bottom right, bottom left]
+        if (array == null || array.size() < 4) {
+            return null;
+        }
+        return new LatLngQuad(
+                toLatLng(array.getArray(0)),
+                toLatLng(array.getArray(1)),
+                toLatLng(array.getArray(2)),
+                toLatLng(array.getArray(3))
+        );
+    }
+
+    public static double[] pointToDoubleArray(Point point) {
+        if (point == null) {
+            return new double[] { 0.0, 0.0 };
+        }
+        return new double[] { point.longitude(), point.latitude() };
+    }
+}

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

@@ -0,0 +1,37 @@
+package org.maplibre.reactnative.utils;
+
+import android.graphics.PointF;
+
+import org.maplibre.android.geometry.LatLng;
+import org.maplibre.android.geometry.LatLngBounds;
+import org.maplibre.android.geometry.VisibleRegion;
+
+/**
+ * Ported from https://github.com/mapbox/geo-viewport/blob/master/index.js
+ * This port only assumes we will have 512 vector tile sizes
+ */
+
+public class GeoViewport {
+    private static SphericalMercator sphericalMercator = new SphericalMercator();
+
+    public static VisibleRegion getRegion(LatLng centerCoord, int zoomLevel, int viewportWidth, int viewportHeight) {
+        PointF px = sphericalMercator.getPX(centerCoord, zoomLevel);
+
+        LatLng tl = sphericalMercator.getLatLng(new PointF(
+                px.x - (viewportWidth / 2),
+                px.y - (viewportHeight / 2)
+        ), zoomLevel);
+
+        LatLng br = sphericalMercator.getLatLng(new PointF(
+                px.x + (viewportWidth / 2),
+                px.y + (viewportHeight / 2)
+        ), zoomLevel);
+
+        LatLng farLeft = tl;
+        LatLng farRight = new LatLng(tl.getLatitude(), br.getLongitude());
+        LatLng nearLeft = new LatLng(br.getLatitude(), tl.getLongitude());
+        LatLng nearRight = br;
+
+        return new VisibleRegion(farLeft, farRight, nearLeft, nearRight, null);
+    }
+}

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

@@ -0,0 +1,25 @@
+package org.maplibre.reactnative.utils;
+
+public class ImageEntry {
+    public String uri;
+    public double scale = 1.0;
+    public static final double defaultScale = 0.0;
+
+    public ImageEntry(String _uri, Double _scale) {
+        uri = _uri;
+        scale = _scale;
+    }
+
+    public ImageEntry(String _uri) {
+        uri = _uri;
+        scale = ImageEntry.defaultScale;
+    }
+
+    public double getScaleOr(double v) {
+        if (scale == ImageEntry.defaultScale) {
+            return v;
+        } else {
+            return scale;
+        }
+    }
+}

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

@@ -0,0 +1,26 @@
+package org.maplibre.reactnative.utils;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.drawable.Drawable;
+import androidx.core.content.ContextCompat;
+
+public class ResourceUtils {
+    public static Drawable getDrawableByName(Context context, String resourceName) {
+        if (context == null || resourceName == null || resourceName.isEmpty()) {
+            return null;
+        }
+
+        Resources resources = context.getResources();
+        if (resources == null) {
+            return null;
+        }
+
+        final int resID = resources.getIdentifier(resourceName, "drawable", context.getPackageName());
+        if (resID == 0) {
+            return null;
+        }
+        
+        return ContextCompat.getDrawable(context, resID);
+    }
+}

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

@@ -0,0 +1,26 @@
+package org.maplibre.reactnative.utils;
+
+import org.maplibre.android.maps.MapLibreMap;
+
+import org.maplibre.reactnative.components.AbstractEventEmitter;
+import org.maplibre.reactnative.events.IEvent;
+
+public class SimpleEventCallback implements MapLibreMap.CancelableCallback {
+    private AbstractEventEmitter mEventEmitter;
+    private IEvent mEvent;
+
+    public SimpleEventCallback(AbstractEventEmitter eventEmitter, IEvent event) {
+        mEventEmitter = eventEmitter;
+        mEvent = event;
+    }
+
+    @Override
+    public void onCancel() {
+        mEventEmitter.handleEvent(mEvent);
+    }
+
+    @Override
+    public void onFinish() {
+        mEventEmitter.handleEvent(mEvent);
+    }
+}

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

@@ -0,0 +1,68 @@
+package org.maplibre.reactnative.utils;
+
+import android.graphics.Point;
+import android.graphics.PointF;
+
+import org.maplibre.android.geometry.LatLng;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Ported from https://github.com/mapbox/sphericalmercator/blob/master/sphericalmercator.js
+ * This port only assumes we will have 512 vector tile sizes
+ */
+
+public class SphericalMercator {
+    public static final double D2R = Math.PI / 180;
+    public static final double R2D = 180 / Math.PI;
+
+    private static Map<String, List<Double>> cache;
+
+    public SphericalMercator() {
+        int tileSize = 512;
+
+        if (cache == null) {
+            cache = new HashMap<>();
+            cache.put("Bc", new ArrayList<Double>());
+            cache.put("Cc", new ArrayList<Double>());
+            cache.put("zc", new ArrayList<Double>());
+            cache.put("Ac", new ArrayList<Double>());
+
+            double size = (double) tileSize;
+            for (int d = 0; d < 30; d++) {
+                cache.get("Bc").add(size / 360);
+                cache.get("Cc").add(size / (2 * Math.PI));
+                cache.get("zc").add(size / 2);
+                cache.get("Ac").add(size);
+                size *= 2;
+            }
+        }
+    }
+
+    public PointF getPX(LatLng latLng, int zoomLevel) {
+        double d = cache.get("zc").get(zoomLevel);
+        double f = Math.min(Math.max(Math.sin(D2R * latLng.getLatitude()), -0.9999), 0.9999);
+        double x = Math.round(d + latLng.getLongitude() * cache.get("Bc").get(zoomLevel));
+        double y = Math.round(d + 0.5 * Math.log((1 + f) / (1 - f)) * (-cache.get("Cc").get(zoomLevel)));
+
+        if (x > cache.get("Ac").get(zoomLevel)) {
+            x = cache.get("Ac").get(zoomLevel);
+        }
+
+        if (y > cache.get("Ac").get(zoomLevel)) {
+            y = cache.get("Ac").get(zoomLevel);
+        }
+
+        return new PointF((float) x, (float) y);
+    }
+
+    public LatLng getLatLng(PointF px, int zoomLevel) {
+        double g = ((double)px.y - cache.get("zc").get(zoomLevel)) / (-cache.get("Cc").get(zoomLevel));
+        double lon = ((double) px.x - cache.get("zc").get(zoomLevel)) / cache.get("Bc").get(zoomLevel);
+        double lat = R2D * (2 * Math.atan(Math.exp(g)) - 0.5 * Math.PI);
+        return new LatLng(lat, lon);
+    }
+}

package/app.plugin.js

@@ -1 +1 @@
-module.exports = require('./plugin/build/withMapLibre');
+module.exports = require("./plugin/build/withMapLibre");

package/ios/MLRN/CameraMode.h

@@ -0,0 +1,10 @@
+#import <Foundation/Foundation.h>
+
+@interface CameraMode : NSObject
+
+extern int const RCT_MAPBOX_CAMERA_MODE_FLIGHT;
+extern int const RCT_MAPBOX_CAMERA_MODE_EASE;
+extern int const RCT_MAPBOX_CAMERA_MODE_LINEAR;
+extern int const RCT_MAPBOX_CAMERA_MODE_NONE;
+
+@end

package/ios/MLRN/CameraMode.m

@@ -0,0 +1,10 @@
+#import "CameraMode.h"
+
+@implementation CameraMode
+
+int const RCT_MAPBOX_CAMERA_MODE_FLIGHT = 1;
+int const RCT_MAPBOX_CAMERA_MODE_EASE = 2;
+int const RCT_MAPBOX_CAMERA_MODE_LINEAR = 3;
+int const RCT_MAPBOX_CAMERA_MODE_NONE = 4;
+
+@end

package/ios/MLRN/CameraStop.h

@@ -0,0 +1,18 @@
+@import MapLibre;
+#import "MLRNCamera.h"
+
+@interface CameraStop : NSObject
+
+@property (nonatomic, strong) NSNumber *pitch;
+@property (nonatomic, strong) NSNumber *heading;
+@property (nonatomic, strong) NSNumber *zoom;
+@property (nonatomic, strong) NSNumber *mode;
+@property (nonatomic, assign) NSTimeInterval duration;
+
+@property (nonatomic, assign) CLLocationCoordinate2D coordinate;
+@property (nonatomic, assign) MLNCoordinateBounds bounds;
+@property (nonatomic, assign) UIEdgeInsets padding;
+
++ (CameraStop*)fromDictionary:(NSDictionary*)args;
+
+@end

package/ios/MLRN/CameraStop.m

@@ -0,0 +1,75 @@
+#import "CameraStop.h"
+#import "CameraMode.h"
+#import "MLRNUtils.h"
+#import "MLRNCamera.h"
+
+@implementation CameraStop
+
+- (void)setMode:(NSNumber *)mode
+{
+    int modeInt = [mode intValue];
+    
+    if (modeInt == RCT_MAPBOX_CAMERA_MODE_FLIGHT) {
+        _mode = [NSNumber numberWithInt:modeInt];
+    } else if (modeInt == RCT_MAPBOX_CAMERA_MODE_NONE) {
+        _mode = [NSNumber numberWithInt:modeInt];
+    } else if (modeInt == RCT_MAPBOX_CAMERA_MODE_LINEAR) {
+        _mode = [NSNumber numberWithInt:modeInt];
+    } else {
+        _mode = [NSNumber numberWithInt:RCT_MAPBOX_CAMERA_MODE_EASE];
+    }
+}
+
+-(id)init {
+     if (self = [super init])  {
+         self.coordinate = kCLLocationCoordinate2DInvalid;
+         self.bounds = MLNCoordinateBoundsMake(kCLLocationCoordinate2DInvalid, kCLLocationCoordinate2DInvalid);
+     }
+     return self;
+}
+
+
++ (CameraStop*)fromDictionary:(NSDictionary *)args
+{
+    CameraStop *stop = [[CameraStop alloc] init];
+    
+    if (args[@"pitch"]) {
+        stop.pitch = args[@"pitch"];
+    }
+    
+    if (args[@"heading"]) {
+        stop.heading = args[@"heading"];
+    }
+
+    if (args[@"centerCoordinate"]) {
+        stop.coordinate = [MLRNUtils fromFeature:args[@"centerCoordinate"]];
+    }
+    
+    if (args[@"zoom"]) {
+        stop.zoom = args[@"zoom"];
+    }
+    
+    if (args[@"mode"]) {
+        stop.mode = args[@"mode"];
+    }
+    
+    if (args[@"bounds"]) {
+        stop.bounds = [MLRNUtils fromFeatureCollection:args[@"bounds"]];
+    }
+    
+    CGFloat paddingTop = args[@"paddingTop"] ? [args[@"paddingTop"] floatValue] : 0.0;
+    CGFloat paddingRight = args[@"paddingRight"] ? [args[@"paddingRight"] floatValue] : 0.0;
+    CGFloat paddingBottom = args[@"paddingBottom"] ? [args[@"paddingBottom"] floatValue] : 0.0;
+    CGFloat paddingLeft = args[@"paddingLeft"] ? [args[@"paddingLeft"] floatValue] : 0.0;
+    stop.padding = UIEdgeInsetsMake(paddingTop, paddingLeft, paddingBottom, paddingRight);
+    
+    NSTimeInterval duration = 2.0;
+    if (args[@"duration"]) {
+        duration = [MLRNUtils fromMS:args[@"duration"]];
+    }
+    stop.duration = duration;
+    
+    return stop;
+}
+
+@end

package/ios/MLRN/CameraUpdateItem.h

@@ -0,0 +1,10 @@
+#import "CameraStop.h"
+#import "MLRNMapView.h"
+
+@interface CameraUpdateItem : NSObject
+
+@property (nonatomic, strong) CameraStop* _Nonnull cameraStop;
+
+- (void)execute:(MLRNMapView* _Nonnull)mapView withCompletionHandler:(nullable void (^)(void))completionHandler;
+
+@end