@maplibre/maplibre-react-native 11.0.0-alpha.1 → 11.0.0-alpha.11

package/ios/components/map-view/MLRNMapViewModule.mm

@@ -0,0 +1,249 @@
+#import "MLRNMapViewModule.h"
+
+#import "FilterParser.h"
+#import "MLRNMapView.h"
+#import "MLRNMapViewComponentView.h"
+#import "MLRNMapViewManager.h"
+#import "MLRNUtils.h"
+
+@implementation MLRNMapViewModule
+
+@synthesize viewRegistry_DEPRECATED = _viewRegistry_DEPRECATED;
+
++ (NSString *)moduleName {
+  return @"MLRNMapViewModule";
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeMapViewModuleSpecJSI>(params);
+}
+
+- (void)withMapView:(NSInteger)reactTag
+              block:(void (^)(MLRNMapView *))block
+             reject:(RCTPromiseRejectBlock)reject
+         methodName:(NSString *)methodName {
+  [self.viewRegistry_DEPRECATED addUIBlock:^(RCTViewRegistry *viewRegistry) {
+    UIView *view =
+        [self.viewRegistry_DEPRECATED viewForReactTag:[NSNumber numberWithInteger:reactTag]];
+
+    if ([view isKindOfClass:[MLRNMapViewComponentView class]]) {
+      MLRNMapViewComponentView *componentView = (MLRNMapViewComponentView *)view;
+
+      if ([componentView.contentView isKindOfClass:[MLRNMapView class]]) {
+        MLRNMapView *mapView = (MLRNMapView *)componentView.contentView;
+
+        block(mapView);
+        return;
+      }
+    }
+
+    reject(methodName,
+           [NSString stringWithFormat:@"Invalid `reactTag` %@, could not find MLRNMapView",
+                                      [NSNumber numberWithInteger:reactTag]],
+           nil);
+  }];
+}
+
+- (void)getCenter:(NSInteger)reactTag
+          resolve:(RCTPromiseResolveBlock)resolve
+           reject:(RCTPromiseRejectBlock)reject {
+  [self withMapView:reactTag
+              block:^(MLRNMapView *view) {
+                [MLRNMapViewManager getCenter:view resolve:resolve reject:reject];
+              }
+             reject:reject
+         methodName:@"getCenter"];
+}
+
+- (void)getZoom:(NSInteger)reactTag
+        resolve:(RCTPromiseResolveBlock)resolve
+         reject:(RCTPromiseRejectBlock)reject {
+  [self withMapView:reactTag
+              block:^(MLRNMapView *view) {
+                [MLRNMapViewManager getZoom:view resolve:resolve reject:reject];
+              }
+             reject:reject
+         methodName:@"getZoom"];
+}
+
+- (void)getBearing:(NSInteger)reactTag
+           resolve:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject {
+  [self withMapView:reactTag
+              block:^(MLRNMapView *view) {
+                [MLRNMapViewManager getBearing:view resolve:resolve reject:reject];
+              }
+             reject:reject
+         methodName:@"getBearing"];
+}
+
+- (void)getPitch:(NSInteger)reactTag
+         resolve:(RCTPromiseResolveBlock)resolve
+          reject:(RCTPromiseRejectBlock)reject {
+  [self withMapView:reactTag
+              block:^(MLRNMapView *view) {
+                [MLRNMapViewManager getPitch:view resolve:resolve reject:reject];
+              }
+             reject:reject
+         methodName:@"getPitch"];
+}
+
+- (void)getBounds:(NSInteger)reactTag
+          resolve:(RCTPromiseResolveBlock)resolve
+           reject:(RCTPromiseRejectBlock)reject {
+  [self withMapView:reactTag
+              block:^(MLRNMapView *view) {
+                [MLRNMapViewManager getBounds:view resolve:resolve reject:reject];
+              }
+             reject:reject
+         methodName:@"getBounds"];
+}
+
+- (void)getViewState:(NSInteger)reactTag
+             resolve:(RCTPromiseResolveBlock)resolve
+              reject:(RCTPromiseRejectBlock)reject {
+  [self withMapView:reactTag
+              block:^(MLRNMapView *view) {
+                [MLRNMapViewManager getViewState:view resolve:resolve reject:reject];
+              }
+             reject:reject
+         methodName:@"getViewState"];
+}
+
+- (void)project:(NSInteger)reactTag
+     coordinate:(JS::NativeMapViewModule::SpecProjectCoordinate &)coordinate
+        resolve:(RCTPromiseResolveBlock)resolve
+         reject:(RCTPromiseRejectBlock)reject {
+  [self withMapView:reactTag
+              block:^(MLRNMapView *view) {
+                [MLRNMapViewManager project:view
+                                 coordinate:CLLocationCoordinate2DMake(coordinate.latitude(),
+                                                                       coordinate.longitude())
+                                    resolve:resolve
+                                     reject:reject];
+              }
+             reject:reject
+         methodName:@"project"];
+}
+
+- (void)unproject:(NSInteger)reactTag
+            point:(JS::NativeMapViewModule::SpecUnprojectPoint &)point
+          resolve:(RCTPromiseResolveBlock)resolve
+           reject:(RCTPromiseRejectBlock)reject {
+  [self withMapView:reactTag
+              block:^(MLRNMapView *view) {
+                [MLRNMapViewManager unproject:view
+                                        point:CGPointMake(point.locationX(), point.locationY())
+                                      resolve:resolve
+                                       reject:reject];
+              }
+             reject:reject
+         methodName:@"unproject"];
+}
+
+- (void)takeSnap:(NSInteger)reactTag
+     writeToDisk:(BOOL)writeToDisk
+         resolve:(RCTPromiseResolveBlock)resolve
+          reject:(RCTPromiseRejectBlock)reject {
+  [self withMapView:reactTag
+              block:^(MLRNMapView *view) {
+                [MLRNMapViewManager takeSnap:view
+                                 writeToDisk:writeToDisk
+                                     resolve:resolve
+                                      reject:reject];
+              }
+             reject:reject
+         methodName:@"takeSnap"];
+}
+
+- (void)queryRenderedFeaturesWithCoordinate:(NSInteger)reactTag
+                                 coordinate:
+                                     (JS::NativeMapViewModule::
+                                          SpecQueryRenderedFeaturesWithCoordinateCoordinate &)
+                                         coordinate
+                                     layers:(nonnull NSArray<NSString *> *)layers
+                                     filter:(nonnull NSArray *)filter
+                                    resolve:(nonnull RCTPromiseResolveBlock)resolve
+                                     reject:(nonnull RCTPromiseRejectBlock)reject {
+  [self withMapView:reactTag
+              block:^(MLRNMapView *view) {
+                NSSet *layerIdSet = nil;
+                if (layers != nil && layers.count > 0) {
+                  layerIdSet = [NSSet setWithArray:layers];
+                }
+
+                NSPredicate *predicate = [FilterParser parse:filter];
+
+                [MLRNMapViewManager queryRenderedFeaturesWithCoordinate:view
+                                                             coordinate:CLLocationCoordinate2D(
+                                                                            coordinate.latitude(),
+                                                                            coordinate.longitude())
+                                                               layerIds:layerIdSet
+                                                              predicate:predicate
+                                                                resolve:resolve
+                                                                 reject:reject];
+              }
+             reject:reject
+         methodName:@"queryRenderedFeaturesWithCoordinate"];
+}
+
+- (void)queryRenderedFeaturesWithBounds:(NSInteger)reactTag
+                                 bounds:(NSArray<NSNumber *> *)bounds
+                                 layers:(NSArray<NSString *> *)layers
+                                 filter:(NSArray *)filter
+                                resolve:(RCTPromiseResolveBlock)resolve
+                                 reject:(RCTPromiseRejectBlock)reject {
+  [self withMapView:reactTag
+              block:^(MLRNMapView *view) {
+                MLNCoordinateBounds coordinateBounds = [MLRNUtils fromReactBounds:bounds];
+
+                NSSet *layerIdSet = nil;
+                if (layers != nil && layers.count > 0) {
+                  layerIdSet = [NSSet setWithArray:layers];
+                }
+
+                NSPredicate *predicate = [FilterParser parse:filter];
+
+                [MLRNMapViewManager queryRenderedFeaturesWithBounds:view
+                                                             bounds:coordinateBounds
+                                                           layerIds:layerIdSet
+                                                          predicate:predicate
+                                                            resolve:resolve
+                                                             reject:reject];
+              }
+             reject:reject
+         methodName:@"queryRenderedFeaturesInRect"];
+}
+
+- (void)showAttribution:(NSInteger)reactTag
+                resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject {
+  [self withMapView:reactTag
+              block:^(MLRNMapView *view) {
+                [MLRNMapViewManager showAttribution:view resolve:resolve reject:reject];
+              }
+             reject:reject
+         methodName:@"showAttribution"];
+}
+
+- (void)setSourceVisibility:(NSInteger)reactTag
+                    visible:(BOOL)visible
+                   sourceId:(nonnull NSString *)sourceId
+              sourceLayerId:(NSString *)sourceLayerId
+                    resolve:(RCTPromiseResolveBlock)resolve
+                     reject:(RCTPromiseRejectBlock)reject {
+  [self withMapView:reactTag
+              block:^(MLRNMapView *view) {
+                [MLRNMapViewManager setSourceVisibility:view
+                                                visible:visible
+                                               sourceId:sourceId
+                                          sourceLayerId:sourceLayerId
+                                                resolve:resolve
+                                                 reject:reject];
+              }
+             reject:reject
+         methodName:@"setSourceVisibility"];
+}
+
+@end

