@maplibre/maplibre-react-native 10.0.0-alpha.9 → 10.0.0-beta.10

package/ios/MLRN/MLRNStyleValue.h

@@ -0,0 +1,19 @@
+#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;
+- (MLNTransition)getTransition;
+- (NSExpression *)getSphericalPosition;
+- (BOOL)isVisible;
+
++ (MLRNStyleValue*)make:(NSString*)expressionJSONStr;
+
+@end

package/ios/MLRN/MLRNStyleValue.m

@@ -0,0 +1,159 @@
+#import "MLRNStyleValue.h"
+#import "MLRNUtils.h"
+#import <React/RCTImageLoader.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;
+    }
+}
+
+- (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/MLRN/MLRNSymbolLayer.h

@@ -0,0 +1,5 @@
+#import "MLRNVectorLayer.h"
+
+@interface MLRNSymbolLayer : MLRNVectorLayer
+
+@end

package/ios/MLRN/MLRNSymbolLayer.m

@@ -0,0 +1,25 @@
+#import "MLRNSymbolLayer.h"
+#import "MLRNStyle.h"
+
+#import <React/RCTLog.h>
+
+@implementation MLRNSymbolLayer
+
+- (MLNSymbolStyleLayer*)makeLayer:(MLNStyle*)style
+{
+    MLNSource *source = [self layerWithSourceIDInStyle: style];
+    if (source == nil) { return nil; }
+    MLNSymbolStyleLayer *layer = [[MLNSymbolStyleLayer alloc] initWithIdentifier:self.id source:source];
+    layer.sourceLayerIdentifier = self.sourceLayerID;
+    return layer;
+}
+
+- (void)addStyles
+{
+    MLRNStyle *style = [[MLRNStyle alloc] initWithMLNStyle:self.style];
+    style.bridge = self.bridge;
+    [style symbolLayer:(MLNSymbolStyleLayer*)self.styleLayer withReactStyle:self.reactStyle isValid:^{ return [self isAddedToMap];
+    }];
+}
+
+@end

package/ios/MLRN/MLRNSymbolLayerManager.h

@@ -0,0 +1,5 @@
+#import "ViewManager.h"
+
+@interface MLRNSymbolLayerManager : ViewManager
+
+@end

package/ios/MLRN/MLRNSymbolLayerManager.m

@@ -0,0 +1,31 @@
+#import "MLRNSymbolLayerManager.h"
+#import "MLRNSymbolLayer.h"
+
+@implementation MLRNSymbolLayerManager
+
+RCT_EXPORT_MODULE()
+
+// circle layer props
+RCT_EXPORT_VIEW_PROPERTY(sourceLayerID, NSString);
+
+// standard layer props
+RCT_EXPORT_VIEW_PROPERTY(id, NSString);
+RCT_EXPORT_VIEW_PROPERTY(sourceID, NSString);
+RCT_EXPORT_VIEW_PROPERTY(filter, NSArray);
+
+RCT_EXPORT_VIEW_PROPERTY(aboveLayerID, NSString);
+RCT_EXPORT_VIEW_PROPERTY(belowLayerID, NSString);
+RCT_EXPORT_VIEW_PROPERTY(layerIndex, NSNumber);
+RCT_EXPORT_VIEW_PROPERTY(reactStyle, NSDictionary);
+
+RCT_EXPORT_VIEW_PROPERTY(maxZoomLevel, NSNumber);
+RCT_EXPORT_VIEW_PROPERTY(minZoomLevel, NSNumber);
+
+- (UIView*)view
+{
+    MLRNSymbolLayer *layer = [MLRNSymbolLayer new];
+    layer.bridge = self.bridge;
+    return layer;
+}
+
+@end

package/ios/MLRN/MLRNTileSource.h

@@ -0,0 +1,22 @@
+//
+//  MLRNTileSource.h
+//  MLRN
+//
+
+#import "MLRNSource.h"
+@import MapLibre;
+
+@interface MLRNTileSource : MLRNSource
+
+@property (nonatomic, copy) NSString *url;
+@property (nonatomic, strong) NSArray<NSString *> *tileUrlTemplates;
+@property (nonatomic, copy) NSString *attribution;
+
+@property (nonatomic, strong) NSNumber *minZoomLevel;
+@property (nonatomic, strong) NSNumber *maxZoomLevel;
+
+@property (nonatomic, assign) BOOL tms;
+
+- (NSDictionary<MLNTileSourceOption, id>*)getOptions;
+
+@end

package/ios/MLRN/MLRNTileSource.m

@@ -0,0 +1,31 @@
+//
+//  BaseSource.m
+//  MLRN
+//
+
+#import "MLRNTileSource.h"
+
+@implementation MLRNTileSource
+
+- (NSDictionary<MLNTileSourceOption, id>*)getOptions {
+    NSMutableDictionary<MLNTileSourceOption, id> *options = [[NSMutableDictionary alloc] init];
+    
+    if (self.maxZoomLevel != nil) {
+        options[MLNTileSourceOptionMaximumZoomLevel] = self.maxZoomLevel;
+    }
+    
+    if (self.minZoomLevel != nil) {
+        options[MLNTileSourceOptionMinimumZoomLevel] = self.minZoomLevel;
+    }
+    
+    if (self.tms) {
+        options[MLNTileSourceOptionTileCoordinateSystem] = [NSNumber numberWithUnsignedInteger:MLNTileCoordinateSystemTMS];
+    }
+    
+    if (self.attribution != nil) {
+        options[MLNTileSourceOptionAttributionHTMLString] = self.attribution;
+    }
+    
+    return options;
+}
+@end

package/ios/MLRN/MLRNUserLocation.h

@@ -0,0 +1,15 @@
+//
+//  MLRNUserLocation.h
+//  MLRN
+
+#import <Foundation/Foundation.h>
+#import <CoreLocation/CoreLocation.h>
+#import <MapLibre/MLNUserLocationAnnotationView.h>
+
+@interface MLRNUserLocation : NSObject
+
++ (id)sharedInstance;
+
+- (MLNUserLocationAnnotationView*)hiddenUserAnnotation;
+
+@end

package/ios/MLRN/MLRNUserLocation.m

@@ -0,0 +1,38 @@
+//
+//  MLRNUserLocation.m
+//  MLRN
+//
+
+#import "MLRNUserLocation.h"
+#import <MapLibre/MLNUserLocationAnnotationView.h>
+
+@interface HiddenUserLocationAnnotationView : MLNUserLocationAnnotationView
+
+@end
+
+@implementation HiddenUserLocationAnnotationView
+
+
+- (void)update {
+    self.frame = CGRectNull;
+}
+
+@end
+
+
+@implementation MLRNUserLocation : NSObject
+
++ (id)sharedInstance
+{
+    static MLRNUserLocation *userLocation = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{ userLocation = [[self alloc] init]; });
+    return userLocation;
+}
+
+- (MLNUserLocationAnnotationView*)hiddenUserAnnotation
+{
+    return [[HiddenUserLocationAnnotationView alloc] init];
+}
+
+@end

