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

package/README.md

@@ -85,6 +85,21 @@ and protected delivery still require HTTPS.
 
 `onThemeChange` reports only the safe public selection shape. It does not expose style URLs, style JSON, configuration, session authority or native error messages.
 
+## Theme transitions and blends
+
+`themeTransition={{duration: 450}}` cross-fades theme changes: a snapshot of the drawn map covers it, follows the camera and fades out once the new theme is drawn. `themeBlend={{themes: ['night', 'dusk', 'day'], position}}` shows a continuous blend of the map's themes instead of `theme`; position 0 is the first theme and 1.5 is halfway from the second to the third:
+
+```tsx
+<Map
+  source={source}
+  themeTransition={{duration: 450}}
+  themeBlend={{themes: ['night', 'dusk', 'day'], position}}
+  style={{flex: 1}}
+/>
+```
+
+The first blend of a set of themes prepares every theme's style and replaces the native style once; moving `position` later changes the map without loading. Removing `themeBlend` returns to `theme`. Both keep the same native Map, context and session, and `ready` events wait for the fade. The device's reduce-motion setting changes at once. See [theme transitions and blends](https://github.com/tileflow/tileflow-sdk/blob/main/packages/core/docs/theme-transitions-and-blends.md#react-native) for what follows the position on native maps.
+
 ## Camera
 
 The existing mount-stable camera contract is preserved. Use either an initial camera seed or complete controlled camera ownership for the lifetime of one mounted Map:

package/android/src/main/java/dev/tileflow/reactnative/NativeTheme.kt

@@ -0,0 +1,75 @@
+package dev.tileflow.reactnative
+
+import android.animation.ValueAnimator
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Matrix
+import android.graphics.Paint
+import android.graphics.PorterDuff
+import android.graphics.PorterDuffXfermode
+import android.os.Build
+import android.provider.Settings
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReadableType
+import kotlin.math.roundToInt
+
+/** Pure helpers for theme transitions and blends on MapLibre Android. */
+internal object NativeTheme {
+	private const val maximumDepth = 32
+
+	/** A style-specification value from JavaScript as the plain Java value MapLibre converts. */
+	fun value(dynamic: Dynamic, depth: Int = 0): Any? {
+		if (depth > maximumDepth) throw IllegalStateException("Native surface operation failed.")
+		return when (dynamic.type) {
+			ReadableType.Null -> null
+			ReadableType.Boolean -> dynamic.asBoolean()
+			ReadableType.Number -> dynamic.asDouble().also { if (!it.isFinite()) throw IllegalStateException("Native surface operation failed.") }
+			ReadableType.String -> dynamic.asString()
+			ReadableType.Array -> {
+				val array = dynamic.asArray() ?: throw IllegalStateException("Native surface operation failed.")
+				Array(array.size()) { index -> value(array.getDynamic(index), depth + 1) }
+			}
+			ReadableType.Map -> {
+				val map = dynamic.asMap() ?: throw IllegalStateException("Native surface operation failed.")
+				val result = HashMap<String, Any?>()
+				val keys = map.keySetIterator()
+				while (keys.hasNextKey()) {
+					val key = keys.nextKey()
+					result[key] = value(map.getDynamic(key), depth + 1)
+				}
+				result
+			}
+		}
+	}
+
+	/** Whether the device shows animations; the "remove animations" setting turns them off. */
+	fun motionEnabled(context: Context): Boolean {
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && !ValueAnimator.areAnimatorsEnabled()) return false
+		return Settings.Global.getFloat(context.contentResolver, Settings.Global.ANIMATOR_DURATION_SCALE, 1f) != 0f
+	}
+
+	/** Pattern artwork mixed in premultiplied pixels: `from` at 1 - t plus `to` at t. */
+	fun mix(from: Bitmap, to: Bitmap, t: Double): Bitmap {
+		if (t <= 0) return from
+		if (t >= 1) return to
+		if (from.width != to.width || from.height != to.height) return if (t < 0.5) from else to
+		val result = Bitmap.createBitmap(from.width, from.height, Bitmap.Config.ARGB_8888)
+		result.density = from.density
+		val canvas = Canvas(result)
+		val paint = Paint()
+		paint.alpha = ((1 - t) * 255).roundToInt()
+		canvas.drawBitmap(from, 0f, 0f, paint)
+		paint.alpha = (t * 255).roundToInt()
+		paint.xfermode = PorterDuffXfermode(PorterDuff.Mode.ADD)
+		canvas.drawBitmap(to, 0f, 0f, paint)
+		return result
+	}
+
+	/** The projective transform taking four points to four points, or null when degenerate. */
+	fun homography(from: FloatArray, to: FloatArray): Matrix? {
+		if (from.size != 8 || to.size != 8 || to.any { !it.isFinite() }) return null
+		val matrix = Matrix()
+		return if (matrix.setPolyToPoly(from, 0, to, 0, 4)) matrix else null
+	}
+}

