@maplibre/maplibre-react-native 11.0.0-alpha.2 → 11.0.0-alpha.21

package/ios/components/layers/style/MLRNStyleValue.h

@@ -0,0 +1,20 @@
+#import <Foundation/Foundation.h>
+@import MapLibre;
+
+@interface MLRNStyleValue : NSObject
+
+@property (nonatomic, strong) NSString *styleType;
+@property (nonatomic, strong) NSDictionary *rawStyleValue;
+@property (nonatomic, readonly) NSExpression *mlnStyleValue;
+
+- (BOOL)shouldAddImage;
+- (NSString *)getImageURI;
+- (double)getImageScale;
+- (BOOL)getImageSdf;
+- (MLNTransition)getTransition;
+- (NSExpression *)getSphericalPosition;
+- (BOOL)isVisible;
+
++ (MLRNStyleValue *)make:(NSString *)expressionJSONStr;
+
+@end

package/ios/components/layers/style/MLRNStyleValue.m

@@ -0,0 +1,172 @@
+#import "MLRNStyleValue.h"
+#import <React/RCTImageLoader.h>
+#import "MLRNUtils.h"
+
+@implementation MLRNStyleValue {
+  NSObject *expressionJSON;
+}
+
+- (NSExpression *)mlnStyleValue {
+  if ([_styleType isEqualToString:@"color"] &&
+      [expressionJSON respondsToSelector:@selector(objectEnumerator)] &&
+      [[[(NSArray *)expressionJSON objectEnumerator] nextObject] isKindOfClass:[NSNumber class]]) {
+    UIColor *color = [MLRNUtils toColor:expressionJSON];
+    return [NSExpression expressionWithMLNJSONObject:color];
+  } else if ([_styleType isEqualToString:@"color"] &&
+             [expressionJSON isKindOfClass:[NSNumber class]]) {
+    UIColor *color = [MLRNUtils toColor:expressionJSON];
+    return [NSExpression expressionWithMLNJSONObject:color];
+  } else if ([_styleType isEqualToString:@"vector"] &&
+             [expressionJSON respondsToSelector:@selector(objectEnumerator)] &&
+             [[[(NSArray *)expressionJSON objectEnumerator] nextObject]
+                 isKindOfClass:[NSNumber class]]) {
+    CGVector vector = [MLRNUtils toCGVector:(NSArray<NSNumber *> *)expressionJSON];
+    return [NSExpression expressionWithMLNJSONObject:[NSValue valueWithCGVector:vector]];
+  } else if ([_styleType isEqualToString:@"image"] &&
+             [expressionJSON isKindOfClass:[NSDictionary class]]) {
+    return [NSExpression expressionForConstantValue:[self getImageURI]];
+  } else if ([_styleType isEqual:@"edgeinsets"] &&
+             [expressionJSON respondsToSelector:@selector(objectEnumerator)] &&
+             [[[(NSArray *)expressionJSON objectEnumerator] nextObject]
+                 isKindOfClass:[NSNumber class]]) {
+    UIEdgeInsets edgeInsets = [MLRNUtils toUIEdgeInsets:(NSArray<NSNumber *> *)expressionJSON];
+    return [NSExpression expressionWithMLNJSONObject:[NSValue valueWithUIEdgeInsets:edgeInsets]];
+  } else if ([_styleType isEqualToString:@"enum"] &&
+             [expressionJSON isKindOfClass:[NSNumber class]]) {
+    // ensure we pass through values as NSUInteger when mapping to an MLN enum
+    NSUInteger uintValue = [(NSNumber *)expressionJSON unsignedIntegerValue];
+    id rawValue = [NSValue value:&uintValue withObjCType:@encode(NSUInteger)];
+    return [NSExpression expressionWithMLNJSONObject:rawValue];
+  } else if ([expressionJSON respondsToSelector:@selector(objectEnumerator)] &&
+             [[[(NSArray *)expressionJSON objectEnumerator] nextObject]
+                 isKindOfClass:[NSNumber class]]) {
+    return [NSExpression expressionForConstantValue:expressionJSON];
+  } else {
+    return [NSExpression expressionWithMLNJSONObject:expressionJSON];
+  }
+}
+
+- (void)setStyleObject:(NSObject *)object {
+  expressionJSON = object;
+}
+
+- (NSObject *)parse:(NSDictionary *)rawStyleValue {
+  NSObject *object = nil;
+  NSString *type = (NSString *)rawStyleValue[@"type"];
+
+  if ([type isEqualToString:@"string"]) {
+    object = (NSString *)rawStyleValue[@"value"];
+  } else if ([type isEqualToString:@"number"]) {
+    object = (NSNumber *)rawStyleValue[@"value"];
+  } else if ([type isEqualToString:@"boolean"]) {
+    object = rawStyleValue[@"value"];
+  } else if ([type isEqualToString:@"hashmap"]) {
+    NSMutableDictionary *dict = [[NSMutableDictionary alloc] init];
+    NSArray *values = (NSArray *)rawStyleValue[@"value"];
+
+    for (int i = 0; i < values.count; i++) {
+      NSObject *key = [self parse:values[i][0]];
+      NSObject *value = [self parse:values[i][1]];
+      dict[[key mutableCopy]] = value;
+    }
+
+    object = dict;
+  } else if ([type isEqualToString:@"array"]) {
+    NSMutableArray *arr = [[NSMutableArray alloc] init];
+    NSArray *values = (NSArray *)rawStyleValue[@"value"];
+
+    for (int i = 0; i < values.count; i++) {
+      [arr addObject:[self parse:values[i]]];
+    }
+
+    object = arr;
+  }
+
+  return object;
+}
+
+- (BOOL)shouldAddImage {
+  NSString *imageURI = [self getImageURI];
+
+  return [imageURI containsString:@"://"];
+}
+
+- (NSString *)getImageURI {
+  if ([expressionJSON isKindOfClass:[NSDictionary class]]) {
+    return [expressionJSON valueForKey:@"uri"];
+  } else if ([expressionJSON isKindOfClass:[NSArray class]]) {
+    return nil;
+  } else {
+    return (NSString *)expressionJSON;
+  }
+}
+
+- (double)getImageScale {
+  if ([expressionJSON isKindOfClass:[NSDictionary class]]) {
+    id scale = [expressionJSON valueForKey:@"scale"];
+    if ([scale isKindOfClass:[NSNumber class]]) {
+      return [scale doubleValue];
+    } else {
+      return 1.0;
+    }
+  } else {
+    return 1.0;
+  }
+}
+
+- (BOOL)getImageSdf {
+  if ([expressionJSON isKindOfClass:[NSDictionary class]]) {
+    id sdf = [expressionJSON valueForKey:@"sdf"];
+    if ([sdf isKindOfClass:[NSNumber class]]) {
+      return [sdf boolValue];
+    } else {
+      return false;
+    }
+  } else {
+    return false;
+  }
+}
+
+- (MLNTransition)getTransition {
+  if (![expressionJSON isKindOfClass:[NSDictionary class]]) {
+    return MLNTransitionMake(0.f, 0.f);
+  }
+
+  NSDictionary *config = (NSDictionary *)expressionJSON;
+  double duration = config[@"duration"] != nil ? [config[@"duration"] doubleValue] : 300.0;
+  double delay = config[@"delay"] != nil ? [config[@"delay"] doubleValue] : 0.0;
+
+  const double millisecondsToSeconds = 1.0 / 1000.0;
+
+  return MLNTransitionMake(duration * millisecondsToSeconds, delay * millisecondsToSeconds);
+}
+
+- (NSExpression *)getSphericalPosition {
+  NSArray *values = (NSArray<NSNumber *> *)expressionJSON;
+
+  CGFloat radial = [values[0] floatValue];
+  CLLocationDistance azimuthal = [values[1] doubleValue];
+  CLLocationDistance polar = [values[2] doubleValue];
+
+  MLNSphericalPosition pos = MLNSphericalPositionMake(radial, azimuthal, polar);
+  return [NSExpression expressionWithMLNJSONObject:@(pos)];
+}
+
+- (BOOL)isVisible {
+  if ([expressionJSON isKindOfClass:[NSString class]]) {
+    NSString *visible = (NSString *)expressionJSON;
+    return [visible isEqualToString:@"visible"];
+  }
+  return YES;
+}
+
++ (MLRNStyleValue *)make:(NSDictionary *)rawStyleValue;
+{
+  MLRNStyleValue *styleValue = [[MLRNStyleValue alloc] init];
+  styleValue.styleType = (NSString *)rawStyleValue[@"styletype"];
+  NSObject *object = [styleValue parse:(NSDictionary *)rawStyleValue[@"stylevalue"]];
+  [styleValue setStyleObject:object];
+  return styleValue;
+}
+
+@end

