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

package/ios/components/camera/MLRNCameraComponentView.mm

@@ -0,0 +1,192 @@
+#import "MLRNCameraComponentView.h"
+
+#import <react/renderer/components/MapLibreReactNativeSpec/ComponentDescriptors.h>
+#import <react/renderer/components/MapLibreReactNativeSpec/EventEmitters.h>
+#import <react/renderer/components/MapLibreReactNativeSpec/Props.h>
+#import <react/renderer/components/MapLibreReactNativeSpec/RCTComponentViewHelpers.h>
+
+#import "RCTFabricComponentsPlugins.h"
+
+#import <React/RCTConversions.h>
+#import "MLRNCamera.h"
+
+using namespace facebook::react;
+
+// MARK: - MLRNCameraComponentView
+
+@interface MLRNCameraComponentView () <RCTMLRNCameraViewProtocol>
+
+@end
+
+@implementation MLRNCameraComponentView {
+  MLRNCamera *_view;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const MLRNCameraProps>();
+    _props = defaultProps;
+    [self prepareView];
+  }
+
+  return self;
+}
+
+- (void)prepareView {
+  _view = [[MLRNCamera alloc] init];
+
+  // Capture weak self reference to prevent retain cycle
+  __weak __typeof__(self) weakSelf = self;
+
+  [_view setOnTrackUserLocationChange:^(NSDictionary *event) {
+    __typeof__(self) strongSelf = weakSelf;
+
+    if (strongSelf != nullptr && strongSelf->_eventEmitter != nullptr) {
+      facebook::react::MLRNCameraEventEmitter::OnTrackUserLocationChange eventStruct{
+          [event[@"trackUserLocation"] UTF8String],
+      };
+      std::dynamic_pointer_cast<const facebook::react::MLRNCameraEventEmitter>(
+          strongSelf->_eventEmitter)
+          ->onTrackUserLocationChange(eventStruct);
+    }
+  }];
+
+  self.contentView = _view;
+}
+
+#pragma mark - RCTComponentViewProtocol
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps {
+  const auto &oldViewProps = *std::static_pointer_cast<MLRNCameraProps const>(_props);
+  const auto &newViewProps = *std::static_pointer_cast<MLRNCameraProps const>(props);
+
+  if (oldViewProps.minZoom != newViewProps.minZoom) {
+    [_view setMinZoom:@(newViewProps.minZoom)];
+  }
+
+  if (oldViewProps.maxZoom != newViewProps.maxZoom) {
+    [_view setMaxZoom:@(newViewProps.maxZoom)];
+  }
+
+  if (oldViewProps.maxBounds != newViewProps.maxBounds) {
+    if (newViewProps.maxBounds.size() == 4) {
+      NSMutableArray<NSNumber *> *maxBoundsArray =
+          [NSMutableArray arrayWithCapacity:newViewProps.maxBounds.size()];
+      for (double value : newViewProps.maxBounds) {
+        [maxBoundsArray addObject:@(value)];
+      }
+
+      [_view setMaxBounds:maxBoundsArray];
+    } else {
+      [_view setMaxBounds:nil];
+    }
+  }
+
+  if (_view.initialViewState == nil) {
+    NSMutableDictionary *initialViewState = [NSMutableDictionary dictionary];
+
+    if (newViewProps.initialViewState.longitude != -360 &&
+        newViewProps.initialViewState.latitude != -360) {
+      initialViewState[@"longitude"] = @(newViewProps.initialViewState.longitude);
+      initialViewState[@"latitude"] = @(newViewProps.initialViewState.latitude);
+    } else if (newViewProps.initialViewState.bounds.size() == 4) {
+      initialViewState[@"bounds"] = @[
+        @(newViewProps.initialViewState.bounds[0]), @(newViewProps.initialViewState.bounds[1]),
+        @(newViewProps.initialViewState.bounds[2]), @(newViewProps.initialViewState.bounds[3])
+      ];
+    }
+
+    initialViewState[@"padding"] = @{
+      @"top" : @(newViewProps.initialViewState.padding.top),
+      @"right" : @(newViewProps.initialViewState.padding.right),
+      @"bottom" : @(newViewProps.initialViewState.padding.bottom),
+      @"left" : @(newViewProps.initialViewState.padding.left)
+    };
+
+    if (newViewProps.initialViewState.zoom != -1) {
+      initialViewState[@"zoom"] = @(newViewProps.initialViewState.zoom);
+    }
+    if (newViewProps.initialViewState.bearing != -1) {
+      initialViewState[@"bearing"] = @(newViewProps.initialViewState.bearing);
+    }
+    if (newViewProps.initialViewState.pitch != -1) {
+      initialViewState[@"pitch"] = @(newViewProps.initialViewState.pitch);
+    }
+
+    [_view setInitialViewState:initialViewState];
+  }
+
+  BOOL updateCamera = NO;
+
+  if (oldViewProps.stop.longitude != newViewProps.stop.longitude ||
+      oldViewProps.stop.latitude != newViewProps.stop.latitude ||
+
+      oldViewProps.stop.bounds != newViewProps.stop.bounds ||
+      oldViewProps.stop.padding.top != newViewProps.stop.padding.top ||
+      oldViewProps.stop.padding.right != newViewProps.stop.padding.right ||
+      oldViewProps.stop.padding.bottom != newViewProps.stop.padding.bottom ||
+      oldViewProps.stop.padding.left != newViewProps.stop.padding.left ||
+
+      oldViewProps.stop.zoom != newViewProps.stop.zoom ||
+      oldViewProps.stop.bearing != newViewProps.stop.bearing ||
+      oldViewProps.stop.pitch != newViewProps.stop.pitch ||
+
+      oldViewProps.stop.duration != newViewProps.stop.duration ||
+      oldViewProps.stop.easing != newViewProps.stop.easing) {
+    NSMutableDictionary *stop = [NSMutableDictionary dictionary];
+
+    if (newViewProps.stop.longitude != -360 && newViewProps.stop.latitude != -360) {
+      stop[@"longitude"] = @(newViewProps.stop.longitude);
+      stop[@"latitude"] = @(newViewProps.stop.latitude);
+    } else if (newViewProps.stop.bounds.size() == 4) {
+      stop[@"bounds"] = @[
+        @(newViewProps.stop.bounds[0]), @(newViewProps.stop.bounds[1]),
+        @(newViewProps.stop.bounds[2]), @(newViewProps.stop.bounds[3])
+      ];
+    }
+
+    stop[@"padding"] = @{
+      @"top" : @(newViewProps.stop.padding.top),
+      @"right" : @(newViewProps.stop.padding.right),
+      @"bottom" : @(newViewProps.stop.padding.bottom),
+      @"left" : @(newViewProps.stop.padding.left)
+    };
+
+    if (newViewProps.stop.zoom != -1) {
+      stop[@"zoom"] = @(newViewProps.stop.zoom);
+    }
+    if (newViewProps.stop.bearing != -1) {
+      stop[@"bearing"] = @(newViewProps.stop.bearing);
+    }
+    if (newViewProps.stop.pitch != -1) {
+      stop[@"pitch"] = @(newViewProps.stop.pitch);
+    }
+
+    if (newViewProps.stop.duration != -1) {
+      stop[@"duration"] = @(newViewProps.stop.duration);
+    }
+    stop[@"easing"] = @((NSInteger)newViewProps.stop.easing);
+
+    [_view setStop:stop];
+    updateCamera = YES;
+  }
+
+  if (oldViewProps.trackUserLocation != newViewProps.trackUserLocation) {
+    [_view setTrackUserLocation:[NSString stringWithUTF8String:facebook::react::toString(
+                                                                   newViewProps.trackUserLocation)
+                                                                   .c_str()]];
+    updateCamera = YES;
+  }
+
+  if (updateCamera) {
+    [_view updateCamera];
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<MLRNCameraComponentDescriptor>();
+}
+
+@end

package/ios/components/camera/MLRNCameraManager.h

@@ -0,0 +1,11 @@
+#import "MLRNCamera.h"
+#import "ViewManager.h"
+
+@interface MLRNCameraManager : ViewManager
+
++ (void)handleImperativeStop:(MLRNCamera *)view
+                        stop:(NSDictionary<NSString *, id> *)stop
+                     resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject;
+
+@end

package/ios/components/camera/MLRNCameraManager.m

@@ -0,0 +1,20 @@
+#import "MLRNCameraManager.h"
+#import "MLRNCamera.h"
+
+@implementation MLRNCameraManager
+
+- (UIView *)view {
+  return [[MLRNCamera alloc] init];
+}
+
+// MARK: - React View Methods
+
++ (void)handleImperativeStop:(MLRNCamera *)view
+                        stop:(NSDictionary<NSString *, id> *)stop
+                     resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject {
+  [view handleImperativeStop:stop];
+  resolve(nil);
+}
+
+@end

package/ios/components/camera/MLRNCameraModule.h

@@ -0,0 +1,4 @@
+#import <MapLibreReactNativeSpec/MapLibreReactNativeSpec.h>
+
+@interface MLRNCameraModule : NSObject <NativeCameraModuleSpec>
+@end

package/ios/components/camera/MLRNCameraModule.mm

@@ -0,0 +1,111 @@
+#import "MLRNCameraModule.h"
+
+#import "CameraEasing.h"
+#import "MLRNCamera.h"
+#import "MLRNCameraComponentView.h"
+#import "MLRNCameraManager.h"
+
+@implementation MLRNCameraModule
+
+@synthesize viewRegistry_DEPRECATED = _viewRegistry_DEPRECATED;
+
++ (NSString *)moduleName {
+  return @"MLRNCameraModule";
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeCameraModuleSpecJSI>(params);
+}
+
+- (void)withCamera:(NSInteger)reactTag
+             block:(void (^)(MLRNCamera *))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:[MLRNCameraComponentView class]]) {
+      MLRNCameraComponentView *componentView = (MLRNCameraComponentView *)view;
+
+      if ([componentView.contentView isKindOfClass:[MLRNCamera class]]) {
+        MLRNCamera *camera = (MLRNCamera *)componentView.contentView;
+
+        block(camera);
+        return;
+      }
+    }
+
+    reject(methodName,
+           [NSString stringWithFormat:@"Invalid `reactTag` %@, could not find MLRNCamera",
+                                      [NSNumber numberWithInteger:reactTag]],
+           nil);
+  }];
+}
+
+- (void)setStop:(NSInteger)reactTag
+           stop:(JS::NativeCameraModule::NativeCameraStop &)stop
+        resolve:(RCTPromiseResolveBlock)resolve
+         reject:(RCTPromiseRejectBlock)reject {
+  NSMutableDictionary<NSString *, id> *stopDict = [NSMutableDictionary dictionary];
+
+  if (stop.longitude().has_value() && stop.latitude().has_value()) {
+    stopDict[@"longitude"] = @(stop.longitude().value());
+    stopDict[@"latitude"] = @(stop.latitude().value());
+  } else if (stop.bounds().has_value() && stop.bounds().value().size() == 4) {
+    NSArray<NSNumber *> *bounds = @[
+      @(stop.bounds().value()[0]), @(stop.bounds().value()[1]), @(stop.bounds().value()[2]),
+      @(stop.bounds().value()[3])
+    ];
+    stopDict[@"bounds"] = bounds;
+  }
+
+  if (stop.padding().has_value()) {
+    auto padding = stop.padding().value();
+    stopDict[@"padding"] = @{
+      @"top" : padding.top().has_value() ? @(padding.top().value()) : @0,
+      @"right" : padding.right().has_value() ? @(padding.right().value()) : @0,
+      @"bottom" : padding.bottom().has_value() ? @(padding.bottom().value()) : @0,
+      @"left" : padding.left().has_value() ? @(padding.left().value()) : @0
+    };
+  }
+  if (stop.zoom().has_value()) {
+    stopDict[@"zoom"] = @(stop.zoom().value());
+  }
+  if (stop.bearing().has_value()) {
+    stopDict[@"bearing"] = @(stop.bearing().value());
+  }
+  if (stop.pitch().has_value()) {
+    stopDict[@"pitch"] = @(stop.pitch().value());
+  }
+
+  if (stop.duration().has_value()) {
+    stopDict[@"duration"] = @(stop.duration().value());
+  }
+  if (stop.easing()) {
+    NSString *easing = stop.easing();
+
+    if ([easing isEqualToString:@"none"]) {
+      stopDict[@"easing"] = @(MLRNCameraEasingLinear);
+    } else if ([easing isEqualToString:@"linear"]) {
+      stopDict[@"easing"] = @(MLRNCameraEasingLinear);
+    } else if ([easing isEqualToString:@"ease"]) {
+      stopDict[@"easing"] = @(MLRNCameraEasingEase);
+    } else if ([easing isEqualToString:@"fly"]) {
+      stopDict[@"easing"] = @(MLRNCameraEasingFly);
+    }
+  }
+
+  [self withCamera:reactTag
+             block:^(MLRNCamera *view) {
+               [MLRNCameraManager handleImperativeStop:view
+                                                  stop:[stopDict copy]
+                                               resolve:resolve
+                                                reject:reject];
+             }
+            reject:reject
+        methodName:@"setStop"];
+}
+
+@end