package/ios/components/sources/MLRNShapeSource.h

@@ -0,0 +1,36 @@
+#import <React/RCTBridge.h>
+#import "MLRNSource.h"
+
+#import <MapLibre/MapLibre.h>
+
+@interface MLRNShapeSource : MLRNSource
+
+@property (nonatomic, weak) RCTBridge *bridge;
+
+@property (nonatomic, copy, nullable) NSString *url;
+@property (nonatomic, copy, nullable) NSString *shape;
+
+@property (nonatomic, strong, nullable) NSNumber *cluster;
+@property (nonatomic, strong, nullable) NSNumber *clusterRadius;
+@property (nonatomic, strong, nullable) NSNumber *clusterMinPoints;
+@property (nonatomic, strong, nullable) NSNumber *clusterMaxZoomLevel;
+@property (nonatomic, strong, nullable)
+    NSDictionary<NSString *, NSArray<NSExpression *> *> *clusterProperties;
+
+@property (nonatomic, strong, nullable) NSNumber *maxZoomLevel;
+@property (nonatomic, strong, nullable) NSNumber *buffer;
+@property (nonatomic, strong, nullable) NSNumber *tolerance;
+@property (nonatomic, strong, nullable) NSNumber *lineMetrics;
+
+@property (nonatomic, copy, nullable) RCTBubblingEventBlock onPress;
+@property (nonatomic, assign) BOOL hasPressListener;
+
+- (nonnull NSArray<id<MLNFeature>> *)featuresMatchingPredicate:(nullable NSPredicate *)predicate;
+- (nonnull NSArray<id<MLNFeature>> *)getClusterLeaves:(nonnull NSString *)featureJSON
+                                               number:(NSUInteger)number
+                                               offset:(NSUInteger)offset;
+- (nonnull NSArray<id<MLNFeature>> *)getClusterChildren:(nonnull NSString *)featureJSON;
+
+- (double)getClusterExpansionZoom:(nonnull NSString *)featureJSON;
+
+@end