package/ios/components/map-view/MLRNMapTouchEvent.h

@@ -0,0 +1,18 @@
+#import <Foundation/Foundation.h>
+#import "MLRNEvent.h"
+#import "MLRNPointAnnotation.h"
+
+#import <MapLibre/MapLibre.h>
+
+@interface MLRNMapTouchEvent : MLRNEvent
+
+@property (nonatomic, copy) NSString *id;
+@property (nonatomic, assign) CLLocationCoordinate2D coordinate;
+@property (nonatomic, assign) CGPoint screenPoint;
+
++ (MLRNMapTouchEvent *)makeTapEvent:(MLNMapView *)mapView withPoint:(CGPoint)point;
++ (MLRNMapTouchEvent *)makeLongPressEvent:(MLNMapView *)mapView withPoint:(CGPoint)point;
++ (MLRNMapTouchEvent *)makeAnnotationTapEvent:(MLRNPointAnnotation *)pointAnnotation;
++ (MLRNMapTouchEvent *)makeAnnotationTapEventOnDrag:(MLRNPointAnnotation *)pointAnnotation;
+
+@end

package/ios/components/map-view/MLRNMapTouchEvent.m

@@ -0,0 +1,72 @@
+#import "MLRNMapTouchEvent.h"
+#import "MLRNEventTypes.h"
+#import "MLRNPointAnnotation.h"
+@import MapLibre;
+
+@implementation MLRNMapTouchEvent
+
+- (NSDictionary *)payload {
+  MLNPointFeature *feature = [[MLNPointFeature alloc] init];
+  feature.coordinate = _coordinate;
+  if (_id == nil) {
+    feature.attributes = @{
+      @"longitude" : [NSNumber numberWithDouble:_coordinate.longitude],
+      @"latitude" : [NSNumber numberWithDouble:_coordinate.latitude],
+      @"locationX" : [NSNumber numberWithDouble:_screenPoint.x],
+      @"locationY" : [NSNumber numberWithDouble:_screenPoint.y]
+    };
+  } else {
+    feature.attributes = @{
+      @"id" : _id,
+      @"longitude" : [NSNumber numberWithDouble:_coordinate.longitude],
+      @"latitude" : [NSNumber numberWithDouble:_coordinate.latitude],
+      @"locationX" : [NSNumber numberWithDouble:_screenPoint.x],
+      @"locationY" : [NSNumber numberWithDouble:_screenPoint.y]
+    };
+  }
+  return [feature geoJSONDictionary];
+}
+
++ (MLRNMapTouchEvent *)makeTapEvent:(MLNMapView *)mapView withPoint:(CGPoint)point {
+  return [MLRNMapTouchEvent _fromPoint:point withMapView:mapView andEventType:RCT_MLRN_PRESS];
+}
+
++ (MLRNMapTouchEvent *)makeLongPressEvent:(MLNMapView *)mapView withPoint:(CGPoint)point {
+  return [MLRNMapTouchEvent _fromPoint:point withMapView:mapView andEventType:RCT_MLRN_LONG_PRESS];
+}
+
++ (MLRNMapTouchEvent *)makeAnnotationTapEvent:(MLRNPointAnnotation *)pointAnnotation {
+  MLRNMapTouchEvent *event = [[MLRNMapTouchEvent alloc] init];
+  event.type = RCT_MLRN_ANNOTATION_TAP;
+  event.id = pointAnnotation.id;
+  event.coordinate = pointAnnotation.coordinate;
+  event.screenPoint = [pointAnnotation.superview convertPoint:pointAnnotation.frame.origin
+                                                       toView:nil];
+  return event;
+}
+
++ (MLRNMapTouchEvent *)makeAnnotationTapEventOnDrag:(MLRNPointAnnotation *)pointAnnotation {
+  MLRNMapTouchEvent *event = [[MLRNMapTouchEvent alloc] init];
+  event.type = RCT_MLRN_ANNOTATION_TAP;
+  event.id = pointAnnotation.id;
+  CGPoint screenPoint = [pointAnnotation.superview convertPoint:pointAnnotation.layer.position
+                                                         toView:nil];
+  screenPoint.x -= (pointAnnotation.layer.bounds.size.width * pointAnnotation.layer.anchorPoint.x);
+  screenPoint.y -= (pointAnnotation.layer.bounds.size.height * pointAnnotation.layer.anchorPoint.y);
+  event.screenPoint = screenPoint;
+  event.coordinate = [pointAnnotation.map convertPoint:pointAnnotation.layer.position
+                                  toCoordinateFromView:pointAnnotation.map];
+  return event;
+}
+
++ (MLRNMapTouchEvent *)_fromPoint:(CGPoint)point
+                      withMapView:(MLNMapView *)mapView
+                     andEventType:(NSString *)eventType {
+  MLRNMapTouchEvent *event = [[MLRNMapTouchEvent alloc] init];
+  event.type = eventType;
+  event.coordinate = [mapView convertPoint:point toCoordinateFromView:mapView];
+  event.screenPoint = point;
+  return event;
+}
+
+@end