package/android/src/main/java/dev/tileflow/reactnative/TileflowNativeSurfaceModule.kt

@@ -1,10 +1,17 @@
 package dev.tileflow.reactnative
 
+import android.graphics.Bitmap
+import android.graphics.PointF
 import android.os.Handler
 import android.os.Looper
 import android.view.View
 import android.view.ViewGroup
+import android.view.PixelCopy
+import android.view.SurfaceView
+import android.view.TextureView
 import android.view.ViewTreeObserver
+import android.view.animation.AccelerateDecelerateInterpolator
+import android.widget.ImageView
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.Promise
@@ -19,9 +26,14 @@ import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.common.UIManagerType
 import java.util.UUID
 import kotlin.math.abs
+import org.maplibre.android.geometry.LatLng
 import org.maplibre.android.maps.MapLibreMap
 import org.maplibre.android.maps.MapView
 import org.maplibre.android.maps.Style
+import org.maplibre.android.style.layers.Layer
+import org.maplibre.android.style.layers.LayoutPropertyValue
+import org.maplibre.android.style.layers.PaintPropertyValue
+import org.maplibre.android.style.light.Position
 import org.maplibre.reactnative.components.camera.MLRNCamera
 import org.maplibre.reactnative.components.mapview.MLRNMapView
 
@@ -154,6 +166,35 @@ class TileflowNativeSurfaceModule(context: ReactApplicationContext) : ReactConte
 		surfaces[id]?.state?.cancelCommand(integer(sequence))
 		Arguments.makeNativeMap(mapOf("cancelled" to true))
 	}
+	private fun duration(value: Double): Long {
+		if (!value.isFinite() || value < 0 || value > 5000 || value != value.toLong().toDouble()) invalid()
+		return value.toLong()
+	}
+	@ReactMethod fun coverSurface(id: String, milliseconds: Double, promise: Promise) {
+		handler.post {
+			try {
+				val surface = current(id)
+				val covered = { value: Boolean -> promise.resolve(Arguments.makeNativeMap(mapOf("covered" to value))) }
+				if (duration(milliseconds) == 0L) covered(false) else surface.cover(covered)
+			} catch (_: Exception) { reject(promise) }
+		}
+	}
+	@ReactMethod fun revealSurface(id: String, milliseconds: Double, promise: Promise) {
+		handler.post {
+			try { current(id, allowFailed = true).reveal(duration(milliseconds), promise) }
+			catch (_: Exception) { reject(promise) }
+		}
+	}
+	@ReactMethod fun discardSurfaceCover(id: String, promise: Promise) = action(promise) {
+		if (!AdmissionUrl.validToken(id)) invalid()
+		surfaces[id]?.discardCovers()
+		Arguments.makeNativeMap(mapOf("discarded" to true))
+	}
+	@ReactMethod fun applyThemeValues(id: String, token: String, values: ReadableMap, promise: Promise) = action(promise) {
+		val surface = current(id)
+		if (surface.token != token) invalid()
+		Arguments.makeNativeMap(mapOf("applied" to surface.applyThemeValues(surface.style() ?: invalid(), values)))
+	}
 	private fun nearAngular(a: Double, b: Double): Boolean = abs(((a - b + 540) % 360) - 180) <= 0.000001
 	private fun view(input: ReadableMap): Map<String, Any> {
 		val keys = input.keySetIterator(); var count = 0
@@ -222,6 +263,13 @@ class TileflowNativeSurfaceModule(context: ReactApplicationContext) : ReactConte
 		var retiring = false
 		var deadline: Runnable? = null
 		var layoutWaiter: (() -> Unit)? = null
+		private val covers = mutableListOf<Cover>()
+		private val reveals = mutableListOf<Reveal>()
+		private val settling = mutableListOf<Reveal>()
+		private var revealDeadline: Runnable? = null
+		private var themedToken: String? = null
+		private val themedLayers = HashMap<String, Layer>()
+		private val themedImages = HashMap<String, Bitmap>()
 		private var layoutSnapshot: List<Int>? = null
 		fun marker() = "__tileflow_native_style_$token"
 		fun style(): Style? = sdk.style?.takeIf { it.isFullyLoaded && it.getLayer(marker()) != null }
@@ -233,13 +281,16 @@ class TileflowNativeSurfaceModule(context: ReactApplicationContext) : ReactConte
 		}
 		private fun guarded(action: () -> Unit) { if (!retiring) try { action() } catch (_: Exception) { state.fail() } }
 		private val loaded = MapView.OnDidFinishLoadingStyleListener { guarded { style()?.let { state.loaded(token, it) } } }
