@rnmapbox/maps 10.0.0-beta.28

package/ios/RCTMGL/RCTMGLLocationManager.h

@@ -0,0 +1,30 @@
+//
+//  RCTMGLLocationManager.h
+//  RCTMGL
+//
+//  Created by Nick Italiano on 6/21/18.
+//  Copyright © 2018 Mapbox Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+#import "RCTMGLLocation.h"
+#import "RCTMGLLocationManagerDelegate.h"
+
+typedef void (^RCTMGLLocationBlock)(RCTMGLLocation *location);
+
+@interface RCTMGLLocationManager : NSObject
+
+@property (nonatomic, strong) id<RCTMGLLocationManagerDelegate> delegate;
+
++ (id)sharedInstance;
+
+- (void)start:(CLLocationDistance)minDisplacement;
+- (void)stop;
+- (void)setMinDisplacement:(CLLocationDistance)minDisplacement;
+- (BOOL)isEnabled;
+- (RCTMGLLocation *)getLastKnownLocation;
+- (void)addListener:(RCTMGLLocationBlock)listener;
+- (void)removeListener:(RCTMGLLocationBlock)listener;
+
+@end

package/ios/RCTMGL/RCTMGLLocationManager.m

@@ -0,0 +1,180 @@
+//
+//  RCTMGLLocationManager.m
+//  RCTMGL
+//
+//  Created by Nick Italiano on 6/21/18.
+//  Copyright © 2018 Mapbox Inc. All rights reserved.
+//
+
+#import <CoreLocation/CoreLocation.h>
+#import "RCTMGLLocationManager.h"
+
+@interface RCTMGLLocationManager()<CLLocationManagerDelegate>
+@end
+
+@implementation RCTMGLLocationManager
+{
+    CLLocationManager *locationManager;
+    CLLocation *lastKnownLocation;
+    CLHeading *lastKnownHeading;
+    CLLocationDistance displacement;
+    NSMutableArray<RCTMGLLocationBlock> *listeners;
+    BOOL isListening;
+}
+
++ (id)sharedInstance
+{
+    static RCTMGLLocationManager *manager = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{ manager = [[self alloc] init]; });
+    return manager;
+}
+
+- (instancetype)init
+{
+    if (self = [super init]) {
+        [self _setupLocationManager];
+        listeners = [[NSMutableArray alloc] init];
+        displacement = 0.0;
+    }
+    return self;
+}
+
+- (void)dealloc
+{
+    locationManager.delegate = nil;
+    [self stop];
+}
+
+- (void)start:(CLLocationDistance)minDisplacement
+{
+
+    displacement = minDisplacement;
+
+    if ([self isEnabled]) {
+        return;
+    }
+
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [self->locationManager requestWhenInUseAuthorization];
+        [self->locationManager startUpdatingLocation];
+        [self->locationManager startUpdatingHeading];
+        [self->locationManager setDistanceFilter:(minDisplacement)];
+        self->isListening = YES;
+    });
+}
+
+- (void)setMinDisplacement:(CLLocationDistance)minDisplacement
+{
+
+    displacement = minDisplacement;
+
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [self->locationManager setDistanceFilter:(minDisplacement)];
+    });
+}
+
+- (void)stop
+{
+    if (![self isEnabled]) {
+        return;
+    }
+
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [self->locationManager stopUpdatingLocation];
+        [self->locationManager stopUpdatingHeading];
+        self->isListening = NO;
+    });
+}
+
+- (BOOL)isEnabled
+{
+    return isListening;
+}
+
+- (RCTMGLLocation *)getLastKnownLocation
+{
+    CLLocation* newLastLocation = locationManager.location;
+    if (newLastLocation) {
+      lastKnownLocation = newLastLocation;
+    }
+    RCTMGLLocation *location = [self _convertToMapboxLocation:lastKnownLocation];
+    return location;
+}
+
+- (void)addListener:(RCTMGLLocationBlock)listener
+{
+    if (![listeners containsObject:listener]) {
+        [listeners addObject:listener];
+    }
+}
+
+- (void)removeListener:(RCTMGLLocationBlock)listener
+{
+    NSUInteger indexOf = [listeners indexOfObject:listener];
+
+    if (indexOf == NSNotFound) {
+        return;
+    }
+
+    [listeners removeObjectAtIndex:indexOf];
+}
+
+- (void)locationManager:(CLLocationManager *)manager didUpdateHeading:(CLHeading *)heading
+{
+    lastKnownHeading = heading;
+
+    if (displacement > 0) {
+      return;
+    }
+
+    [self _updateDelegate];
+}
+
+- (void)locationManager:(CLLocationManager *)manager didUpdateLocations:(NSArray<CLLocation *> *)locations
+{
+    lastKnownLocation = [locations lastObject];
+    [self _updateDelegate];
+}
+
+- (void)_setupLocationManager
+{
+    __weak RCTMGLLocationManager *weakSelf = self;
+
+    dispatch_async(dispatch_get_main_queue(), ^{
+        self->locationManager = [[CLLocationManager alloc] init];
+        self->locationManager.delegate = weakSelf;
+    });
+}
+
+- (void)_updateDelegate
+{
+    if (_delegate == nil) {
+        return;
+    }
+
+    RCTMGLLocation *userLocation = [self _convertToMapboxLocation:lastKnownLocation];
+
+    if (listeners.count > 0) {
+        for (int i = 0; i < listeners.count; i++) {
+            RCTMGLLocationBlock listener = listeners[i];
+            listener(userLocation);
+        }
+    }
+
+    [_delegate locationManager:self didUpdateLocation:userLocation];
+}
+
+- (RCTMGLLocation *)_convertToMapboxLocation:(CLLocation *)location
+{
+    if (location == nil) {
+        return nil;
+    }
+
+    RCTMGLLocation *userLocation = [[RCTMGLLocation alloc] init];
+    userLocation.location = location;
+    userLocation.heading = lastKnownHeading;
+    return userLocation;
+}
+
+@end