package/ios/components/sources/MLRNShapeSource.m

@@ -0,0 +1,144 @@
+#import "MLRNShapeSource.h"
+#import "MLRNMapView.h"
+#import "MLRNUtils.h"
+
+@implementation MLRNShapeSource
+
+static UIImage *_placeHolderImage;
+
+- (void)setUrl:(NSString *)url {
+  _url = url;
+  if (self.source != nil) {
+    MLNShapeSource *source = (MLNShapeSource *)self.source;
+    [source setURL:url == nil ? nil : [NSURL URLWithString:url]];
+  }
+}
+
+- (void)setShape:(NSString *)shape {
+  _shape = shape;
+
+  if (self.source != nil) {
+    MLNShapeSource *source = (MLNShapeSource *)self.source;
+    [source setShape:shape == nil ? nil : [MLRNUtils shapeFromGeoJSON:_shape]];
+  }
+}
+
+- (void)addToMap {
+  if (self.map.style == nil) {
+    return;
+  }
+  [super addToMap];
+}
+
+- (void)removeFromMap {
+  if (self.map.style == nil) {
+    return;
+  }
+
+  [super removeFromMap];
+}
+
+- (nullable MLNSource *)makeSource {
+  NSDictionary<MLNShapeSourceOption, id> *options = [self _getOptions];
+
+  if (_shape != nil) {
+    MLNShape *shape = [MLRNUtils shapeFromGeoJSON:_shape];
+    return [[MLNShapeSource alloc] initWithIdentifier:self.id shape:shape options:options];
+  }
+
+  if (_url != nil) {
+    NSURL *url = [[NSURL alloc] initWithString:_url];
+    return [[MLNShapeSource alloc] initWithIdentifier:self.id URL:url options:options];
+  }
+  return nil;
+}
+
+- (NSDictionary<MLNShapeSourceOption, id> *)_getOptions {
+  NSMutableDictionary<MLNShapeSourceOption, id> *options = [[NSMutableDictionary alloc] init];
+
+  if (_cluster != nil) {
+    options[MLNShapeSourceOptionClustered] = [NSNumber numberWithBool:[_cluster intValue] == 1];
+  }
+
+  if (_clusterRadius != nil) {
+    options[MLNShapeSourceOptionClusterRadius] = _clusterRadius;
+  }
+
+  if (_clusterMinPoints != nil) {
+    options[MLNShapeSourceOptionClusterMinPoints] = _clusterMinPoints;
+  }
+
+  if (_clusterMaxZoomLevel != nil) {
+    options[MLNShapeSourceOptionMaximumZoomLevelForClustering] = _clusterMaxZoomLevel;
+  }
+
+  if (_clusterProperties != nil) {
+    NSMutableDictionary<NSString *, NSArray *> *properties = [NSMutableDictionary new];
+
+    for (NSString *propertyName in _clusterProperties.allKeys) {
+      NSArray<NSExpression *> *expressions = [_clusterProperties objectForKey:propertyName];
+      NSExpression *firstExpression =
+          [NSExpression expressionWithMLNJSONObject:[expressions objectAtIndex:0]];
+      NSExpression *secondExpression =
+          [NSExpression expressionWithMLNJSONObject:[expressions objectAtIndex:1]];
+
+      [properties setObject:@[ firstExpression, secondExpression ] forKey:propertyName];
+    }
+
+    options[MLNShapeSourceOptionClusterProperties] = properties;
+  }
+
+  if (_maxZoomLevel != nil) {
+    options[MLNShapeSourceOptionMaximumZoomLevel] = _maxZoomLevel;
+  }
+
+  if (_buffer != nil) {
+    options[MLNShapeSourceOptionBuffer] = _buffer;
+  }
+
+  if (_tolerance != nil) {
+    options[MLNShapeSourceOptionSimplificationTolerance] = _tolerance;
+  }
+
+  if (_lineMetrics != nil) {
+    options[MLNShapeSourceOptionLineDistanceMetrics] = _lineMetrics;
+  }
+
+  return options;
+}
+
+- (nonnull NSArray<id<MLNFeature>> *)featuresMatchingPredicate:(nullable NSPredicate *)predicate {
+  MLNShapeSource *shapeSource = (MLNShapeSource *)self.source;
+
+  return [shapeSource featuresMatchingPredicate:predicate];
+}
+
+- (double)getClusterExpansionZoom:(nonnull NSString *)featureJSON {
+  MLNShapeSource *shapeSource = (MLNShapeSource *)self.source;
+
+  MLNPointFeature *feature = (MLNPointFeature *)[MLRNUtils shapeFromGeoJSON:featureJSON];
+
+  return [shapeSource zoomLevelForExpandingCluster:(MLNPointFeatureCluster *)feature];
+}
+
+- (nonnull NSArray<id<MLNFeature>> *)getClusterLeaves:(nonnull NSString *)featureJSON
+                                               number:(NSUInteger)number
+                                               offset:(NSUInteger)offset {
+  MLNShapeSource *shapeSource = (MLNShapeSource *)self.source;
+
+  MLNPointFeature *feature = (MLNPointFeature *)[MLRNUtils shapeFromGeoJSON:featureJSON];
+
+  MLNPointFeatureCluster *cluster = (MLNPointFeatureCluster *)feature;
+  return [shapeSource leavesOfCluster:cluster offset:offset limit:number];
+}
+
+- (nonnull NSArray<id<MLNFeature>> *)getClusterChildren:(nonnull NSString *)featureJSON {
+  MLNShapeSource *shapeSource = (MLNShapeSource *)self.source;
+
+  MLNPointFeature *feature = (MLNPointFeature *)[MLRNUtils shapeFromGeoJSON:featureJSON];
+
+  MLNPointFeatureCluster *cluster = (MLNPointFeatureCluster *)feature;
+  return [shapeSource childrenOfCluster:cluster];
+}
+
+@end