-		private val frameStart = MapView.OnWillStartRenderingFrameListener { guarded { sampleLayout(); state.frameStart(style()) } }
-		private val frameEnd = MapView.OnDidFinishRenderingFrameListener { fully, _, _ -> guarded { state.frameEnd(style(), fully) } }
+		private val frameStart = MapView.OnWillStartRenderingFrameListener { guarded { sampleLayout(); state.frameStart(style()); followCovers() } }
+		private val frameEnd = MapView.OnDidFinishRenderingFrameListener { fully, _, _ -> guarded {
+			state.frameEnd(style(), fully)
+			if (fully && reveals.isNotEmpty()) startReveals()
+		} }
 		private val cameraStart = MapLibreMap.OnCameraMoveStartedListener { reason -> guarded {
 			if (reason == MapLibreMap.OnCameraMoveStartedListener.REASON_API_GESTURE) state.gestureStart(view())
 			else state.gestureEnd(view())
 		} }
-		private val cameraMove = MapLibreMap.OnCameraMoveListener { guarded { state.gestureChange(view()) } }
+		private val cameraMove = MapLibreMap.OnCameraMoveListener { guarded { state.gestureChange(view()); followCovers() } }
 		private val cameraEnd = MapLibreMap.OnCameraIdleListener { guarded { state.gestureEnd(view()) } }
 		private val layout = View.OnLayoutChangeListener { _, _, _, _, _, _, _, _, _ -> guarded { sampleLayout() } }
 		fun sampleLayout() {
@@ -257,6 +308,7 @@ class TileflowNativeSurfaceModule(context: ReactApplicationContext) : ReactConte
 		}
 		fun retire() {
 			if (retiring) return
+			discardCovers()
 			retiring = true; state.close(); deadline?.let { handler.removeCallbacks(it) }; deadline = null
 			layoutWaiter?.invoke(); layoutWaiter = null
 			root.removeOnLayoutChangeListener(layout); map.removeOnLayoutChangeListener(layout)
@@ -265,6 +317,162 @@ class TileflowNativeSurfaceModule(context: ReactApplicationContext) : ReactConte
 			sdk.removeOnCameraMoveStartedListener(cameraStart); sdk.removeOnCameraMoveListener(cameraMove); sdk.removeOnCameraIdleListener(cameraEnd)
 			if (!root.isAttachedToWindow) onViewDetachedFromWindow(root)
 		}