package/ios/RCTMGL/RCTMGLLocationManagerDelegate.h

@@ -0,0 +1,20 @@
+//
+//  RCTMGLLocationManagerDelegate.h
+//  RCTMGL
+//
+//  Created by Nick Italiano on 6/21/18.
+//  Copyright © 2018 Mapbox Inc. All rights reserved.
+//
+
+#import <CoreLocation/CoreLocation.h>
+
+#import "RCTMGLLocation.h"
+
+@class RCTMGLLocationManager;
+
+@protocol RCTMGLLocationManagerDelegate<NSObject>
+
+- (void)locationManager:(RCTMGLLocationManager *)locationManager didUpdateLocation:(RCTMGLLocation *)location;
+
+@end
+

package/ios/RCTMGL/RCTMGLLocationModule.h

@@ -0,0 +1,15 @@
+//
+//  RCTMGLLocationManager.h
+//  RCTMGL
+//
+//  Created by Nick Italiano on 6/21/18.
+//  Copyright © 2018 Mapbox Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCTMGLLocationModule : RCTEventEmitter<RCTBridgeModule>
+
+@end

package/ios/RCTMGL/RCTMGLLocationModule.m

@@ -0,0 +1,99 @@
+//
+//  RCTMGLLocationManager.m
+//  RCTMGL
+//
+//  Created by Nick Italiano on 6/21/18.
+//  Copyright © 2018 Mapbox Inc. All rights reserved.
+//
+
+#import <CoreLocation/CoreLocation.h>
+
+#import "RCTMGLLocation.h"
+#import "RCTMGLLocationModule.h"
+#import "RCTMGLLocationManager.h"
+#import "RCTMGLLocationManagerDelegate.h"
+#import "RCTMGLEventTypes.h"
+
+@interface RCTMGLLocationModule() <RCTMGLLocationManagerDelegate>
+@end
+
+@implementation RCTMGLLocationModule
+{
+    RCTMGLLocationManager *locationManager;
+    BOOL hasListeners;
+}
+
+RCT_EXPORT_MODULE();
+
++ (BOOL)requiresMainQueueSetup
+{
+    return NO;
+}
+
+- (instancetype)init
+{
+    if (self = [super init]) {
+        locationManager = [[RCTMGLLocationManager alloc] init];
+        locationManager.delegate = self;
+    }
+    return self;
+}
+
+- (void)startObserving
+{
+    [super startObserving];
+    hasListeners = YES;
+}
+
+- (void)stopObserving
+{
+    [super stopObserving];
+    hasListeners = NO;
+}
+
+- (NSArray<NSString *> *)supportedEvents
+{
+    return @[RCT_MAPBOX_USER_LOCATION_UPDATE];
+}
+
+RCT_EXPORT_METHOD(start:(CLLocationDistance)minDisplacement)
+{
+  [locationManager start:minDisplacement];
+}
+
+RCT_EXPORT_METHOD(pause)
+{
+    [locationManager stop];
+}
+
+RCT_EXPORT_METHOD(stop)
+{
+    [locationManager stop];
+}
+
+RCT_EXPORT_METHOD(setMinDisplacement:(CLLocationDistance)minDisplacement)
+{
+    [locationManager setMinDisplacement:minDisplacement];
+}
+
+RCT_EXPORT_METHOD(getLastKnownLocation:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+{
+    RCTMGLLocation *lastKnownLocation = [locationManager getLastKnownLocation];
+    resolve(lastKnownLocation);
+}
+
+- (void)locationManager:(RCTMGLLocationManager *)locationManager didUpdateLocation:(RCTMGLLocation *)location
+{
+    if (!hasListeners) {
+        return;
+    }
+
+    if (self.bridge == nil) {
+        return;
+    }
+
+    [self sendEventWithName:RCT_MAPBOX_USER_LOCATION_UPDATE body:[location toJSON]];
+}
+
+@end
+

package/ios/RCTMGL/RCTMGLLogging.h

@@ -0,0 +1,18 @@
+#ifndef RCTMGLLogging_h
+#define RCTMGLLogging_h
+
+#import <Foundation/Foundation.h>
+#import <React/RCTEventEmitter.h>
+
+
+@class MGLLoggingConfiguration;
+
+@interface RCTMGLLogging : RCTEventEmitter <RCTBridgeModule>
+
+@property (nonatomic, nonnull) MGLLoggingConfiguration*  loggingConfiguration;
+
+- (void)setLoggingLevel:(nonnull NSString*) logLevel;
+
+@end
+
+#endif /* RCTMGLLogging_h */

package/ios/RCTMGL/RCTMGLLogging.m

@@ -0,0 +1,132 @@
+#import "RCTMGLLogging.h"
+
+@import Mapbox;
+
+@interface RCTMGLLogging()
+@property (nonatomic) BOOL hasListeners;
+@end
+
+@implementation RCTMGLLogging
+
++ (id)allocWithZone:(NSZone *)zone {
+    static RCTMGLLogging *sharedInstance = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        sharedInstance = [super allocWithZone:zone];
+    });
+    return sharedInstance;
+}
+
+-(id)init {
+    if ( self = [super init] ) {
+        self.loggingConfiguration = [MGLLoggingConfiguration sharedConfiguration];
+        [self.loggingConfiguration  setLoggingLevel:MGLLoggingLevelWarning];
+        __weak typeof(self) weakSelf = self;
+        self.loggingConfiguration.handler = ^(MGLLoggingLevel loggingLevel, NSString *filePath, NSUInteger line, NSString *message) {
+            [weakSelf sendLogWithLevel:loggingLevel filePath: filePath line: line message: message];
+        };
+    }
+    return self;
+}
+
+RCT_EXPORT_MODULE();
+
++ (BOOL)requiresMainQueueSetup
+{
+    return YES;
+}
+
+- (NSArray<NSString *> *)supportedEvents
+{
+  return @[@"LogEvent"];
+}
+
+- (void)startObserving
+{
+    [super startObserving];
+    self.hasListeners = true;
+}
+
+- (void)stopObserving
+{
+    [super stopObserving];
+    self.hasListeners = false;
+}
+
+- (void)sendLogWithLevel:(MGLLoggingLevel)loggingLevel filePath:(NSString*)filePath line:(NSUInteger)line message:(NSString*)message
+{
+    if (!self.hasListeners) return;
+
+    NSString* level = @"n/a";
+    switch (loggingLevel) {
+    case MGLLoggingLevelInfo:
+        level = @"info";
+        break;
+    case MGLLoggingLevelError:
+        level = @"error";
+        break;
+#if MGL_LOGGING_ENABLE_DEBUG
+    case MGLLoggingLevelDebug:
+        level = @"debug";
+        break;
+#endif
+    case MGLLoggingLevelWarning:
+        level = @"warning";
+        break;
+    case MGLLoggingLevelNone:
+        level = @"none";
+        break;
+    case MGLLoggingLevelFault:
+        level = @"fault";
+        break;
+    case MGLLoggingLevelVerbose:
+        level = @"verbose";
+        break;
+    }
+
+    NSString* type = nil;
+    if ([message hasPrefix:@"Failed to load glyph range"]) {
+        type = @"missing_font";
+    }
+
+    NSMutableDictionary* body = [@{
+        @"level": level,
+        @"message": message,
+        @"filePath": filePath,
+        @"line": @(line)
+    } mutableCopy];
+
+    if (type != nil) {
+        body[@"type"] = type;
+    }
+    [self sendEventWithName:@"LogEvent" body:body];
+}
+
+RCT_EXPORT_METHOD(setLogLevel: (nonnull NSString*)logLevel)
+{
+    MGLLoggingLevel mglLogLevel = MGLLoggingLevelNone;
+    if ([logLevel isEqualToString:@"none"]) {
+        mglLogLevel = MGLLoggingLevelNone;
+    } else if ([logLevel isEqualToString:@"debug"]) {
+        mglLogLevel = MGLLoggingLevelInfo;
+    } else if ([logLevel isEqualToString:@"fault"]) {
+        mglLogLevel = MGLLoggingLevelFault;
+    } else if ([logLevel isEqualToString:@"error"]) {
+        mglLogLevel = MGLLoggingLevelError;
+    } else if ([logLevel isEqualToString:@"warning"]) {
+        mglLogLevel = MGLLoggingLevelWarning;
+    } else if ([logLevel isEqualToString:@"info"]) {
+        mglLogLevel = MGLLoggingLevelInfo;
+    } else if ([logLevel isEqualToString:@"debug"]) {
+#if MGL_LOGGING_ENABLE_DEBUG
+        mglLogLevel = MGLLoggingLevelDebug;
+#else
+        mglLogLevel = MGLLoggingLevelVerbose;
+#endif
+    } else if ([logLevel isEqualToString:@"verbose"]) {
+        mglLogLevel = MGLLoggingLevelVerbose;
+    }
+    self.loggingConfiguration.loggingLevel = mglLogLevel;
+}
+
+@end

