@maplibre/maplibre-react-native 11.0.0-alpha.7 → 11.0.0-alpha.9

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

@@ -1,310 +0,0 @@
-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 com.google.gson.JsonObject;
-
-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.log.Logger;
-import org.maplibre.turf.TurfMeasurement;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.stream.Collectors;
-
-public class GeoJSONUtils {
-    public static final String LOG_TAG = "GeoJSONUtils";
-
-    public static WritableMap fromFeature(Feature feature) {
-        WritableMap map = Arguments.createMap();
-        map.putString("type", "Feature");
-        map.putString("id", feature.id());
-
-        Geometry geometry = feature.geometry();
-        if (geometry == null) {
-            map.putNull("geometry");
-        } else {
-            map.putMap("geometry", fromGeometry(geometry));
-        }
-
-        JsonObject properties = feature.properties();
-        if(properties == null) {
-            map.putNull("properties");
-        } else {
-            map.putMap("properties", ConvertUtils.toWritableMap(properties));
-        }
-
-        return map;
-    }
-
-    public static WritableMap fromGeometry(Geometry geometry) {
-        final String type = geometry.type();
-
-        return switch (type) {
-            case "Point" -> fromPoint((Point) geometry);
-            case "LineString" -> fromLineString((LineString) geometry);
-            case "Polygon" -> fromPolygon((Polygon) geometry);
-            case "MultiPoint" -> fromMultiPoint((MultiPoint) geometry);
-            case "MultiLineString" -> fromMultiLineString((MultiLineString) geometry);
-            case "MultiPolygon" -> fromMultiPolygon((MultiPolygon) geometry);
-            case "GeometryCollection" -> fromGeometryCollection((GeometryCollection) geometry);
-            default -> {
-                Logger.w(LOG_TAG, "GeoJSONUtils.fromGeometry unsupported type: \"" + type + "\"");
-
-                yield 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 WritableMap fromGeometryCollection(GeometryCollection geometryCollection) {
-        WritableMap map = Arguments.createMap();
-        map.putString("type", "GeometryCollection");
-
-        map.putArray("geometries",
-                Arguments.fromList(
-                        geometryCollection
-                                .geometries()
-                                .stream()
-                                .map(GeoJSONUtils::fromGeometry)
-                                .collect(Collectors.toList())
-                )
-        );
-
-        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();
-
-        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/ios/CameraMode.h

@@ -1,10 +0,0 @@
-#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/CameraMode.m

@@ -1,10 +0,0 @@
-#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/CameraStop.m

@@ -1,73 +0,0 @@
-#import "CameraStop.h"
-#import "CameraMode.h"
-#import "MLRNCamera.h"
-#import "MLRNUtils.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/MLRNCamera.h

@@ -1,29 +0,0 @@
-#import <React/RCTComponent.h>
-#import <UIKit/UIKit.h>
-#import "MLRNMapView.h"
-
-@class MLRNMapView;
-
-@interface MLRNCamera : UIView <MLRNMapViewCamera>
-
-@property (nonatomic, strong) NSDictionary<NSString *, id> *stop;
-@property (nonatomic, strong) NSDictionary<NSString *, id> *defaultStop;
-@property (nonatomic, strong) MLRNMapView *map;
-
-@property (nonatomic, assign) BOOL followUserLocation;
-@property (nonatomic, copy) NSString *followUserMode;
-@property (nonatomic, copy) NSNumber *followZoomLevel;
-@property (nonatomic, copy) NSNumber *followPitch;
-@property (nonatomic, copy) NSNumber *followHeading;
-
-@property (nonatomic, copy) NSNumber *maxZoomLevel;
-@property (nonatomic, copy) NSNumber *minZoomLevel;
-
-@property (nonatomic, copy) NSString *maxBounds;
-
-@property (nonatomic, copy) NSString *alignment;
-@property (nonatomic, copy, readonly) NSNumber *cameraAnimationMode;
-
-@property (nonatomic, copy) RCTBubblingEventBlock onUserTrackingModeChange;
-
-@end

package/ios/MLRNCamera.m

@@ -1,236 +0,0 @@
-#import "MLRNCamera.h"
-#import "CameraMode.h"
-#import "CameraStop.h"
-#import "CameraUpdateQueue.h"
-#import "MLRNEvent.h"
-#import "MLRNEventTypes.h"
-#import "MLRNLocation.h"
-#import "MLRNLocationManager.h"
-#import "MLRNUtils.h"
-
-@implementation MLRNCamera {
-  CameraUpdateQueue *cameraUpdateQueue;
-  MLRNCamera *followCamera;
-}
-
-- (instancetype)init {
-  if (self = [super init]) {
-    cameraUpdateQueue = [[CameraUpdateQueue alloc] init];
-  }
-  return self;
-}
-
-- (void)dealloc {
-  if (_map) {
-    _map.reactCamera = nil;
-  }
-}
-
-- (void)setMaxZoomLevel:(NSNumber *)maxZoomLevel {
-  _maxZoomLevel = maxZoomLevel;
-  [self _updateMinMaxZoomLevel];
-}
-
-- (void)setMinZoomLevel:(NSNumber *)minZoomLevel {
-  _minZoomLevel = minZoomLevel;
-  [self _updateMinMaxZoomLevel];
-}
-
-- (void)setMaxBounds:(NSString *)maxBounds {
-  _maxBounds = maxBounds;
-  [self _updateMaxBounds];
-}
-
-- (void)setDefaultStop:(NSDictionary<NSString *, id> *)stop {
-  _defaultStop = stop;
-}
-
-- (void)setStop:(NSDictionary<NSString *, id> *)stop {
-  _stop = stop;
-
-  [self _updateCamera];
-}
-
-- (void)setMap:(MLRNMapView *)map {
-  if (_map != nil) {
-    _map.reactCamera = nil;
-  }
-  _map = map;
-  _map.reactCamera = self;
-
-  [self _setInitialCamera];
-  [self _updateMinMaxZoomLevel];
-  [self _updateMaxBounds];
-  [self _updateCamera];
-}
-
-- (void)setFollowUserLocation:(BOOL)followUserLocation {
-  _followUserLocation = followUserLocation;
-  [self _updateCameraFromTrackingMode];
-}
-
-- (void)setFollowUserMode:(NSString *)followUserMode {
-  _followUserMode = followUserMode;
-  [self _updateCameraFromTrackingMode];
-}
-
-- (void)setFollowPitch:(NSNumber *)followPitch {
-  _followPitch = followPitch;
-  [self _updateCameraFromTrackingMode];
-}
-
-- (void)setFollowZoomLevel:(NSNumber *)followZoomLevel {
-  _followZoomLevel = followZoomLevel;
-  [self _updateCameraFromTrackingMode];
-}
-
-- (void)setFollowHeading:(NSNumber *)followHeading {
-  _followHeading = followHeading;
-  [self _updateCameraFromTrackingMode];
-}
-
-- (void)_updateCameraFromJavascript {
-  if (_stop == nil) {
-    return;
-  }
-
-  if (_followUserLocation) {
-    return;
-  }
-
-  if (_map != nil && _map.userTrackingMode != MLNUserTrackingModeNone) {
-    _map.userTrackingMode = MLNUserTrackingModeNone;
-  }
-  if (_stop[@"stops"]) {
-    NSArray *stops = _stop[@"stops"];
-    for (NSDictionary *stop in stops) {
-      [cameraUpdateQueue enqueue:[CameraStop fromDictionary:stop]];
-    }
-  } else {
-    [cameraUpdateQueue enqueue:[CameraStop fromDictionary:_stop]];
-  }
-  [cameraUpdateQueue execute:_map];
-}
-
-- (void)_setInitialCamera {
-  if (!_defaultStop) {
-    return;
-  }
-
-  CameraStop *stop = [CameraStop fromDictionary:_defaultStop];
-  stop.duration = 0;
-  stop.mode = [NSNumber numberWithInt:RCT_MAPBOX_CAMERA_MODE_NONE];
-  CameraUpdateItem *item = [[CameraUpdateItem alloc] init];
-  item.cameraStop = stop;
-  [item execute:_map
-      withCompletionHandler:^{
-      }];
-}
-
-- (void)_updateCamera {
-  if (_map != nil) {
-    if (_followUserLocation) {
-      [self _updateCameraFromTrackingMode];
-    } else {
-      [self _updateCameraFromJavascript];
-    }
-  }
-}
-
-- (void)_updateMinMaxZoomLevel {
-  if (_map != nil) {
-    if (_maxZoomLevel) {
-      _map.maximumZoomLevel = [_maxZoomLevel doubleValue];
-    }
-    if (_minZoomLevel) {
-      _map.minimumZoomLevel = [_minZoomLevel doubleValue];
-    }
-  }
-}
-
-- (void)_updateMaxBounds {
-  if (_map != nil) {
-    if (_maxBounds) {
-      _map.maxBounds = [MLRNUtils fromFeatureCollection:_maxBounds];
-    }
-  }
-}
-
-- (void)_updateCameraFromTrackingMode {
-  if (_map == nil) {
-    return;
-  }
-  if (!_followUserLocation) {
-    _map.userTrackingMode = MLNUserTrackingModeNone;
-    return;
-  }
-
-  MLNMapCamera *camera = _map.camera;
-  if (_followPitch != nil && [_followPitch floatValue] >= 0.0) {
-    camera.pitch = [_followPitch floatValue];
-  } else if (_stop != nil && _stop[@"pitch"] != nil) {
-    camera.pitch = [_stop[@"pitch"] floatValue];
-  }
-
-  if ([self _userTrackingMode] != MLNUserTrackingModeFollowWithCourse &&
-      [self _userTrackingMode] != MLNUserTrackingModeFollowWithHeading) {
-    if (_followHeading != nil && [_followHeading floatValue] >= 0.0) {
-      camera.heading = [_followHeading floatValue];
-    } else if (_stop != nil && _stop[@"heading"] != nil) {
-      camera.heading = [_stop[@"heading"] floatValue];
-    }
-  }
-
-  if (_followZoomLevel != nil && [_followZoomLevel doubleValue] >= 0.0) {
-    camera.altitude = [_map altitudeFromZoom:[_followZoomLevel doubleValue]];
-  }
-
-  [_map setCamera:camera animated:NO];
-
-  if (_map.userTrackingMode != [self _userTrackingMode]) {
-    _map.userTrackingMode = [self _userTrackingMode];
-  }
-}
-
-- (NSUInteger)_userTrackingMode {
-  if ([_followUserMode isEqualToString:@"compass"]) {
-    return MLNUserTrackingModeFollowWithHeading;
-  } else if ([_followUserMode isEqualToString:@"course"]) {
-    return MLNUserTrackingModeFollowWithCourse;
-  } else if (_followUserLocation) {
-    return MLNUserTrackingModeFollow;
-  } else {
-    return MLNUserTrackingModeNone;
-  }
-}
-
-- (id)_trackingModeToString:(MLNUserTrackingMode)mode {
-  switch (mode) {
-    case MLNUserTrackingModeFollowWithHeading:
-      return @"compass";
-    case MLNUserTrackingModeFollowWithCourse:
-      return @"course";
-    case MLNUserTrackingModeFollow:
-      return @"normal";
-    case MLNUserTrackingModeNone:
-      return [NSNull null];
-  }
-}
-
-- (void)initialLayout {
-  [self _setInitialCamera];
-  [self _updateCamera];
-}
-
-- (void)didChangeUserTrackingMode:(MLNUserTrackingMode)mode animated:(BOOL)animated {
-  NSDictionary *payload = @{
-    @"followUserMode" : [self _trackingModeToString:mode],
-    @"followUserLocation" : @((BOOL)(mode != MLNUserTrackingModeNone))
-  };
-  MLRNEvent *event = [MLRNEvent makeEvent:RCT_MAPBOX_USER_TRACKING_MODE_CHANGE withPayload:payload];
-  if (_onUserTrackingModeChange) {
-    _onUserTrackingModeChange([event toJSON]);
-  }
-}
-
-@end

package/ios/MLRNCameraManager.h

@@ -1,5 +0,0 @@
-#import "ViewManager.h"
-
-@interface MLRNCameraManager : ViewManager
-
-@end