package/ios/components/map-view/MLRNMapView.h

@@ -0,0 +1,111 @@
+#import <React/RCTComponent.h>
+
+#import <MapLibre/MapLibre.h>
+
+#import "MLRNPointAnnotation.h"
+#import "MLRNSource.h"
+
+@class CameraUpdateQueue;
+@class MLRNImages;
+@class MLRNLogging;
+
+@protocol MLRNMapViewCamera <NSObject>
+- (void)initialLayout;
+- (void)didChangeUserTrackingMode:(MLNUserTrackingMode)mode animated:(BOOL)animated;
+@end
+
+typedef void (^FoundLayerBlock)(MLNStyleLayer *__nonnull layer);
+typedef void (^StyleLoadedBlock)(MLNStyle *__nonnull style);
+
+@interface MLRNMapView : MLNMapView <RCTInvalidating, MLNMapViewDelegate>
+
+- initWithFrame:(CGRect)frame;
+- (void)addToMap:(UIView *_Nonnull)subview;
+- (void)removeFromMap:(UIView *_Nonnull)subview;
+
+@property (nonatomic, strong, nonnull) MLRNLogging *logging;
+@property (nonatomic, strong, nonnull) CameraUpdateQueue *cameraUpdateQueue;
+@property (nonatomic, weak) id<MLRNMapViewCamera> reactCamera;
+@property (nonatomic, strong, nonnull) NSMutableArray<UIView *> *reactSubviews;
+@property (nonatomic, strong, nonnull) NSMutableArray<MLRNSource *> *sources;
+@property (nonatomic, strong, nonnull) NSMutableArray<MLRNImages *> *images;
+@property (nonatomic, strong, nonnull) NSMutableArray<MLRNLayer *> *layers;
+@property (nonatomic, strong, nonnull) NSMutableArray<MLRNPointAnnotation *> *pointAnnotations;
+
+@property (nonatomic, strong, nonnull)
+    NSMutableDictionary<NSString *, NSMutableArray<FoundLayerBlock> *> *layerWaiters;
+@property (nonatomic, strong, nonnull) NSMutableArray<StyleLoadedBlock> *styleWaiters;
+
+@property (nonatomic, copy, nullable) NSString *reactMapStyle;
+@property (nonatomic, copy, nullable) NSDictionary *reactLight;
+@property (nonatomic, copy, nullable) NSDictionary<NSString *, NSNumber *> *reactContentInset;
+@property (nonatomic, assign) NSInteger reactPreferredFramesPerSecond;
+
+@property (nonatomic, assign) BOOL reactScrollEnabled;
+@property (nonatomic, assign) BOOL reactZoomEnabled;
+@property (nonatomic, assign) BOOL reactRotateEnabled;
+@property (nonatomic, assign) BOOL reactPitchEnabled;
+
+@property (nonatomic, assign) BOOL reactAttributionEnabled;
+@property (nonatomic, strong, nullable)
+    NSDictionary<NSString *, NSNumber *> *reactAttributionPosition;
+
+@property (nonatomic, assign) BOOL reactLogoEnabled;
+@property (nonatomic, strong, nullable) NSDictionary<NSString *, NSNumber *> *reactLogoPosition;
+
+@property (nonatomic, assign) BOOL reactCompassEnabled;
+@property (nonatomic, strong, nullable) NSDictionary<NSString *, NSNumber *> *reactCompassPosition;
+
+@property (nonatomic, assign) MLNCoordinateBounds maxBounds;
+
+@property (nonatomic, assign) BOOL isUserInteraction;
+@property (nonatomic, assign) BOOL useNativeUserLocationAnnotationView;
+
+@property (nonatomic, copy, nullable) RCTBubblingEventBlock reactOnPress;
+@property (nonatomic, copy, nullable) RCTBubblingEventBlock reactOnLongPress;
+
+@property (nonatomic, copy, nullable) RCTDirectEventBlock reactOnRegionWillChange;
+@property (nonatomic, copy, nullable) RCTDirectEventBlock reactOnRegionIsChanging;
+@property (nonatomic, copy, nullable) RCTDirectEventBlock reactOnRegionDidChange;
+
+@property (nonatomic, copy, nullable) RCTDirectEventBlock reactOnWillStartLoadingMap;
+@property (nonatomic, copy, nullable) RCTDirectEventBlock reactOnDidFinishLoadingMap;
+@property (nonatomic, copy, nullable) RCTDirectEventBlock reactOnDidFailLoadingMap;
+
+@property (nonatomic, copy, nullable) RCTDirectEventBlock reactOnWillStartRenderingFrame;
+@property (nonatomic, copy, nullable) RCTDirectEventBlock reactOnDidFinishRenderingFrame;
+@property (nonatomic, copy, nullable) RCTDirectEventBlock reactOnDidFinishRenderingFrameFully;
+
+@property (nonatomic, copy, nullable) RCTDirectEventBlock reactOnWillStartRenderingMap;
+@property (nonatomic, copy, nullable) RCTDirectEventBlock reactOnDidFinishRenderingMap;
+@property (nonatomic, copy, nullable) RCTDirectEventBlock reactOnDidFinishRenderingMapFully;
+
+@property (nonatomic, copy, nullable) RCTDirectEventBlock reactOnDidFinishLoadingStyle;
+
+- (void)layerAdded:(nonnull MLNStyleLayer *)layer;
+
+- (CLLocationDistance)getMetersPerPixelAtLatitude:(double)latitude withZoom:(double)zoomLevel;
+- (CLLocationDistance)altitudeFromZoom:(double)zoomLevel;
+- (CLLocationDistance)altitudeFromZoom:(double)zoomLevel atLatitude:(CLLocationDegrees)latitude;
+- (CLLocationDistance)altitudeFromZoom:(double)zoomLevel
+                            atLatitude:(CLLocationDegrees)latitude
+                               atPitch:(CGFloat)pitch;
+- (nonnull MLRNPointAnnotation *)getRCTPointAnnotation:(nonnull MLNPointAnnotation *)mlnAnnotation;
+- (nonnull NSArray<MLRNSource *> *)getAllTouchableSources;
+- (nonnull NSArray<MLRNSource *> *)getAllShapeSources;
+- (nonnull NSArray<MLRNImages *> *)getAllImages;
+- (nonnull MLRNSource *)getTouchableSourceWithHighestZIndex:
+    (nonnull NSArray<MLRNSource *> *)touchableSources;
+- (nonnull NSString *)takeSnap:(BOOL)writeToDisk;
+- (void)didChangeUserTrackingMode:(MLNUserTrackingMode)mode animated:(BOOL)animated;
+
+- (void)waitForLayerWithId:(nonnull NSString *)layerId
+                      then:(void (^_Nonnull)(MLNStyleLayer *_Nonnull layer))foundLayer;
+
+- (void)setSourceVisibility:(BOOL)visibility
+                   sourceId:(nonnull NSString *)sourceId
+              sourceLayerId:(nullable NSString *)sourceLayerId;
+
+- (void)notifyStyleLoaded;
+
+@end