package/ios/MLRN/MLRNUtils.h

@@ -0,0 +1,23 @@
+#import <MapKit/MapKit.h>
+#import <React/RCTBridge.h>
+#import <React/RCTConvert.h>
+#import <React/RCTImageLoader.h>
+
+@import MapLibre;
+
+@interface MLRNUtils: NSObject
+
++ (CLLocationCoordinate2D)fromFeature:(NSString*)json;
++ (MLNShape*)shapeFromGeoJSON:(NSString*)json;
++ (MLNCoordinateBounds)fromFeatureCollection:(NSString*)json;
++ (NSArray<NSNumber *> *)fromCoordinateBounds:(MLNCoordinateBounds)bounds;
++ (NSTimeInterval)fromMS:(NSNumber*)number;
++ (NSNumber*)clamp:(NSNumber*)value min:(NSNumber*)min max:(NSNumber*)max;
++ (UIColor*)toColor:(id)value;
++ (void)fetchImage:(RCTBridge*)bridge url:(NSString*)url scale:(double)scale callback:(RCTImageLoaderCompletionBlock)callback;
++ (void)fetchImages:(RCTBridge *)bridge style:(MLNStyle *)style objects:(NSDictionary<NSString *, NSString *>*)objects forceUpdate:(BOOL)forceUpdate callback:(void (^)(void))callback;
++ (CGVector)toCGVector:(NSArray<NSNumber*>*)arr;
++ (UIEdgeInsets)toUIEdgeInsets:(NSArray<NSNumber *> *)arr;
++ (NSURL*)styleURLFromStyleJSON:(NSString *)styleJSON;
+
+@end