+		/** A snapshot of one frame over the rendering view that follows four of its ground points. */
+		inner class Cover(val view: ImageView, val corners: FloatArray, val anchors: List<LatLng>) { var fading = false }
+		inner class Reveal(val duration: Long, val covers: List<Cover>, var promise: Promise?)
+
+		fun cover(covered: (Boolean) -> Unit) {
+			val render = map.renderView
+			if (!NativeTheme.motionEnabled(reactApplicationContext) || !foreground || style() == null || render == null ||
+				render.width < 1 || render.height < 1 || covers.size >= 4) { covered(false); return }
+			if (covers.any { !it.fading }) { covered(true); return }
+			// Only the drawn map is copied; logo, attribution and markers stay live above the cover.
+			when (render) {
+				is TextureView -> covered(render.bitmap?.let { addCover(it) } ?: false)
+				is SurfaceView -> {
+					val bitmap = Bitmap.createBitmap(render.width, render.height, Bitmap.Config.ARGB_8888)
+					PixelCopy.request(render, bitmap, { result ->
+						covered(try { result == PixelCopy.SUCCESS && addCover(bitmap) } catch (_: Exception) { false })
+					}, handler)
+				}
+				else -> covered(false)
+			}
+		}
+		private fun addCover(bitmap: Bitmap): Boolean {
+			val render = map.renderView
+			if (retiring || style() == null || render == null || !NativeTheme.motionEnabled(reactApplicationContext)) return false
+			val width = bitmap.width.toFloat(); val height = bitmap.height.toFloat()
+			// Ground points below the horizon at any supported pitch, in snapshot pixels.
+			val corners = floatArrayOf(width * 0.1f, height * 0.45f, width * 0.9f, height * 0.45f, width * 0.9f, height * 0.9f, width * 0.1f, height * 0.9f)
+			val projection = sdk.projection
+			val anchors = (0 until 4).map { projection.fromScreenLocation(PointF(corners[2 * it], corners[2 * it + 1])) }
+			if (anchors.any { !it.latitude.isFinite() || !it.longitude.isFinite() }) return false
+			val view = ImageView(map.context)
+			view.scaleType = ImageView.ScaleType.MATRIX
+			view.setImageBitmap(bitmap)
+			view.isClickable = false; view.isFocusable = false
+			view.importantForAccessibility = View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS
+			// Newer covers go below older ones, which keep fading on top.
+			map.addView(view, map.indexOfChild(render) + 1, ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT))
+			// React Native lays out only the views it manages, so the cover is sized here.
+			view.measure(View.MeasureSpec.makeMeasureSpec(map.width, View.MeasureSpec.EXACTLY), View.MeasureSpec.makeMeasureSpec(map.height, View.MeasureSpec.EXACTLY))
+			view.layout(0, 0, map.width, map.height)
+			covers.add(Cover(view, corners, anchors))
+			followCovers()
+			return true
+		}
+		private fun followCovers() {
+			if (covers.isEmpty()) return
+			val projection = sdk.projection
+			for (cover in covers) {
+				val target = FloatArray(8)
+				cover.anchors.forEachIndexed { index, anchor ->
+					val point = projection.toScreenLocation(anchor)
+					target[2 * index] = point.x; target[2 * index + 1] = point.y
+				}
+				NativeTheme.homography(cover.corners, target)?.let { cover.view.imageMatrix = it }
+			}
+		}
+		fun reveal(duration: Long, promise: Promise) {
+			val reveal = Reveal(duration, covers.toList(), promise)
+			if (reveal.covers.isEmpty()) { promise.resolve(Arguments.makeNativeMap(mapOf("revealed" to true))); return }
+			reveals.add(reveal)
+			// Fades start on the next complete frame, or after ten seconds at most.
+			if (revealDeadline == null) {
+				val timeout = Runnable { revealDeadline = null; startReveals() }
+				revealDeadline = timeout; handler.postDelayed(timeout, 10000)
+			}
+			sdk.triggerRepaint()
+		}
+		private fun startReveals() {
+			revealDeadline?.let { handler.removeCallbacks(it) }; revealDeadline = null
+			val pending = reveals.toList(); reveals.clear()
+			for (reveal in pending) {
+				for (cover in reveal.covers) {
+					if (cover.fading) continue
+					cover.fading = true
+					cover.view.animate().alpha(0f).setDuration(reveal.duration).setInterpolator(AccelerateDecelerateInterpolator())
+						.withEndAction { removeCover(cover) }.start()
+				}
+				settle(reveal)
+			}
+		}
+		private fun removeCover(cover: Cover) {
+			cover.view.animate().cancel(); map.removeView(cover.view); covers.remove(cover)
+			for (reveal in settling.toList()) settle(reveal)
+		}
+		// A reveal resolves once every cover that existed when it was requested is gone.
+		private fun settle(reveal: Reveal) {
+			if (reveal.covers.any { it in covers }) { if (reveal !in settling) settling.add(reveal); return }
+			settling.remove(reveal)
+			reveal.promise?.resolve(Arguments.makeNativeMap(mapOf("revealed" to true))); reveal.promise = null
+		}
+		fun discardCovers() {
+			revealDeadline?.let { handler.removeCallbacks(it) }; revealDeadline = null
+			for (cover in covers.toList()) { cover.view.animate().cancel(); map.removeView(cover.view) }
+			covers.clear()
+			for (reveal in reveals + settling) { reveal.promise?.resolve(Arguments.makeNativeMap(mapOf("revealed" to true))); reveal.promise = null }
+			reveals.clear(); settling.clear()
+		}
+
+		fun applyThemeValues(style: Style, values: ReadableMap): Int {
+			if (themedToken != token) {
+				// Layers and original artwork belong to one style.
+				themedToken = token; themedLayers.clear(); themedImages.clear()
+			}
+			var applied = 0
+			for (group in listOf("paint", "layout")) {
+				if (!values.hasKey(group)) continue
+				val entries = values.getArray(group) ?: invalid()
+				if (entries.size() > 8192) invalid()
+				for (index in 0 until entries.size()) {
+					val entry = entries.getArray(index) ?: invalid()
+					if (entry.size() != 3 || entry.getType(0) != ReadableType.String || entry.getType(1) != ReadableType.String) invalid()
+					val identifier = entry.getString(0) ?: invalid()
+					val layer = themedLayers[identifier] ?: style.getLayer(identifier)?.also { themedLayers[identifier] = it } ?: continue
+					val property = entry.getString(1) ?: invalid()
+					val value = NativeTheme.value(entry.getDynamic(2))
+					layer.setProperties(if (group == "paint") PaintPropertyValue(property, value) else LayoutPropertyValue(property, value))
+					applied++
+				}
+			}
+			if (values.hasKey("images")) {
+				val images = values.getArray("images") ?: invalid()
+				if (images.size() > 64) invalid()
+				// Originals are read before any artwork is replaced, so tuples can share names.
+				for (index in 0 until images.size()) {
+					val entry = images.getArray(index) ?: invalid()
+					if (entry.size() != 4 || (0 until 3).any { entry.getType(it) != ReadableType.String } || entry.getType(3) != ReadableType.Number) invalid()
+					for (name in (0 until 3).map { entry.getString(it) ?: invalid() })
+						if (!themedImages.containsKey(name)) style.getImage(name)?.let { themedImages[name] = it }
+				}
+				for (index in 0 until images.size()) {
+					val entry = images.getArray(index) ?: invalid()
+					val from = themedImages[entry.getString(1)] ?: continue
+					val to = themedImages[entry.getString(2)] ?: continue
+					val t = entry.getDouble(3)
+					if (!t.isFinite() || t < 0 || t > 1) invalid()
+					style.addImage(entry.getString(0) ?: invalid(), NativeTheme.mix(from, to, t))
+					applied++
+				}
+			}
+			if (values.hasKey("light")) {
+				val light = values.getMap("light") ?: invalid()
+				val target = style.light
+				if (target != null) {
+					if (light.hasKey("color") && light.getType("color") == ReadableType.String) target.setColor(light.getString("color") ?: invalid())
+					if (light.hasKey("intensity") && light.getType("intensity") == ReadableType.Number) target.intensity = light.getDouble("intensity").toFloat()
+					if (light.hasKey("position") && light.getType("position") == ReadableType.Array) {
+						val position = light.getArray("position") ?: invalid()
+						if (position.size() == 3 && (0 until 3).all { position.getType(it) == ReadableType.Number })
+							target.position = Position(position.getDouble(0).toFloat(), position.getDouble(1).toFloat(), position.getDouble(2).toFloat())
+					}
+					applied++
+				}
+			}
+			return applied
+		}
+
 		override fun onViewAttachedToWindow(view: View) { guarded { sampleLayout() } }
 		override fun onViewDetachedFromWindow(view: View) {
 			retire(); root.removeOnAttachStateChangeListener(this); surfaces.remove(id)

package/dist/{contract-DWs-lDPo.d.ts → contract-Bwl-gB-I.d.ts}

@@ -27,9 +27,35 @@ type MapColorScheme = NonNullable<TileflowNativeSourceOptions['colorScheme']>;
 type MapView = TileflowNativeInitialView;
 /** Portable composition inputs, independent from source acquisition. */
 type MapInitialViewInputs = TileflowNativeInitialViewOptions;
+/**
+ * How a theme change appears. With a `duration`, a snapshot of the current frame covers the map,
+ * follows the camera, and fades out once the new theme is drawn. The device's reduce-motion
+ * setting changes at once.
+ */
+type MapThemeTransition = Readonly<{
+    /** Cross-fade length in milliseconds, from 0 (the default, an immediate change) to 5000. */
+    duration?: number;
+}>;
+/**
+ * A continuous blend of two to eight concrete themes of the map, shown instead of `theme`.
+ * `position` runs from 0 (the first theme) to `themes.length - 1`; 1.25 is a quarter of the way
+ * from the second theme to the third. Ground colours and widths follow the position; labels and
+ * icons cross-fade when the nearest theme changes.
+ */
+type MapThemeBlend = Readonly<{
+    themes: readonly string[];
+    position: number;
+}>;
 type MapSourceProps = Readonly<{
     source: MapSource;
     theme?: MapThemeSelection;
+    /** Cross-fades theme changes, including entering and leaving a blend. */
+    themeTransition?: MapThemeTransition;
+    /**
+     * Shows a blend of themes instead of `theme`. The first blend of a set of themes prepares one
+     * style that holds all of them; moving `position` later changes the map without loading.
+     */
+    themeBlend?: MapThemeBlend;
 }>;
 type AllowedMapOptions = 'dragPan' | 'touchZoom' | 'doubleTapZoom' | 'doubleTapHoldZoom' | 'touchRotate' | 'touchPitch' | 'compass' | 'compassHiddenFacingNorth' | 'scaleBar';
 type OwnedMapOptions = Exclude<keyof MapProps$1, AllowedMapOptions> | 'container' | 'styleURL' | 'styleUrl' | 'transformRequest' | 'requestTransform' | 'requestHeaders';
@@ -141,4 +167,4 @@ type MapCameraProps = Readonly<{
 /** Complete Tileflow source, presentation, mount-stable camera and portable interaction inputs. */
 type MapProps<TAnnotation extends TileflowAnnotation = TileflowAnnotation> = MapBaseProps & MapCameraProps & MapInteractionProps<TAnnotation>;
 
-export type { MapView as M, MapViewChangeEvent as a, MapInitialViewInputs as b, MapCameraProps as c, MapProps as d, MapBaseProps as e, MapColorScheme as f, MapErrorEvent as g, MapEventHandlers as h, MapInteractionEvent as i, MapInteractionProps as j, MapLoadEvent as k, MapMarkerRenderContext as l, MapMarkerRenderer as m, MapOptions as n, MapPresentationProps as o, MapReadinessChangeEvent as p, MapRef as q, MapSelection as r, MapSource as s, MapSourceError as t, MapSourceProps as u, MapSourceState as v, MapTheme as w, MapThemeChangeEvent as x, MapThemeSelection as y };
+export type { MapThemeTransition as A, MapView as M, MapViewChangeEvent as a, MapInitialViewInputs as b, MapCameraProps as c, MapProps as d, MapBaseProps as e, MapColorScheme as f, MapErrorEvent as g, MapEventHandlers as h, MapInteractionEvent as i, MapInteractionProps as j, MapLoadEvent as k, MapMarkerRenderContext as l, MapMarkerRenderer as m, MapOptions as n, MapPresentationProps as o, MapReadinessChangeEvent as p, MapRef as q, MapSelection as r, MapSource as s, MapSourceError as t, MapSourceProps as u, MapSourceState as v, MapTheme as w, MapThemeBlend as x, MapThemeChangeEvent as y, MapThemeSelection as z };

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import { ReactElement } from 'react';
 import { TileflowAnnotation } from '@tileflow/interactions';
 export { TileflowAnnotation, TileflowInteractionBinding, TileflowInteractionCoordinate, TileflowInteractionDiagnostic, TileflowPoiCategory, TileflowResolvedAnnotationTarget, TileflowResolvedPoiFeatureTarget } from '@tileflow/interactions';
-import { d as MapProps } from './contract-DWs-lDPo.js';
-export { e as MapBaseProps, c as MapCameraProps, f as MapColorScheme, g as MapErrorEvent, h as MapEventHandlers, b as MapInitialViewInputs, i as MapInteractionEvent, j as MapInteractionProps, k as MapLoadEvent, l as MapMarkerRenderContext, m as MapMarkerRenderer, n as MapOptions, o as MapPresentationProps, p as MapReadinessChangeEvent, q as MapRef, r as MapSelection, s as MapSource, t as MapSourceError, u as MapSourceProps, v as MapSourceState, w as MapTheme, x as MapThemeChangeEvent, y as MapThemeSelection, M as MapView, a as MapViewChangeEvent } from './contract-DWs-lDPo.js';
+import { d as MapProps } from './contract-Bwl-gB-I.js';
+export { e as MapBaseProps, c as MapCameraProps, f as MapColorScheme, g as MapErrorEvent, h as MapEventHandlers, b as MapInitialViewInputs, i as MapInteractionEvent, j as MapInteractionProps, k as MapLoadEvent, l as MapMarkerRenderContext, m as MapMarkerRenderer, n as MapOptions, o as MapPresentationProps, p as MapReadinessChangeEvent, q as MapRef, r as MapSelection, s as MapSource, t as MapSourceError, u as MapSourceProps, v as MapSourceState, w as MapTheme, x as MapThemeBlend, y as MapThemeChangeEvent, z as MapThemeSelection, A as MapThemeTransition, M as MapView, a as MapViewChangeEvent } from './contract-Bwl-gB-I.js';
 import '@maplibre/maplibre-react-native';
 import 'react-native';
 import '@tileflow/core/native';