package/ios/RCTMGL/RCTMGLMapTouchEvent.h

@@ -0,0 +1,25 @@
+//
+//  RCTMGLTouchEvent.h
+//  RCTMGL
+//
+//  Created by Nick Italiano on 8/25/17.
+//  Copyright © 2017 Mapbox Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "RCTMGLEvent.h"
+#import "RCTMGLPointAnnotation.h"
+@import Mapbox;
+
+@interface RCTMGLMapTouchEvent : RCTMGLEvent
+
+@property (nonatomic, copy) NSString *id;
+@property (nonatomic, assign) CLLocationCoordinate2D coordinate;
+@property (nonatomic, assign) CGPoint screenPoint;
+
++ (RCTMGLMapTouchEvent*)makeTapEvent:(MGLMapView*)mapView withPoint:(CGPoint)point;
++ (RCTMGLMapTouchEvent*)makeLongPressEvent:(MGLMapView*)mapView withPoint:(CGPoint)point;
++ (RCTMGLMapTouchEvent *)makeAnnotationTapEvent:(RCTMGLPointAnnotation *)pointAnnotation;
++ (RCTMGLMapTouchEvent *)makeAnnotationTapEventOnDrag:(RCTMGLPointAnnotation *)pointAnnotation;
+
+@end

package/ios/RCTMGL/RCTMGLMapTouchEvent.m