package/ios/MLRN/MLRNUtils.m

@@ -0,0 +1,210 @@
+#import "MLRNUtils.h"
+#import "MLRNImageQueue.h"
+
+@import MapLibre;
+
+@implementation MLRNUtils
+
+static double const MS_TO_S = 0.001;
+
++ (CLLocationCoordinate2D)fromFeature:(NSString*)jsonStr
+{
+    NSData* data = [jsonStr dataUsingEncoding:NSUTF8StringEncoding];
+    MLNPointFeature *feature = (MLNPointFeature*)[MLNShape shapeWithData:data encoding:NSUTF8StringEncoding error:nil];
+    return feature.coordinate;
+}
+
++ (UIEdgeInsets)toUIEdgeInsets:(NSArray<NSNumber *> *)arr
+{
+    return UIEdgeInsetsMake([arr[0] floatValue], [arr[1] floatValue], [arr[2] floatValue], [arr[3] floatValue]);
+}
+
++ (MLNShape*)shapeFromGeoJSON:(NSString*)jsonStr
+{
+    NSData* data = [jsonStr dataUsingEncoding:NSUTF8StringEncoding];
+    NSError* error = nil;
+    MLNShape* result = [MLNShape shapeWithData:data encoding:NSUTF8StringEncoding error:&error];
+    if (error != nil) {
+      RCTLogWarn(@"Failed to convert data to shape error:%@ src:%@", error, jsonStr);
+    }
+    return result;
+}
+
++ (NSString *)hashURI:(NSString *)uri
+{
+    if (uri == nil) {
+        return @"-1";
+    }
+    NSUInteger hash = [uri hash];
+    return [NSString stringWithFormat:@"%lu", (unsigned long)hash];
+}
+
++ (MLNCoordinateBounds)fromFeatureCollection:(NSString*)jsonStr
+{
+    NSData* data = [jsonStr dataUsingEncoding:NSUTF8StringEncoding];
+    MLNShapeCollectionFeature *featureCollection = (MLNShapeCollectionFeature*)[MLNShapeCollectionFeature shapeWithData:data encoding:NSUTF8StringEncoding error:nil];
+    
+    CLLocationCoordinate2D ne = featureCollection.shapes[0].coordinate;
+    CLLocationCoordinate2D sw = featureCollection.shapes[1].coordinate;
+    
+    return MLNCoordinateBoundsMake(sw, ne);
+}
+
++ (NSArray<NSNumber *> *)fromCoordinateBounds:(MLNCoordinateBounds)bounds
+{
+    return @[
+        @[@(bounds.ne.longitude), @(bounds.ne.latitude)],
+        @[@(bounds.sw.longitude), @(bounds.sw.latitude)]
+    ];
+}
+
++ (NSTimeInterval)fromMS:(NSNumber *)number
+{
+    return [number doubleValue] * MS_TO_S;
+}
+
++ (NSNumber*)clamp:(NSNumber *)value min:(NSNumber *)min max:(NSNumber *)max
+{
+    if ([value doubleValue] < [min doubleValue]) return min;
+    if ([value doubleValue] > [max doubleValue]) return max;
+    return value;
+}
+
++ (UIColor*)toColor:(id)value
+{
+    return [RCTConvert UIColor:value];
+}
+
++ (CGVector)toCGVector:(NSArray<NSNumber *> *)arr
+{
+    return CGVectorMake([arr[0] floatValue], [arr[1] floatValue]);
+}
+
++ (void)fetchImage:(RCTBridge*)bridge url:(NSString *)url scale:(double)scale callback:(RCTImageLoaderCompletionBlock)callback
+{
+    [MLRNImageQueue.sharedInstance addImage:url scale:scale bridge:bridge completionHandler:callback];
+}
+
++ (void)fetchImages:(RCTBridge *)bridge style:(MLNStyle *)style objects:(NSDictionary<NSString *, id>*)objects forceUpdate:(BOOL)forceUpdate callback:(void (^)(void))callback
+{
+    if (objects == nil) {
+        callback();
+        return;
+    }
+    
+    NSArray<NSString *> *imageNames = objects.allKeys;
+    if (imageNames.count == 0) {
+        callback();
+        return;
+    }
+    
+    __block NSUInteger imagesLeftToLoad = imageNames.count;
+    __weak MLNStyle *weakStyle = style;
+    
+    void (^imageLoadedBlock)(void) = ^{
+        imagesLeftToLoad--;
+        
+        if (imagesLeftToLoad == 0) {
+            callback();
+        }
+    };
+    
+    for (NSString *imageName in imageNames) {
+        UIImage *foundImage = forceUpdate ? nil : [style imageForName:imageName];
+        
+        if (forceUpdate || foundImage == nil) {
+            NSDictionary* image = objects[imageName];
+            BOOL hasScale = [image isKindOfClass:[NSDictionary class]] && ([image objectForKey:@"scale"] != nil);
+            double scale = hasScale ? [[image objectForKey:@"scale"] doubleValue] : 1.0;
+            [MLRNImageQueue.sharedInstance addImage:objects[imageName] scale:scale bridge:bridge completionHandler:^(NSError *error, UIImage *image) {
+              if (!image) {
+                RCTLogWarn(@"Failed to fetch image: %@ error:%@", imageName, error);
+              }
+              else {
+                dispatch_async(dispatch_get_main_queue(), ^{
+                    [weakStyle setImage:image forName:imageName];
+                    imageLoadedBlock();
+                });
+              }
+            }];
+        } else {
+            imageLoadedBlock();
+        }
+    }
+}
+
++ (NSString*)getStyleJsonTempDirectory
+{
+    static NSString *styleJsonTempDirectory;
+    if (!styleJsonTempDirectory) {
+        styleJsonTempDirectory = [NSTemporaryDirectory() stringByAppendingPathComponent:@"MLRNStyleJSON"];
+    }
+    return styleJsonTempDirectory;
+}
+
+/**
+ * Clears cached style-json entries from previous app runs. Can be safely called multiple times as it will
+ * only perform the action once per app run.
+ *
+ * @see styleURLFromStyleJSON:
+ */
++ (void)cleanCustomStyleJSONCacheIfNeeded
+{
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    NSString *styleJsonTempDirectory = [MLRNUtils getStyleJsonTempDirectory];
+    
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        if ([fileManager fileExistsAtPath:styleJsonTempDirectory]) {
+            [fileManager removeItemAtPath:styleJsonTempDirectory error:NULL];
+        }
+    });
+}
+
+/**
+ * Provides a way to convert raw style-json into a file so it can be directly referenced / used as styleURL.
+ * It's a crude / alternative approach to support Android's API: Style.Builder.fromJson().
+ */
++ (NSURL*)styleURLFromStyleJSON:(NSString *)styleJSON
+{
+    [MLRNUtils cleanCustomStyleJSONCacheIfNeeded];
+    
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    NSString *styleJsonTempDirectory = [MLRNUtils getStyleJsonTempDirectory];
+    
+    // attempt to create the temporary directory
+    if (![fileManager fileExistsAtPath:styleJsonTempDirectory]) {
+        NSError *error;
+        [fileManager createDirectoryAtPath:styleJsonTempDirectory
+               withIntermediateDirectories:YES
+                                attributes:nil
+                                     error:&error];
+        if (error) {
+            RCTLogError(@"Failed to create temporary directory '%@' for storing style-json. Error: %@", styleJsonTempDirectory, error);
+            return nil;
+        }
+    }
+    
+    // Determine filename based on the md5 hash of the style-json.
+    // This way, the written file can also act as a cached entry in case
+    // the same style-json is used again.
+    NSString *hashedFilename = [RCTMD5Hash(styleJSON) stringByAppendingPathExtension:@"json"];
+    
+    // Construct temporary file path (tempdir + md5 hash for filename)
+    NSString *styleJsonTempPath = [styleJsonTempDirectory stringByAppendingPathComponent:hashedFilename];
+    NSURL* styleJsonTempURL = [NSURL fileURLWithPath:styleJsonTempPath isDirectory:false];
+    
+    // Write style-json to temporary file in case it doesn't already exist
+    if (![fileManager fileExistsAtPath:styleJsonTempPath isDirectory:false]) {
+        NSError *error;
+        [styleJSON writeToURL:styleJsonTempURL atomically:YES encoding:NSUTF8StringEncoding error:&error];
+        if (error) {
+            RCTLogError(@"Failed to write style-json to temporary file '%@'. Error: %@", styleJsonTempURL, error);
+            return nil;
+        }
+    }
+    
+    return styleJsonTempURL;
+}
+
+@end