package/ios/{MLRNMapView.h → components/map-view/MLRNMapView.h}

@@ -1,11 +1,11 @@
 #import <React/RCTComponent.h>
+
+#import <MapLibre/MapLibre.h>
+
 #import "MLRNLight.h"
 #import "MLRNPointAnnotation.h"
-#import "MLRNShapeSource.h"
 #import "MLRNSource.h"
 
-@import MapLibre;
-
 @class CameraUpdateQueue;
 @class MLRNImages;
 @class MLRNLogging;
@@ -18,48 +18,70 @@
 typedef void (^FoundLayerBlock)(MLNStyleLayer *__nonnull layer);
 typedef void (^StyleLoadedBlock)(MLNStyle *__nonnull style);
 
-@interface MLRNMapView : MLNMapView <RCTInvalidating>
+@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<id<RCTComponent>> *reactSubviews;
+@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, nullable) MLRNLight *light;
-@property (nonatomic, copy, nullable) NSArray<NSNumber *> *reactContentInset;
 
 @property (nonatomic, strong, nonnull)
     NSMutableDictionary<NSString *, NSMutableArray<FoundLayerBlock> *> *layerWaiters;
 @property (nonatomic, strong, nonnull) NSMutableArray<StyleLoadedBlock> *styleWaiters;
 
