@mapvina-com/mapvina-react-native 1.0.0

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

@@ -0,0 +1,248 @@
+#import "MLRNMapViewModule.h"
+
+#import "FilterParser.h"
+#import "MLRNMapView.h"
+#import "MLRNMapViewComponentView.h"
+#import "MLRNMapViewManager.h"
+#import "MLRNUtils.h"
+#import "MLRNViewModuleUtils.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 {
+  [MLRNViewModuleUtils withView:self.viewRegistry_DEPRECATED
+                       reactTag:reactTag
+             componentViewClass:[MLRNMapViewComponentView class]
+               contentViewClass:[MLRNMapView class]
+                          block:^(UIView *view) {
+                            block((MLRNMapView *)view);
+                          }
+                         reject:reject
+                     methodName:methodName];
+}
+
+- (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
+         lngLat:(NSArray<NSNumber *> *)lngLat
+        resolve:(RCTPromiseResolveBlock)resolve
+         reject:(RCTPromiseRejectBlock)reject {
+  CLLocationCoordinate2D coordinate =
+      CLLocationCoordinate2DMake([lngLat[1] doubleValue], [lngLat[0] doubleValue]);
+
+  [self withMapView:reactTag
+              block:^(MLRNMapView *view) {
+                [MLRNMapViewManager project:view
+                                 coordinate:coordinate
+                                    resolve:resolve
+                                     reject:reject];
+              }
+             reject:reject
+         methodName:@"project"];
+}
+
+- (void)unproject:(NSInteger)reactTag
+       pixelPoint:(NSArray<NSNumber *> *)pixelPoint
+          resolve:(RCTPromiseResolveBlock)resolve
+           reject:(RCTPromiseRejectBlock)reject {
+  CGPoint point = CGPointMake([pixelPoint[0] doubleValue], [pixelPoint[1] doubleValue]);
+
+  [self withMapView:reactTag
+              block:^(MLRNMapView *view) {
+                [MLRNMapViewManager unproject:view point:point resolve:resolve reject:reject];
+              }
+             reject:reject
+         methodName:@"unproject"];
+}
+
+- (void)createStaticMapImage:(NSInteger)reactTag
+                      output:(NSString *)output
+                     resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject {
+  [self withMapView:reactTag
+              block:^(MLRNMapView *view) {
+                [MLRNMapViewManager createStaticMapImage:view
+                                             writeToDisk:[output isEqual:@"file"]
+                                                 resolve:resolve
+                                                  reject:reject];
+              }
+             reject:reject
+         methodName:@"takeSnap"];
+}
+
+- (void)queryRenderedFeaturesWithPoint:(NSInteger)reactTag
+                            pixelPoint:(NSArray<NSNumber *> *)pixelPoint
+                                layers:(nonnull NSArray<NSString *> *)layers
+                                filter:(nonnull NSArray *)filter
+                               resolve:(nonnull RCTPromiseResolveBlock)resolve
+                                reject:(nonnull RCTPromiseRejectBlock)reject {
+  CGPoint point = CGPointMake([pixelPoint[0] doubleValue], [pixelPoint[1] doubleValue]);
+
+  [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 queryRenderedFeaturesWithPoint:view
+                                                             point:point
+                                                          layerIds:layerIdSet
+                                                         predicate:predicate
+                                                           resolve:resolve
+                                                            reject:reject];
+              }
+             reject:reject
+         methodName:@"queryRenderedFeaturesWithCoordinate"];
+}
+
+- (void)queryRenderedFeaturesWithBounds:(NSInteger)reactTag
+                       pixelPointBounds:(NSArray<NSArray<NSNumber *> *> *)pixelPointBounds
+                                 layers:(NSArray<NSString *> *)layers
+                                 filter:(NSArray *)filter
+                                resolve:(RCTPromiseResolveBlock)resolve
+                                 reject:(RCTPromiseRejectBlock)reject {
+  [self withMapView:reactTag
+              block:^(MLRNMapView *view) {
+                CGRect rect;
+
+                if (pixelPointBounds == nil) {
+                  rect = view.bounds;
+                } else {
+                  CGFloat left = [pixelPointBounds[0][0] doubleValue];
+                  CGFloat top = [pixelPointBounds[0][1] doubleValue];
+                  CGFloat right = [pixelPointBounds[1][0] doubleValue];
+                  CGFloat bottom = [pixelPointBounds[1][1] doubleValue];
+
+                  rect = CGRectMake(left, top, right - left, bottom - top);
+                }
+
+                NSSet *layerIdSet = nil;
+                if (layers != nil && layers.count > 0) {
+                  layerIdSet = [NSSet setWithArray:layers];
+                }
+
+                NSPredicate *predicate = [FilterParser parse:filter];
+
+                [MLRNMapViewManager queryRenderedFeaturesWithRect:view
+                                                             rect:rect
+                                                         layerIds:layerIdSet
+                                                        predicate:predicate
+                                                          resolve:resolve
+                                                           reject:reject];
+              }
+             reject:reject
+         methodName:@"queryRenderedFeaturesWithBounds"];
+}
+
+- (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
+                     source:(nonnull NSString *)source
+                sourceLayer:(nullable NSString *)sourceLayer
+                    resolve:(RCTPromiseResolveBlock)resolve
+                     reject:(RCTPromiseRejectBlock)reject {
+  [self withMapView:reactTag
+              block:^(MLRNMapView *view) {
+                [MLRNMapViewManager setSourceVisibility:view
+                                                visible:visible
+                                               sourceId:source
+                                          sourceLayerId:sourceLayer
+                                                resolve:resolve
+                                                 reject:reject];
+              }
+             reject:reject
+         methodName:@"setSourceVisibility"];
+}
+
+@end

package/ios/components/sources/MLRNSource.h

@@ -0,0 +1,28 @@
+#import <React/RCTComponent.h>
+#import <UIKit/UIKit.h>
+
+#import "MLRNLayer.h"
+
+#import <MapVina/MapVina.h>
+
+@interface MLRNSource : UIView
+
+@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;
+
+- (void)insertReactSubview:(id<RCTComponent> _Nullable)subview atIndex:(NSInteger)atIndex;
+- (void)removeReactSubview:(id<RCTComponent> _Nullable)subview;
+
+@end

package/ios/components/sources/MLRNSource.m

@@ -0,0 +1,129 @@
+#import "MLRNSource.h"
+#import <React/RCTLog.h>
+#import <React/UIView+React.h>
+#import "MLRNMapView.h"
+
+@implementation MLRNSource
+
+double const DEFAULT_HITBOX_AREA = 44.0;
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    _layers = [[NSMutableArray alloc] init];
+    _reactSubviews = [[NSMutableArray alloc] init];
+    _hitbox = @{@"width" : @(DEFAULT_HITBOX_AREA), @"height" : @(DEFAULT_HITBOX_AREA)};
+  }
+  return self;
+}
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wobjc-missing-super-calls"
+- (void)insertReactSubview:(id<RCTComponent>)subview atIndex:(NSInteger)atIndex {
+  if ([subview isKindOfClass:[MLRNLayer class]]) {
+    MLRNLayer *layer = (MLRNLayer *)subview;
+
+    if (layer.sourceID == nil) {
+      layer.sourceID = _id;
+    }
+
+    if (_map.style != nil) {
+      [layer addToMap:_map style:_map.style];
+    }
+
+    [_layers addObject:layer];
+    [_reactSubviews insertObject:layer atIndex:atIndex];
+  }
+}
+#pragma clang diagnostic pop
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wobjc-missing-super-calls"
+- (void)removeReactSubview:(id<RCTComponent>)subview {
+  if ([subview isKindOfClass:[MLRNLayer class]]) {
+    MLRNLayer *layer = (MLRNLayer *)subview;
+    [layer removeFromMap:_map.style];
+    [_layers removeObject:layer];
+    [_reactSubviews removeObject:layer];
+  }
+}
+#pragma clang diagnostic pop
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wobjc-missing-super-calls"
+- (NSArray<id<RCTComponent>> *)reactSubviews {
+  return _reactSubviews;
+}
+#pragma clang diagnostic pop
+
+- (void)setMap:(MLRNMapView *)map {
+  if (map == nil) {
+    [self removeFromMap];
+    _map = nil;
+  } else {
+    _map = map;
+    [self addToMap];
+  }
+}
+
+- (void)addToMap {
+  if (_map.style == nil) {
+    return;
+  }
+
+  MLNSource *existingSource = [_map.style sourceWithIdentifier:_id];
+  if (existingSource != nil) {
+    _source = existingSource;
+  } else {
+    _source = [self makeSource];
+    if (_source != nil) {
+      [_map.style addSource:_source];
+    } else {
+      RCTLogError(@"Could not create source with id:%@. Make sure url/shape is provided", _id);
+    }
+  }
+
+  if (_layers.count > 0) {
+    for (int i = 0; i < _layers.count; i++) {
+      MLRNLayer *layer = [_layers objectAtIndex:i];
+      if (layer.sourceID == nil) {
+        layer.sourceID = _id;
+      }
+      [layer addToMap:_map style:_map.style];
+    }
+  }
+}
+
+- (void)removeFromMap {
+  if (_map.style == nil) {
+    return;
+  }
+
+  for (int i = 0; i < _layers.count; i++) {
+    MLRNLayer *layer = [_layers objectAtIndex:i];
+    [layer removeFromMap:_map.style];
+  }
+
+  if (_source != nil) {
+    [_map.style removeSource:_source];
+  }
+}
+
+- (nullable MLNSource *)makeSource {
+  @throw [NSException
+      exceptionWithName:NSInternalInconsistencyException
+                 reason:[NSString stringWithFormat:@"You must override %@ in a subclass",
+                                                   NSStringFromSelector(_cmd)]
+               userInfo:nil];
+}
+
+- (NSArray<NSString *> *)getLayerIDs {
+  NSMutableArray *layerIDs = [[NSMutableArray alloc] init];
+
+  for (MLRNLayer *layer in _layers) {
+    [layerIDs addObject:layer.id];
+  }
+
+  return layerIDs;
+}
+
+@end