@@ -0,0 +1,77 @@
+//
+//  RCTMGLTouchEvent.m
+//  RCTMGL
+//
+//  Created by Nick Italiano on 8/25/17.
+//  Copyright © 2017 Mapbox Inc. All rights reserved.
+//
+
+#import "RCTMGLMapTouchEvent.h"
+#import "RCTMGLEventTypes.h"
+#import "RCTMGLPointAnnotation.h"
+@import Mapbox;
+
+@implementation RCTMGLMapTouchEvent
+
+- (NSDictionary*)payload
+{
+    MGLPointFeature *feature = [[MGLPointFeature alloc] init];
+    feature.coordinate = _coordinate;
+    if (_id == nil) {
+        feature.attributes = @{
+           @"screenPointX": [NSNumber numberWithDouble:_screenPoint.x],
+           @"screenPointY":[NSNumber numberWithDouble:_screenPoint.y]
+        };
+    } else {
+        feature.attributes = @{
+           @"id": _id,
+           @"screenPointX": [NSNumber numberWithDouble:_screenPoint.x],
+           @"screenPointY":[NSNumber numberWithDouble:_screenPoint.y]
+        };
+    }
+    return [feature geoJSONDictionary];
+}
+
++ (RCTMGLMapTouchEvent*)makeTapEvent:(MGLMapView*)mapView withPoint:(CGPoint)point
+{
+    return [RCTMGLMapTouchEvent _fromPoint:point withMapView:mapView andEventType:RCT_MAPBOX_EVENT_TAP];
+}
+
++ (RCTMGLMapTouchEvent*)makeLongPressEvent:(MGLMapView*)mapView withPoint:(CGPoint)point
+{
+    return [RCTMGLMapTouchEvent _fromPoint:point withMapView:mapView andEventType:RCT_MAPBOX_EVENT_LONGPRESS];
+}
+
++ (RCTMGLMapTouchEvent *)makeAnnotationTapEvent:(RCTMGLPointAnnotation *)pointAnnotation
+{
+    RCTMGLMapTouchEvent *event = [[RCTMGLMapTouchEvent alloc] init];
+    event.type = RCT_MAPBOX_ANNOTATION_TAP;
+    event.id = pointAnnotation.id;
+    event.coordinate = pointAnnotation.coordinate;
+    event.screenPoint = [pointAnnotation.superview convertPoint:pointAnnotation.frame.origin toView:nil];
+    return event;
+}
+
++ (RCTMGLMapTouchEvent *)makeAnnotationTapEventOnDrag:(RCTMGLPointAnnotation *)pointAnnotation
+{
+    RCTMGLMapTouchEvent *event = [[RCTMGLMapTouchEvent alloc] init];
+    event.type = RCT_MAPBOX_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;
+}
+
++ (RCTMGLMapTouchEvent*)_fromPoint:(CGPoint)point withMapView:(MGLMapView *)mapView andEventType:(NSString*)eventType
+{
+    RCTMGLMapTouchEvent *event = [[RCTMGLMapTouchEvent alloc] init];
+    event.type = eventType;
+    event.coordinate = [mapView convertPoint:point toCoordinateFromView:mapView];
+    event.screenPoint = point;
+    return event;
+}
+
+@end