-@property (nonatomic, assign) BOOL reactLocalizeLabels;
+@property (nonatomic, copy, nullable) NSString *reactMapStyle;
+@property (nonatomic, copy, nullable) NSDictionary<NSString *, NSNumber *> *reactContentInset;
+@property (nonatomic, assign) NSInteger reactPreferredFramesPerSecond;
+
 @property (nonatomic, assign) BOOL reactScrollEnabled;
-@property (nonatomic, assign) BOOL reactPitchEnabled;
+@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, assign) BOOL reactCompassEnabled;
-@property (nonatomic, assign) BOOL reactZoomEnabled;
 
-@property (nonatomic, assign) NSInteger reactCompassViewPosition;
-@property (nonatomic, assign) CGPoint reactCompassViewMargins;
+@property (nonatomic, assign) BOOL reactLogoEnabled;
+@property (nonatomic, strong, nullable) NSDictionary<NSString *, NSNumber *> *reactLogoPosition;
 
-@property (nonatomic, copy, nullable) NSString *reactMapStyle;
-@property (nonatomic, assign) NSInteger reactPreferredFramesPerSecond;
+@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 onPress;
-@property (nonatomic, copy, nullable) RCTBubblingEventBlock onLongPress;
-@property (nonatomic, copy, nullable) RCTBubblingEventBlock onMapChange;
+@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;
 
@@ -78,10 +100,10 @@ typedef void (^StyleLoadedBlock)(MLNStyle *__nonnull style);
 - (nonnull NSString *)takeSnap:(BOOL)writeToDisk;
 - (void)didChangeUserTrackingMode:(MLNUserTrackingMode)mode animated:(BOOL)animated;
 
-- (void)waitForLayerWithID:(nonnull NSString *)layerID
+- (void)waitForLayerWithId:(nonnull NSString *)layerId
                       then:(void (^_Nonnull)(MLNStyleLayer *_Nonnull layer))foundLayer;
 
-- (void)setSourceVisibility:(BOOL)visiblity
+- (void)setSourceVisibility:(BOOL)visibility
                    sourceId:(nonnull NSString *)sourceId
               sourceLayerId:(nullable NSString *)sourceLayerId;