package/ios/MLRN/MLRNVectorLayer.h

@@ -0,0 +1,7 @@
+#import "MLRNLayer.h"
+
+@interface MLRNVectorLayer : MLRNLayer
+
+@property (nonatomic, copy) NSString *sourceLayerID;
+
+@end

package/ios/MLRN/MLRNVectorLayer.m

@@ -0,0 +1,51 @@
+#import "MLRNVectorLayer.h"
+#import "MLRNStyle.h"
+#import "FilterParser.h"
+#import <React/RCTLog.h>
+
+@implementation MLRNVectorLayer
+
+
+- (NSPredicate*)buildFilters
+{
+    return self.filter ? [FilterParser parse:self.filter] : nil;
+}
+
+- (void)updateFilter:(NSPredicate *)predicate
+{
+    @try {
+        ((MLNVectorStyleLayer *) self.styleLayer).predicate = predicate;
+    }
+    @catch (NSException* exception) {
+        RCTLogError(@"Invalid predicate: %@ on layer %@ - %@ reason: %@", predicate, self, exception.name, exception.reason);
+    }
+}
+
+- (void)setSourceLayerID:(NSString *)sourceLayerID
+{
+    _sourceLayerID = sourceLayerID;
+    
+    if (self.styleLayer != nil) {
+        ((MLNVectorStyleLayer*) self.styleLayer).sourceLayerIdentifier = _sourceLayerID;
+    }
+}
+
+- (void)addedToMap
+{
+    NSPredicate *filter = [self buildFilters];
+    if (filter != nil) {
+        [self updateFilter:filter];
+    }
+}
+
+- (void)setFilter:(NSArray*)filter
+{
+    [super setFilter: filter];
+
+    if (self.styleLayer != nil) {
+        NSPredicate *predicate = [self buildFilters];
+        [self updateFilter:predicate];
+    }
+}
+
+@end

