@tileflow/react-native 0.1.0-alpha.1 → 0.1.0-alpha.3

package/ios/TileflowNativeSurface.mm

@@ -5,8 +5,10 @@
 #import <MapLibreReactNative/MLRNMapView.h>
 #import <MapLibreReactNative/MLRNCamera.h>
 #import <QuartzCore/QuartzCore.h>
+#import <algorithm>
 #import "TFAdmissionEngine.h"
 #import "TFNativeSurfaceState.h"
+#import "TFNativeTheme.h"
 #import <cmath>
 
 static void TFSurfaceInvalid(void) {
@@ -67,6 +69,32 @@ static MLRNCamera *TFSurfaceCamera(UIView *root, MLRNMapView *map) {
 	return found;
 }
 
+// The view MapLibre draws into: the subview backed by a Metal (or OpenGL) layer.
+static UIView *TFSurfaceRenderView(MLNMapView *map) {
+	for (UIView *view in map.subviews) {
+		NSString *name = NSStringFromClass(view.layer.class);
+		if ([name containsString:@"Metal"] || [name containsString:@"EAGL"]) return view;
+	}
+	return nil;
+}
+// A snapshot of one frame over the rendering view. It keeps four ground points of that frame and
+// follows them with the ground plane's projective transform while the camera moves.
+@interface TFSurfaceCover : NSObject
+@property (nonatomic, strong) UIView *view;
+@property (nonatomic, copy) NSArray<NSValue *> *corners;
+@property (nonatomic, copy) NSArray<NSValue *> *anchors;
+@property (nonatomic) BOOL fading;
+@end
+@implementation TFSurfaceCover
+@end
+@interface TFSurfaceReveal : NSObject
+@property (nonatomic) double duration;
+@property (nonatomic, strong) NSMutableArray<TFSurfaceCover *> *covers;
+@property (nonatomic, copy) RCTPromiseResolveBlock resolve;
+@end
+@implementation TFSurfaceReveal
+@end
+
 @interface TFSurfaceLayoutProbe : UIView
 @property (nonatomic, copy) dispatch_block_t changed;
 @end
@@ -90,8 +118,19 @@ static MLRNCamera *TFSurfaceCamera(UIView *root, MLRNMapView *map) {
 @property (nonatomic) BOOL retiring;
 @property (nonatomic) BOOL foreground;
 @property (nonatomic) BOOL observing;
+@property (nonatomic, strong) NSMutableArray<TFSurfaceCover *> *covers;
+@property (nonatomic, strong) NSMutableArray<TFSurfaceReveal *> *reveals;
+@property (nonatomic, strong) NSMutableArray<TFSurfaceReveal *> *settling;
+@property (nonatomic, copy, nullable) dispatch_block_t revealDeadline;
+@property (nonatomic, copy, nullable) NSString *themedToken;
+@property (nonatomic, strong) NSMutableDictionary<NSString *, MLNStyleLayer *> *themedLayers;
+@property (nonatomic, strong) NSMutableDictionary<NSString *, UIImage *> *themedImages;
 - (void)attach;
+- (NSUInteger)applyThemeValues:(NSDictionary *)values;
 - (void)retire;
+- (BOOL)cover;
+- (void)reveal:(double)duration resolve:(RCTPromiseResolveBlock)resolve;
+- (void)discardCovers;
 - (BOOL)owns;
 - (MLNStyle *)style;
 - (NSDictionary *)view;
@@ -114,6 +153,7 @@ static MLRNCamera *TFSurfaceCamera(UIView *root, MLRNMapView *map) {
 }
 - (void)attach {
 	self.token = @""; self.detached = [NSMutableArray array]; self.previous = self.map.delegate;
+	self.covers = [NSMutableArray array]; self.reveals = [NSMutableArray array]; self.settling = [NSMutableArray array];
 	if ([self.previous isKindOfClass:TFSurfaceAttachment.class]) TFSurfaceInvalid();
 	self.map.delegate = self;
 	[self.map addObserver:self forKeyPath:@"delegate" options:0 context:(__bridge void *)self]; self.observing = YES;
@@ -149,8 +189,182 @@ static MLRNCamera *TFSurfaceCamera(UIView *root, MLRNMapView *map) {
 	for (NSUInteger index = 0; index < 4; index++) visible = visible && [snapshot[index] doubleValue] > 0;
 	[self.state layout:visible];
 }
+- (BOOL)cover {
+	if (UIAccessibilityIsReduceMotionEnabled() || !self.foreground || !self.root.window || !self.style) return NO;
+	for (TFSurfaceCover *existing in self.covers) if (!existing.fading) return YES;
+	UIView *render = TFSurfaceRenderView(self.map);
+	CGRect frame = render.frame;
+	if (!render || frame.size.width < 1 || frame.size.height < 1 || self.covers.count >= 4) return NO;
+	UIView *snapshot = [render snapshotViewAfterScreenUpdates:NO];
+	if (!snapshot) return NO;
+	snapshot.userInteractionEnabled = NO; snapshot.accessibilityElementsHidden = YES;
+	snapshot.layer.anchorPoint = CGPointZero; snapshot.frame = frame;
+	// Ground points below the horizon at any supported pitch, in map view coordinates.
+	CGFloat width = frame.size.width, height = frame.size.height;
+	NSMutableArray<NSValue *> *corners = [NSMutableArray array], *anchors = [NSMutableArray array];
+	for (NSValue *value in @[[NSValue valueWithCGPoint:CGPointMake(width * 0.1, height * 0.45)], [NSValue valueWithCGPoint:CGPointMake(width * 0.9, height * 0.45)],
+		[NSValue valueWithCGPoint:CGPointMake(width * 0.9, height * 0.9)], [NSValue valueWithCGPoint:CGPointMake(width * 0.1, height * 0.9)]]) {
+		CGPoint point = value.CGPointValue;
+		CLLocationCoordinate2D coordinate = [self.map convertPoint:CGPointMake(point.x + frame.origin.x, point.y + frame.origin.y) toCoordinateFromView:self.map];
+		if (!std::isfinite(coordinate.latitude) || !std::isfinite(coordinate.longitude) || std::fabs(coordinate.latitude) > 90) return NO;
+		[corners addObject:value];
+		[anchors addObject:[NSValue valueWithBytes:&coordinate objCType:@encode(CLLocationCoordinate2D)]];
+	}
+	TFSurfaceCover *cover = [TFSurfaceCover new];
+	cover.view = snapshot; cover.corners = corners; cover.anchors = anchors;
+	// Newer covers go below older ones, which keep fading on top.
+	[self.map insertSubview:snapshot aboveSubview:render];
+	[self.covers addObject:cover];
+	return YES;
+}
+- (void)followCovers {
+	if (!self.covers.count) return;
+	UIView *render = TFSurfaceRenderView(self.map);
+	if (!render) return;
+	CGPoint origin = render.frame.origin;
+	for (TFSurfaceCover *cover in self.covers) {
+		CGPoint from[4], to[4];
+		for (int index = 0; index < 4; index++) {
+			from[index] = cover.corners[index].CGPointValue;
+			CLLocationCoordinate2D coordinate;
+			[cover.anchors[index] getValue:&coordinate size:sizeof(coordinate)];
+			CGPoint point = [self.map convertCoordinate:coordinate toPointToView:self.map];
+			if (!std::isfinite(point.x) || !std::isfinite(point.y)) return;
+			to[index] = CGPointMake(point.x - origin.x, point.y - origin.y);
+		}
+		double h[9];
+		if (!TFThemeHomography(from, to, h)) continue;
+		[CATransaction begin]; [CATransaction setDisableActions:YES];
+		cover.view.layer.position = origin; cover.view.layer.transform = TFThemeTransform(h);
+		[CATransaction commit];
+	}
+}
+- (void)reveal:(double)duration resolve:(RCTPromiseResolveBlock)resolve {
+	TFSurfaceReveal *reveal = [TFSurfaceReveal new];
+	reveal.duration = duration; reveal.resolve = resolve; reveal.covers = [self.covers mutableCopy];
+	if (!reveal.covers.count) { resolve(@{@"revealed": @YES}); return; }
+	[self.reveals addObject:reveal];
+	// Fades start on the next complete frame, or after ten seconds at most.
+	if (!self.revealDeadline) {
+		__weak TFSurfaceAttachment *weakSelf = self;
+		dispatch_block_t deadline = dispatch_block_create((dispatch_block_flags_t)0, ^{ weakSelf.revealDeadline = nil; [weakSelf startReveals]; });
+		self.revealDeadline = deadline;
+		dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 10 * NSEC_PER_SEC), dispatch_get_main_queue(), deadline);
+	}
+	[self.map triggerRepaint];
+}
+- (void)startReveals {
+	if (self.revealDeadline) { dispatch_block_cancel(self.revealDeadline); self.revealDeadline = nil; }
+	NSArray<TFSurfaceReveal *> *reveals = [self.reveals copy];
+	[self.reveals removeAllObjects];
+	for (TFSurfaceReveal *reveal in reveals) {
+		for (TFSurfaceCover *cover in reveal.covers) {
+			if (cover.fading) continue;
+			cover.fading = YES;
+			__weak TFSurfaceAttachment *weakSelf = self;
+			[UIView animateWithDuration:reveal.duration / 1000.0 delay:0 options:UIViewAnimationOptionCurveEaseInOut | UIViewAnimationOptionAllowUserInteraction
+				animations:^{ cover.view.alpha = 0; } completion:^(__unused BOOL finished) { [weakSelf removeCover:cover]; }];
+		}
+		[self settle:reveal];
+	}
+}
+- (void)removeCover:(TFSurfaceCover *)cover {
+	[cover.view.layer removeAllAnimations]; [cover.view removeFromSuperview];
+	[self.covers removeObject:cover];
+	for (TFSurfaceReveal *reveal in [self.settling copy]) [self settle:reveal];
+}
+// A reveal resolves once every cover that existed when it was requested is gone.
+- (void)settle:(TFSurfaceReveal *)reveal {
+	for (TFSurfaceCover *cover in reveal.covers) if ([self.covers containsObject:cover]) {
+		if (![self.settling containsObject:reveal]) [self.settling addObject:reveal];
+		return;
+	}
+	[self.settling removeObject:reveal];
+	if (reveal.resolve) { RCTPromiseResolveBlock resolve = reveal.resolve; reveal.resolve = nil; resolve(@{@"revealed": @YES}); }
+}
+- (void)discardCovers {
+	if (self.revealDeadline) { dispatch_block_cancel(self.revealDeadline); self.revealDeadline = nil; }
+	for (TFSurfaceCover *cover in [self.covers copy]) { [cover.view.layer removeAllAnimations]; [cover.view removeFromSuperview]; }
+	[self.covers removeAllObjects];
+	NSArray *reveals = [self.reveals arrayByAddingObjectsFromArray:self.settling];
+	[self.reveals removeAllObjects]; [self.settling removeAllObjects];
+	for (TFSurfaceReveal *reveal in reveals) if (reveal.resolve) { RCTPromiseResolveBlock resolve = reveal.resolve; reveal.resolve = nil; resolve(@{@"revealed": @YES}); }
+}
+- (NSUInteger)applyThemeValues:(NSDictionary *)values {
+	MLNStyle *style = self.style;
+	if (!style) TFSurfaceInvalid();
+	if (![self.themedToken isEqual:self.token]) {
+		// Layers and original artwork belong to one style.
+		self.themedToken = self.token; self.themedLayers = [NSMutableDictionary dictionary]; self.themedImages = [NSMutableDictionary dictionary];
+	}
+	NSUInteger applied = 0;
+	for (NSString *group in @[@"paint", @"layout"]) {
+		id entries = values[group];
+		if (!entries) continue;
+		if (![entries isKindOfClass:NSArray.class] || [entries count] > 8192) TFSurfaceInvalid();
+		for (id entry in entries) {
+			if (![entry isKindOfClass:NSArray.class] || [entry count] != 3 || ![entry[0] isKindOfClass:NSString.class] || ![entry[1] isKindOfClass:NSString.class]) TFSurfaceInvalid();
+			NSString *identifier = entry[0];
+			MLNStyleLayer *layer = self.themedLayers[identifier];
+			if (!layer) {
+				layer = [style layerWithIdentifier:identifier];
+				if (!layer) continue;
+				self.themedLayers[identifier] = layer;
+			}
+			if ([entry[1] isEqual:@"visibility"]) {
+				// Per-theme copies of a layer switch by visibility, a plain flag.
+				layer.visible = ![entry[2] isEqual:@"none"];
+				applied++;
+				continue;
+			}
+			NSString *key = TFThemeStyleKey(entry[1]);
+			if (![layer respondsToSelector:NSSelectorFromString(key)] || !TFThemeCameraValue(entry[2], 0)) continue;
+			// A value MapLibre rejects keeps its previous value; the rest of the batch still applies.
+			BOOL supported;
+			NSExpression *expression = TFThemeExpression(entry[2], key, &supported);
+			if (!supported) continue;
+			@try { [layer setValue:expression forKey:key]; applied++; }
+			@catch (__unused NSException *exception) {}
+		}
+	}
+	id images = values[@"images"];
+	if (images) {
+		if (![images isKindOfClass:NSArray.class] || [images count] > 64) TFSurfaceInvalid();
+		// Originals are read before any artwork is replaced, so tuples can share names.
+		for (NSArray *entry in images) {
+			if (![entry isKindOfClass:NSArray.class] || entry.count != 4) TFSurfaceInvalid();
+			for (NSUInteger index = 0; index < 3; index++) {
+				if (![entry[index] isKindOfClass:NSString.class]) TFSurfaceInvalid();
+				if (!self.themedImages[entry[index]]) { UIImage *image = [style imageForName:entry[index]]; if (image) self.themedImages[entry[index]] = image; }
+			}
+		}
+		for (NSArray *entry in images) {
+			UIImage *from = self.themedImages[entry[1]], *to = self.themedImages[entry[2]];
+			double t = TFSurfaceNumber(entry[3], 0, 1);
+			if (!from || !to) continue;
+			[style setImage:TFThemeMixImage(from, to, t) forName:entry[0]];
+			applied++;
+		}
+	}
+	id light = values[@"light"];
+	if (light) {
+		if (![light isKindOfClass:NSDictionary.class]) TFSurfaceInvalid();
+		MLNLight *next = style.light ?: [MLNLight new];
+		id colour = light[@"color"], intensity = light[@"intensity"], position = light[@"position"];
+		if ([colour isKindOfClass:NSString.class]) { UIColor *parsed = TFThemeColor(colour); if (parsed) next.color = [NSExpression expressionForConstantValue:parsed]; }
+		if ([intensity isKindOfClass:NSNumber.class]) next.intensity = [NSExpression expressionForConstantValue:intensity];
+		if ([position isKindOfClass:NSArray.class] && [position count] == 3 && TFThemeNumbers(position)) {
+			MLNSphericalPosition spherical = MLNSphericalPositionMake([position[0] doubleValue], [position[1] doubleValue], [position[2] doubleValue]);
+			next.position = [NSExpression expressionForConstantValue:[NSValue valueWithMLNSphericalPosition:spherical]];
+		}
+		style.light = next;
+		applied++;
+	}
+	return applied;
+}
 - (void)retire {
 	if (self.retiring) return;
+	[self discardCovers];
 	self.retiring = YES; [self.state close];
 	if (self.deadline) dispatch_block_cancel(self.deadline); self.deadline = nil;
 	if (self.layoutCancel) self.layoutCancel(); self.layoutCancel = nil;
@@ -165,23 +379,23 @@ static MLRNCamera *TFSurfaceCamera(UIView *root, MLRNMapView *map) {
 	if ([self.previous respondsToSelector:_cmd]) [self.previous mapView:mapView didFinishLoadingStyle:style];
 }
 - (void)mapViewWillStartRenderingFrame:(MLNMapView *)mapView {
-	if ([self owns]) { [self sampleLayout]; [self.state frameStart:self.style]; }
+	if ([self owns]) { [self sampleLayout]; [self.state frameStart:self.style]; [self followCovers]; }
 	if ([self.previous respondsToSelector:_cmd]) [self.previous mapViewWillStartRenderingFrame:mapView];
 }
 - (void)mapViewDidFinishRenderingMap:(MLNMapView *)mapView fullyRendered:(BOOL)fully {
 	if ([self.previous respondsToSelector:_cmd]) [self.previous mapViewDidFinishRenderingMap:mapView fullyRendered:fully];
 }
 - (void)mapViewDidFinishRenderingFrame:(MLNMapView *)mapView fullyRendered:(BOOL)fully {
-	if ([self owns]) [self.state frameEnd:self.style fully:fully];
+	if ([self owns]) { [self.state frameEnd:self.style fully:fully]; if (fully && self.reveals.count) [self startReveals]; }
 	if ([self.previous respondsToSelector:_cmd]) [self.previous mapViewDidFinishRenderingFrame:mapView fullyRendered:fully];
 }
 - (void)mapViewDidFinishRenderingFrame:(MLNMapView *)mapView fullyRendered:(BOOL)fully frameEncodingTime:(double)encoding frameRenderingTime:(double)rendering {
-	if ([self owns]) [self.state frameEnd:self.style fully:fully];
+	if ([self owns]) { [self.state frameEnd:self.style fully:fully]; if (fully && self.reveals.count) [self startReveals]; }
 	if ([self.previous respondsToSelector:_cmd]) [self.previous mapViewDidFinishRenderingFrame:mapView fullyRendered:fully frameEncodingTime:encoding frameRenderingTime:rendering];
 	else if ([self.previous respondsToSelector:@selector(mapViewDidFinishRenderingFrame:fullyRendered:)]) [self.previous mapViewDidFinishRenderingFrame:mapView fullyRendered:fully];
 }
 - (void)mapViewDidFinishRenderingFrame:(MLNMapView *)mapView fullyRendered:(BOOL)fully renderingStats:(MLNRenderingStats *)stats {
-	if ([self owns]) [self.state frameEnd:self.style fully:fully];
+	if ([self owns]) { [self.state frameEnd:self.style fully:fully]; if (fully && self.reveals.count) [self startReveals]; }
 	if ([self.previous respondsToSelector:_cmd]) [self.previous mapViewDidFinishRenderingFrame:mapView fullyRendered:fully renderingStats:stats];
 	else if ([self.previous respondsToSelector:@selector(mapViewDidFinishRenderingFrame:fullyRendered:)]) [self.previous mapViewDidFinishRenderingFrame:mapView fullyRendered:fully];
 }
@@ -194,7 +408,7 @@ static MLRNCamera *TFSurfaceCamera(UIView *root, MLRNMapView *map) {
 	else if ([self.previous respondsToSelector:@selector(mapView:regionWillChangeAnimated:)]) [self.previous mapView:mapView regionWillChangeAnimated:animated];
 }
 - (void)mapView:(MLNMapView *)mapView regionIsChangingWithReason:(MLNCameraChangeReason)reason {
-	if ([self owns]) [self.state gestureChange:self.view];
+	if ([self owns]) { [self.state gestureChange:self.view]; [self followCovers]; }
 	if ([self.previous respondsToSelector:_cmd]) [self.previous mapView:mapView regionIsChangingWithReason:reason];
 	else if ([self.previous respondsToSelector:@selector(mapViewRegionIsChanging:)]) [self.previous mapViewRegionIsChanging:mapView];
 }
@@ -338,6 +552,40 @@ RCT_REMAP_METHOD(cancelCamera, cancelCameraForSurface:(NSString *)identifier seq
 	@try { if (!TFAdmissionValidToken(identifier)) TFSurfaceInvalid(); [self.surfaces[identifier].state cancelCommand:TFSurfaceInteger(sequence)]; resolve(@{@"cancelled": @YES}); }
 	@catch (NSException *exception) { TFSurfaceReject(reject); }
 }
+static double TFSurfaceDuration(id value) {
+	if (![value isKindOfClass:NSNumber.class] || CFGetTypeID((__bridge CFTypeRef)value) == CFBooleanGetTypeID()) TFSurfaceInvalid();
+	double number = [value doubleValue];
+	if (!std::isfinite(number) || number < 0 || number > 5000 || std::floor(number) != number) TFSurfaceInvalid();
+	return number;
+}
+RCT_REMAP_METHOD(coverSurface, coverSurface:(NSString *)identifier duration:(NSNumber *)duration resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+	@try {
+		TFSurfaceAttachment *surface = [self current:identifier allowFailed:NO];
+		double milliseconds = TFSurfaceDuration(duration);
+		resolve(@{@"covered": @(milliseconds > 0 && [surface cover])});
+	} @catch (NSException *exception) { TFSurfaceReject(reject); }
+}
+RCT_REMAP_METHOD(revealSurface, revealSurface:(NSString *)identifier duration:(NSNumber *)duration resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+	@try {
+		TFSurfaceAttachment *surface = [self current:identifier allowFailed:YES];
+		[surface reveal:TFSurfaceDuration(duration) resolve:resolve];
+	} @catch (NSException *exception) { TFSurfaceReject(reject); }
+}
+RCT_REMAP_METHOD(applyThemeValues, applyThemeValuesForSurface:(NSString *)identifier style:(NSString *)token values:(NSDictionary *)values resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+	@try {
+		TFSurfaceAttachment *surface = [self current:identifier allowFailed:NO];
+		if (![values isKindOfClass:NSDictionary.class] || ![surface.token isEqual:token]) TFSurfaceInvalid();
+		NSUInteger applied = [surface applyThemeValues:values];
+		resolve(@{@"applied": @(applied)});
+	} @catch (NSException *exception) { TFSurfaceReject(reject); }
+}
+RCT_REMAP_METHOD(discardSurfaceCover, discardSurfaceCover:(NSString *)identifier resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+	@try {
+		if (!TFAdmissionValidToken(identifier)) TFSurfaceInvalid();
+		[self.surfaces[identifier] discardCovers];
+		resolve(@{@"discarded": @YES});
+	} @catch (NSException *exception) { TFSurfaceReject(reject); }
+}
 - (void)retire:(TFSurfaceAttachment *)surface resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject {
 	[surface retire];
 	if (!surface.root.window) { [self.surfaces removeObjectForKey:surface.identifier]; resolve(@{@"detached": @YES}); return; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tileflow/react-native",
-  "version": "0.1.0-alpha.1",
+  "version": "0.1.0-alpha.3",
   "license": "Apache-2.0",
   "description": "Tileflow maps, camera control and semantic interactions for React Native.",
   "type": "module",
@@ -36,7 +36,7 @@
     }
   },
   "dependencies": {
-    "@tileflow/core": ">=0.1.0-alpha.28 <0.1.0-beta.0",
+    "@tileflow/core": ">=0.1.0-alpha.32 <0.1.0-beta.0",
     "@tileflow/interactions": ">=0.1.0-alpha.4 <0.1.0-beta.0"
   },
   "peerDependencies": {