package/ios/components/sources/geojson-source/MLRNGeoJSONSource.h

@@ -0,0 +1,32 @@
+#import "MLRNSource.h"
+
+#import <MapVina/MapVina.h>
+
+@interface MLRNGeoJSONSource : MLRNSource
+
+@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;
+
+- (void)setReactData:(nonnull NSString *)data;
+
+- (nonnull NSArray<id<MLNFeature>> *)featuresMatchingPredicate:(nullable NSPredicate *)predicate;
+- (nonnull NSArray<id<MLNFeature>> *)getClusterLeaves:(nonnull MLNPointFeatureCluster *)cluster
+                                               number:(NSUInteger)number
+                                               offset:(NSUInteger)offset;
+- (nonnull NSArray<id<MLNFeature>> *)getClusterChildren:(nonnull MLNPointFeatureCluster *)cluster;
+
+- (double)getClusterExpansionZoom:(nonnull MLNPointFeatureCluster *)cluster;
+
+@end

package/ios/components/sources/geojson-source/MLRNGeoJSONSource.m

@@ -0,0 +1,146 @@
+#import "MLRNGeoJSONSource.h"
+#import "MLRNMapView.h"
+#import "MLRNUtils.h"
+
+@implementation MLRNGeoJSONSource
+
+static UIImage *_placeHolderImage;
+
+- (void)setReactData:(NSString *)data {
+  NSURL *url = [NSURL URLWithString:data];
+
+  if (url) {
+    self.url = data;
+  } else {
+    self.shape = data;
+  }
+}
+
+- (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 MLNPointFeatureCluster *)cluster {
+  MLNShapeSource *shapeSource = (MLNShapeSource *)self.source;
+
+  return [shapeSource zoomLevelForExpandingCluster:cluster];
+}
+
+- (nonnull NSArray<id<MLNFeature>> *)getClusterLeaves:(nonnull MLNPointFeatureCluster *)cluster
+                                               number:(NSUInteger)number
+                                               offset:(NSUInteger)offset {
+  MLNShapeSource *shapeSource = (MLNShapeSource *)self.source;
+
+  return [shapeSource leavesOfCluster:cluster offset:offset limit:number];
+}
+
+- (nonnull NSArray<id<MLNFeature>> *)getClusterChildren:(nonnull MLNPointFeatureCluster *)cluster {
+  MLNShapeSource *shapeSource = (MLNShapeSource *)self.source;
+
+  return [shapeSource childrenOfCluster:cluster];
+}
+
+@end

package/ios/components/sources/geojson-source/MLRNGeoJSONSourceComponentView.h

@@ -0,0 +1,9 @@
+#import <React/RCTViewComponentView.h>
+
+@class MLRNGeoJSONSource;
+
+@interface MLRNGeoJSONSourceComponentView : RCTViewComponentView
+
+@property (nonatomic, readonly) MLRNGeoJSONSource *geoJSONSource;
+
+@end