package/ios/MLRN/MLRNVectorSource.h

@@ -0,0 +1,8 @@
+#import "MLRNTileSource.h"
+@import MapLibre;
+
+@interface MLRNVectorSource : MLRNTileSource
+
+- (nonnull NSArray<id <MLNFeature>> *)featuresInSourceLayersWithIdentifiers:(nonnull NSSet<NSString *> *)sourceLayerIdentifiers predicate:(nullable NSPredicate *)predicate;
+
+@end

package/ios/MLRN/MLRNVectorSource.m

@@ -0,0 +1,20 @@
+#import "MLRNVectorSource.h"
+
+@implementation MLRNVectorSource
+
+- (nullable MLNSource*)makeSource
+{
+    if (self.url != nil) {
+        return [[MLNVectorTileSource alloc] initWithIdentifier:self.id configurationURL:[NSURL URLWithString:self.url]];
+    }
+    return [[MLNVectorTileSource alloc] initWithIdentifier:self.id tileURLTemplates:self.tileUrlTemplates options:[self getOptions]];
+}
+
+- (nonnull NSArray<id <MLNFeature>> *)featuresInSourceLayersWithIdentifiers:(nonnull NSSet<NSString *> *)sourceLayerIdentifiers predicate:(nullable NSPredicate *)predicate
+{
+    MLNVectorTileSource* vectorSource = (MLNVectorTileSource*)self.source;
+    
+    return [vectorSource featuresInSourceLayersWithIdentifiers:sourceLayerIdentifiers predicate: predicate];
+}
+
+@end