package/ios/components/sources/MLRNShapeSourceManager.m

@@ -0,0 +1,128 @@
+#import <React/RCTUIManager.h>
+
+#import "MLRNShapeSource.h"
+#import "MLRNShapeSourceManager.h"
+
+#import "FilterParser.h"
+
+@implementation MLRNShapeSourceManager
+
+RCT_EXPORT_MODULE(MLRNShapeSource)
+
+RCT_EXPORT_VIEW_PROPERTY(id, NSString)
+RCT_EXPORT_VIEW_PROPERTY(url, NSString)
+RCT_EXPORT_VIEW_PROPERTY(shape, NSString)
+
+RCT_EXPORT_VIEW_PROPERTY(cluster, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(clusterRadius, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(clusterMinPoints, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(clusterMaxZoomLevel, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(clusterProperties, NSDictionary)
+RCT_EXPORT_VIEW_PROPERTY(maxZoomLevel, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(buffer, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(tolerance, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(lineMetrics, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(images, NSDictionary)
+RCT_EXPORT_VIEW_PROPERTY(nativeImages, NSArray)
+RCT_EXPORT_VIEW_PROPERTY(hasPressListener, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(hitbox, NSDictionary)
+RCT_REMAP_VIEW_PROPERTY(onMapboxShapeSourcePress, onPress, RCTBubblingEventBlock)
+
+- (UIView *)view {
+  MLRNShapeSource *source = [MLRNShapeSource new];
+  source.bridge = self.bridge;
+  return source;
+}
+
+RCT_EXPORT_METHOD(features : (nonnull NSNumber *)reactTag withFilter : (NSArray *)
+                      filter resolver : (RCTPromiseResolveBlock)
+                          resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *manager,
+                                      NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    UIView *view = viewRegistry[reactTag];
+    MLRNShapeSource *shapeSource = nil;
+
+    if ([view isKindOfClass:[MLRNShapeSource class]]) {
+      shapeSource = (MLRNShapeSource *)view;
+    } else {
+      RCTLogError(@"Invalid react tag, could not find MLRNShapeSource");
+      return;
+    }
+
+    NSPredicate *predicate = [FilterParser parse:filter];
+    NSArray<id<MLNFeature>> *shapes = [shapeSource featuresMatchingPredicate:predicate];
+
+    NSMutableArray<NSDictionary *> *features =
+        [[NSMutableArray alloc] initWithCapacity:shapes.count];
+    for (int i = 0; i < shapes.count; i++) {
+      [features addObject:shapes[i].geoJSONDictionary];
+    }
+
+    resolve(@{@"data" : @{@"type" : @"FeatureCollection", @"features" : features}});
+  }];
+}
+
+RCT_EXPORT_METHOD(getClusterExpansionZoom : (nonnull NSNumber *)reactTag featureJSON : (
+    nonnull NSString *)featureJSON resolver : (RCTPromiseResolveBlock)
+                      resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *manager,
+                                      NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    MLRNShapeSource *shapeSource = (MLRNShapeSource *)viewRegistry[reactTag];
+
+    if (![shapeSource isKindOfClass:[MLRNShapeSource class]]) {
+      RCTLogError(@"Invalid react tag, could not find MLRNMapView");
+      return;
+    }
+
+    double zoom = [shapeSource getClusterExpansionZoom:featureJSON];
+    if (zoom == -1) {
+      reject(@"zoom_error",
+             [NSString stringWithFormat:@"Could not get zoom for cluster %@", featureJSON], nil);
+      return;
+    }
+    resolve(@{@"data" : @(zoom)});
+  }];
+}
+
+RCT_EXPORT_METHOD(getClusterLeaves : (nonnull NSNumber *)reactTag featureJSON : (nonnull NSString *)
+                      featureJSON number : (NSUInteger)number offset : (NSUInteger)
+                          offset resolver : (RCTPromiseResolveBlock)
+                              resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *manager,
+                                      NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    MLRNShapeSource *shapeSource = (MLRNShapeSource *)viewRegistry[reactTag];
+
+    NSArray<id<MLNFeature>> *shapes = [shapeSource getClusterLeaves:featureJSON
+                                                             number:number
+                                                             offset:offset];
+
+    NSMutableArray<NSDictionary *> *features =
+        [[NSMutableArray alloc] initWithCapacity:shapes.count];
+    for (int i = 0; i < shapes.count; i++) {
+      [features addObject:shapes[i].geoJSONDictionary];
+    }
+
+    resolve(@{@"data" : @{@"type" : @"FeatureCollection", @"features" : features}});
+  }];
+}
+
+RCT_EXPORT_METHOD(getClusterChildren : (nonnull NSNumber *)reactTag featureJSON : (
+    nonnull NSString *)featureJSON resolver : (RCTPromiseResolveBlock)
+                      resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *manager,
+                                      NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    MLRNShapeSource *shapeSource = (MLRNShapeSource *)viewRegistry[reactTag];
+
+    NSArray<id<MLNFeature>> *shapes = [shapeSource getClusterChildren:featureJSON];
+
+    NSMutableArray<NSDictionary *> *features =
+        [[NSMutableArray alloc] initWithCapacity:shapes.count];
+    for (int i = 0; i < shapes.count; i++) {
+      [features addObject:shapes[i].geoJSONDictionary];
+    }
+
+    resolve(@{@"data" : @{@"type" : @"FeatureCollection", @"features" : features}});
+  }];
+}
+
+@end

package/ios/components/sources/MLRNSource.h

@@ -0,0 +1,29 @@
+#import <React/RCTComponent.h>
+#import <UIKit/UIKit.h>
+
+#import "MLRNLayer.h"
+
+#import <MapLibre/MapLibre.h>
+
+@interface MLRNSource : UIView
+
+extern NSString *_Nonnull const DEFAULT_SOURCE_ID;
+
+@property (nonatomic, strong, nonnull) NSMutableArray<id<RCTComponent>> *reactSubviews;
+@property (nonatomic, strong, nonnull) NSMutableArray<MLRNLayer *> *layers;
+@property (nonatomic, strong, nullable) MLNSource *source;
+@property (nonatomic, strong, nullable) MLRNMapView *map;
+@property (nonatomic, strong, nonnull) NSDictionary<NSString *, NSNumber *> *hitbox;
+
+@property (nonatomic, copy, nonnull) NSString *id;
+@property (nonatomic, assign) BOOL hasPressListener;
+@property (nonatomic, copy, nullable) RCTBubblingEventBlock onPress;
+
+- (void)addToMap;
+- (void)removeFromMap;
+- (nullable MLNSource *)makeSource;
+- (nonnull NSArray<NSString *> *)getLayerIDs;
+
++ (BOOL)isDefaultSource:(nonnull NSString *)sourceID;
+
+@end

package/ios/components/user-location/MLRNNativeUserLocation.m

@@ -0,0 +1,37 @@
+#import "MLRNNativeUserLocation.h"
+#import "CameraStop.h"
+#import "CameraUpdateQueue.h"
+#import "MLRNEvent.h"
+#import "MLRNEventTypes.h"
+#import "MLRNLocation.h"
+#import "MLRNLocationManager.h"
+#import "MLRNUtils.h"
+
+@implementation MLRNNativeUserLocation {
+}
+
+- (void)setMap:(MLRNMapView *)map {
+  if (map == nil && _map) {
+    _map.useNativeUserLocationAnnotationView = NO;
+    _map.showsUserLocation = NO;
+    _map.showsUserHeadingIndicator = NO;
+  } else if (map) {
+    map.useNativeUserLocationAnnotationView = YES;
+    // Toggle off/on showsUserLocation in order for Mapbox to invalidate the
+    // current (hidden) user location annotation view. See also: HiddenUserLocationAnnotationView
+    map.showsUserLocation = NO;
+    map.showsUserLocation = YES;
+    map.showsUserHeadingIndicator = self.iosShowsUserHeadingIndicator;
+  }
+
+  _map = map;
+}
+
+- (void)setIosShowsUserHeadingIndicator:(BOOL)iosShowsUserHeadingIndicator {
+  _iosShowsUserHeadingIndicator = iosShowsUserHeadingIndicator;
+  if (_map) {
+    _map.showsUserHeadingIndicator = iosShowsUserHeadingIndicator;
+  }
+}
+
+@end