package/ios/RCTMGL/RCTMGLMapView.h

@@ -0,0 +1,91 @@
+//
+//  RCTMGLMapView.h
+//  RCTMGL
+//
+//  Created by Nick Italiano on 8/23/17.
+//  Copyright © 2017 Mapbox Inc. All rights reserved.
+//
+
+#import <React/RCTComponent.h>
+#import "RCTMGLSource.h"
+#import "RCTMGLShapeSource.h"
+#import "RCTMGLPointAnnotation.h"
+#import "RCTMGLLight.h"
+
+@import Mapbox;
+
+@class CameraUpdateQueue;
+@class RCTMGLImages;
+@class RCTMGLLogging;
+
+@protocol RCTMGLMapViewCamera<NSObject>
+- (void)initialLayout;
+- (void)didChangeUserTrackingMode:(MGLUserTrackingMode)mode animated:(BOOL)animated;
+@end
+
+typedef void (^FoundLayerBlock) (MGLStyleLayer* __nonnull layer);
+typedef void (^StyleLoadedBlock) (MGLStyle* __nonnull style);
+
+@interface RCTMGLMapView : MGLMapView<RCTInvalidating>
+
+@property (nonatomic, strong, nonnull) RCTMGLLogging* logging;
+@property (nonatomic, strong) CameraUpdateQueue *cameraUpdateQueue;
+@property (nonatomic, weak) id<RCTMGLMapViewCamera> reactCamera;
+@property (nonatomic, strong) NSMutableArray<id<RCTComponent>> *reactSubviews;
+@property (nonatomic, strong) NSMutableArray<RCTMGLSource*> *sources;
+@property (nonatomic, strong) NSMutableArray<RCTMGLImages*> *images;
+@property (nonatomic, strong) NSMutableArray<RCTMGLLayer*> *layers;
+@property (nonatomic, strong) NSMutableArray<RCTMGLPointAnnotation*> *pointAnnotations;
+@property (nonatomic, strong) RCTMGLLight *light;
+@property (nonatomic, copy) NSArray<NSNumber *> *reactContentInset;
+
+@property (nonatomic, strong) NSMutableDictionary<NSString*, NSMutableArray<FoundLayerBlock>*> *layerWaiters;
+@property (nonatomic, strong) NSMutableArray<StyleLoadedBlock> *styleWaiters;
+
+@property (nonatomic, assign) BOOL reactLocalizeLabels;
+@property (nonatomic, assign) BOOL reactScrollEnabled;
+@property (nonatomic, assign) BOOL reactPitchEnabled;
+@property (nonatomic, assign) BOOL reactRotateEnabled;
+@property (nonatomic, assign) BOOL reactAttributionEnabled;
+@property (nonatomic, strong) NSDictionary<NSString *, NSNumber *> *reactAttributionPosition;
+@property (nonatomic, assign) BOOL reactLogoEnabled;
+@property (nonatomic, assign) BOOL reactCompassEnabled;
+@property (nonatomic, assign) BOOL reactZoomEnabled;
+
+@property (nonatomic, assign) NSInteger *reactCompassViewPosition;
+@property (nonatomic, assign) CGPoint reactCompassViewMargins;
+
+@property (nonatomic, copy) NSString *reactStyleURL;
+@property (nonatomic, assign) NSInteger reactPreferredFramesPerSecond;
+
+@property (nonatomic, assign) MGLCoordinateBounds maxBounds;
+
+@property (nonatomic, assign) BOOL isUserInteraction;
+@property (nonatomic, assign) BOOL useNativeUserLocationAnnotationView;
+
+@property (nonatomic, copy) RCTBubblingEventBlock onPress;
+@property (nonatomic, copy) RCTBubblingEventBlock onLongPress;
+@property (nonatomic, copy) RCTBubblingEventBlock onMapChange;
+
+
+- (void)layerAdded:(MGLStyleLayer*) 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;
+- (RCTMGLPointAnnotation*)getRCTPointAnnotation:(MGLPointAnnotation*)mglAnnotation;
+- (NSArray<RCTMGLSource *> *)getAllTouchableSources;
+- (NSArray<RCTMGLSource *> *)getAllShapeSources;
+- (NSArray<RCTMGLImages *> *)getAllImages;
+- (RCTMGLSource *)getTouchableSourceWithHighestZIndex:(NSArray<RCTMGLSource *> *)touchableSources;
+- (NSString *)takeSnap:(BOOL)writeToDisk;
+- (void)didChangeUserTrackingMode:(MGLUserTrackingMode)mode animated:(BOOL)animated;
+
+- (void)waitForLayerWithID:(nonnull NSString*)layerID then:(void (^ _Nonnull)(MGLStyleLayer* _Nonnull layer))foundLayer;
+
+- (void)setSourceVisibility:(BOOL)visiblity sourceId:(nonnull NSString*)sourceId sourceLayerId:(nullable NSString*)sourceLayerId;
+
+- (void)notifyStyleLoaded;
+
+@end