craft-native 0.0.238 → 0.0.242

package/dist/android/templates/CraftNativeMapGoogle.kt.template

@@ -0,0 +1,440 @@
+/** The Android host for the small, host-neutral native trail map contract. */
+private class CraftNativeMapView(context: Context) : FrameLayout(context), OnMapReadyCallback {
+    private val mapView = MapView(context)
+    private val scaleView = LinearLayout(context).apply {
+        orientation = LinearLayout.VERTICAL
+        setPadding(4, 2, 4, 2)
+        background = GradientDrawable().apply { setColor(Color.argb(230, 255, 255, 255)); cornerRadius = 4f }
+        importantForAccessibility = View.IMPORTANT_FOR_ACCESSIBILITY_NO
+    }
+    private val scaleLabel = TextView(context).apply { textSize = 11f; setTextColor(Color.rgb(37, 51, 33)) }
+    private val scaleLine = View(context).apply { setBackgroundColor(Color.rgb(37, 51, 33)) }
+    private var googleMap: GoogleMap? = null
+    private var tileOverlay: com.google.android.gms.maps.model.TileOverlay? = null
+    private var tileTemplate: String? = null
+    private val tileAttribution = TextView(context).apply { textSize = 9f; setTextColor(Color.DKGRAY); setBackgroundColor(Color.argb(220, 255, 255, 255)); maxLines = 2; visibility = View.GONE }
+    private var pendingProps = JSONObject()
+    private var pendingChildren = JSONArray()
+    private val markers = mutableMapOf<String, Marker>()
+    private val polylines = mutableMapOf<String, Polyline>()
+    private val markerHandlers = mutableMapOf<String, String>()
+    private var onMarkerTap: ((String) -> Unit)? = null
+    var onMapPress: ((LatLng) -> Unit)? = null
+    var onRegionChangeComplete: ((JSONObject) -> Unit)? = null
+    private var userChangingCamera = false
+    private var markerBearings = mutableMapOf<String, Float>()
+    private var markerPinColors = mutableMapOf<String, Int>()
+    private val pinIcons = mutableMapOf<Int, com.google.android.gms.maps.model.BitmapDescriptor>()
+    private var directionIcon: com.google.android.gms.maps.model.BitmapDescriptor? = null
+    private var lifecycleStarted = false
+    private var destroyed = false
+    private var initialCameraKey: String? = null
+
+    init {
+        addView(mapView, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
+        scaleView.addView(scaleLabel)
+        scaleView.addView(scaleLine, LinearLayout.LayoutParams(1, 2))
+        addView(scaleView, LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT, Gravity.BOTTOM or Gravity.START).apply {
+            leftMargin = (8 * resources.displayMetrics.density).roundToInt()
+            bottomMargin = (24 * resources.displayMetrics.density).roundToInt()
+        })
+        scaleView.visibility = View.GONE
+        addView(tileAttribution, LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT, Gravity.BOTTOM or Gravity.END).apply { rightMargin = (8 * resources.displayMetrics.density).roundToInt(); bottomMargin = (8 * resources.displayMetrics.density).roundToInt() })
+        mapView.onCreate(null)
+        mapView.getMapAsync(this)
+    }
+
+    override fun onMapReady(map: GoogleMap) {
+        if (destroyed) return
+        googleMap = map
+        map.setOnMapClickListener { point -> onMapPress?.invoke(point) }
+        map.setOnCameraMoveStartedListener { reason ->
+            if (reason == GoogleMap.OnCameraMoveStartedListener.REASON_GESTURE) userChangingCamera = true
+        }
+        map.setOnCameraMoveListener { updateScale() }
+        map.setOnCameraIdleListener {
+            updateScale()
+            if (userChangingCamera) {
+                userChangingCamera = false
+                val bounds = map.projection.visibleRegion.latLngBounds
+                val position = map.cameraPosition
+                val longitudeDelta = (bounds.northeast.longitude - bounds.southwest.longitude + 360) % 360
+                onRegionChangeComplete?.invoke(JSONObject()
+                    .put("center", JSONObject().put("latitude", position.target.latitude).put("longitude", position.target.longitude))
+                    .put("span", JSONObject().put("latitudeDelta", bounds.northeast.latitude - bounds.southwest.latitude).put("longitudeDelta", longitudeDelta))
+                    .put("heading", position.bearing).put("pitch", position.tilt))
+            }
+        }
+        map.setOnMarkerClickListener { marker ->
+            val id = markers.entries.firstOrNull { it.value == marker }?.key ?: return@setOnMarkerClickListener false
+            onMarkerTap?.invoke(id)
+            // The native contract dispatches the marker event itself. Consume
+            // the click so Google Maps does not also show an unsolicited info
+            // window for the marker title.
+            true
+        }
+        applyPending()
+    }
+
+    fun configure(props: JSONObject, children: JSONArray, markerHandler: (String) -> Unit) {
+        pendingProps = props
+        pendingChildren = children
+        onMarkerTap = markerHandler
+        applyPending()
+    }
+
+    fun markerHandler(id: String): String? = markerHandlers[id]
+
+    private fun applyPending() {
+        val map = googleMap ?: return
+        applyMapPadding()
+        map.uiSettings.isCompassEnabled = craftNativeBoolean(pendingProps.opt("showsCompass"))
+        // The toolbar is replaced by authored actions; the scale uses the native projection.
+        map.uiSettings.isMapToolbarEnabled = false
+        map.uiSettings.isScrollGesturesEnabled = craftNativeBoolean(pendingProps.opt("scrollEnabled"), true)
+        map.uiSettings.isZoomGesturesEnabled = craftNativeBoolean(pendingProps.opt("zoomEnabled"), true)
+        map.uiSettings.isRotateGesturesEnabled = craftNativeBoolean(pendingProps.opt("rotateEnabled"))
+        map.uiSettings.isTiltGesturesEnabled = craftNativeBoolean(pendingProps.opt("pitchEnabled"), true)
+        map.mapType = when (craftNativeOptionalString(pendingProps.opt("mapType")).orEmpty().lowercase()) {
+            "satellite" -> GoogleMap.MAP_TYPE_SATELLITE
+            "hybrid" -> GoogleMap.MAP_TYPE_HYBRID
+            "terrain" -> GoogleMap.MAP_TYPE_TERRAIN
+            else -> GoogleMap.MAP_TYPE_NORMAL
+        }
+        applyTileOverlay()
+        val showUserLocation = craftNativeBoolean(pendingProps.opt("showsUserLocation")) && hasLocationPermission()
+        runCatching { map.isMyLocationEnabled = showUserLocation }
+        val nextMarkers = mutableMapOf<String, Pair<LatLng, String?>>()
+        val nextBearings = mutableMapOf<String, Float>()
+        val nextPinColors = mutableMapOf<String, Int>()
+        val nextHandlers = mutableMapOf<String, String>()
+        val nextPolylines = mutableMapOf<String, Triple<List<LatLng>, Int, Float>>()
+        for (index in 0 until pendingChildren.length()) {
+            val child = pendingChildren.optJSONObject(index) ?: continue
+            val type = child.optString("type").lowercase()
+            val props = child.optJSONObject("props") ?: JSONObject()
+            val events = child.optJSONObject("events") ?: JSONObject()
+            val id = craftNativeOptionalString(props.opt("id"))
+                ?: craftNativeOptionalString(child.opt("id"))
+                ?: "overlay-$index"
+            val points = coordinates(props.optJSONArray("geometry"))
+            if (type == "mapmarker" || type == "marker") {
+                points.firstOrNull()?.let { point ->
+                    nextMarkers[id] = point to (props.opt("title") as? String)
+                    (props.opt("pinColor") as? String)?.let { value -> runCatching { craftNativeColor(value) }.getOrNull()?.let { nextPinColors[id] = it } }
+                    (props.opt("bearing") as? Number)?.toDouble()?.takeIf { it.isFinite() }?.let { nextBearings[id] = (it % 360).toFloat() }
+                    listOf(events.opt("onPress"), events.opt("onMarkerPress"))
+                        .firstNotNullOfOrNull(::craftNativeOptionalString)
+                        ?.let { nextHandlers[id] = it }
+                }
+            } else if (type == "mappolyline" || type == "polyline") {
+                if (points.size > 1) {
+                    // Keep malformed authored widths inert, matching the iOS
+                    // host. An omitted or null width still gets the shared
+                    // default; an attacker-controlled NaN, infinity, zero,
+                    // or negative value must not become a valid overlay.
+                    val rawWidth = props.opt("strokeWidth")
+                    val authoredWidth = when (rawWidth) {
+                        null, JSONObject.NULL -> 3.0
+                        is Number -> rawWidth.toDouble()
+                        else -> 3.0
+                    }
+                    // MapKit's lineWidth is expressed in points, while the
+                    // Google Maps SDK consumes screen pixels. Keep the
+                    // protocol in logical points and convert only at this
+                    // Android host boundary so dense displays stay in parity.
+                    val width = (authoredWidth * resources.displayMetrics.density).toFloat()
+                    if (!authoredWidth.isFinite() || !width.isFinite() || width <= 0f) continue
+                    nextPolylines[id] = Triple(points, color(craftNativeOptionalString(props.opt("strokeColor")).orEmpty()), width)
+                }
+            }
+        }
+        markerBearings = nextBearings
+        markerPinColors = nextPinColors
+        pinIcons.keys.filter { it !in markerPinColors.values }.forEach { pinIcons.remove(it) }
+        markers.keys.filter { nextMarkers[it] == null }.forEach { markers.remove(it)?.remove() }
+        for ((id, value) in nextMarkers) {
+            val marker = markers[id]
+            if (marker != null) {
+                marker.position = value.first
+                marker.title = value.second
+                marker.setIcon(if (markerBearings.containsKey(id)) directionMarkerIcon() else pinMarkerIcon(id))
+                marker.isFlat = markerBearings.containsKey(id)
+                marker.rotation = markerBearings[id] ?: 0f
+                marker.setAnchor(0.5f, if (markerBearings.containsKey(id) || markerPinColors.containsKey(id)) 0.5f else 1f)
+            } else {
+                map.addMarker(MarkerOptions().position(value.first).title(value.second).icon(if (markerBearings.containsKey(id)) directionMarkerIcon() else pinMarkerIcon(id)).flat(markerBearings.containsKey(id)).rotation(markerBearings[id] ?: 0f).anchor(0.5f, if (markerBearings.containsKey(id) || markerPinColors.containsKey(id)) 0.5f else 1f))?.let { markers[id] = it }
+            }
+        }
+        markerHandlers.clear()
+        markerHandlers.putAll(nextHandlers)
+        polylines.keys.filter { nextPolylines[it] == null }.forEach { id ->
+            polylines.remove(id)?.remove()
+        }
+        for ((id, value) in nextPolylines) {
+            val polyline = polylines[id]
+            if (polyline != null) {
+                polyline.points = value.first
+                polyline.color = value.second
+                polyline.width = value.third
+            } else {
+                map.addPolyline(PolylineOptions().addAll(value.first).color(value.second).width(value.third))?.let { polylines[id] = it }
+            }
+        }
+        val explicitRegion = region(pendingProps.optJSONObject("region"))
+        val initialRegion = region(pendingProps.optJSONObject("initialRegion"))
+        if (explicitRegion != null) {
+            // A controlled region is an exact camera request. The padding
+            // used for fitToBounds is framing chrome, not part of the region
+            // contract, and would otherwise zoom every Android screen out.
+            moveCamera(explicitRegion, padding = 0)
+            initialCameraKey = null
+        } else if (initialRegion != null) {
+            val key = "region:${pendingProps.optJSONObject("initialRegion")}"
+            if (initialCameraKey != key) {
+                moveCamera(initialRegion, padding = 0)
+                initialCameraKey = key
+            }
+        } else if (craftNativeBoolean(pendingProps.opt("fitToBounds"))) {
+            val key = "fit:${overlayKey(nextMarkers, nextPolylines)}:${pendingProps.optJSONObject("edgePadding")}"
+            if (initialCameraKey != key) {
+                if (fitToBounds()) initialCameraKey = key
+            }
+        } else {
+            initialCameraKey = null
+        }
+        applyCameraOrientation()
+        updateScale()
+    }
+
+    private fun applyTileOverlay() {
+        val map = googleMap ?: return
+        val options = pendingProps.optJSONObject("tileOverlay")
+        val template = options?.optString("urlTemplate").orEmpty()
+        val credit = options?.optString("attribution").orEmpty()
+        val next = template.takeIf { it.startsWith("https://") && listOf("{z}", "{x}", "{y}").all { key -> it.contains(key) } && credit.isNotBlank() }
+        if (next != tileTemplate) {
+            tileOverlay?.remove(); tileOverlay = null; tileTemplate = next
+            if (next != null) {
+                val provider = object : com.google.android.gms.maps.model.UrlTileProvider(256, 256) {
+                    override fun getTileUrl(x: Int, y: Int, zoom: Int): java.net.URL? = runCatching { java.net.URL(next.replace("{x}", x.toString()).replace("{y}", y.toString()).replace("{z}", zoom.toString())) }.getOrNull()
+                }
+                tileOverlay = map.addTileOverlay(com.google.android.gms.maps.model.TileOverlayOptions().tileProvider(provider).zIndex(-1f))
+            }
+        }
+        if (next != null) map.mapType = GoogleMap.MAP_TYPE_NONE
+        tileAttribution.text = credit
+        tileAttribution.visibility = if (next == null) View.GONE else View.VISIBLE
+    }
+
+    private fun applyMapPadding() {
+        val authored = pendingProps.optJSONObject("edgePadding")
+        fun inset(name: String): Double = (authored?.opt(name) as? Number)?.toDouble()?.takeIf { it.isFinite() }?.coerceIn(0.0, 10_000.0)?.times(resources.displayMetrics.density) ?: 0.0
+        var left = inset("left"); var top = inset("top"); var right = inset("right"); var bottom = inset("bottom")
+        val horizontal = left + right
+        val vertical = top + bottom
+        val availableWidth = (width - 40 * resources.displayMetrics.density).coerceAtLeast(0f).toDouble()
+        val availableHeight = (height - 40 * resources.displayMetrics.density).coerceAtLeast(0f).toDouble()
+        if (horizontal > availableWidth && horizontal > 0) { left *= availableWidth / horizontal; right *= availableWidth / horizontal }
+        if (vertical > availableHeight && vertical > 0) { top *= availableHeight / vertical; bottom *= availableHeight / vertical }
+        googleMap?.setPadding(left.roundToInt(), top.roundToInt(), right.roundToInt(), bottom.roundToInt())
+    }
+
+    private fun updateScale() {
+        val map = googleMap ?: return
+        if (!craftNativeBoolean(pendingProps.opt("showsScale")) || width <= 0 || height <= 0) { scaleView.visibility = View.GONE; return }
+        val maximumWidth = (80 * resources.displayMetrics.density).roundToInt()
+        val origin = map.projection.fromScreenLocation(android.graphics.Point(width / 2, height / 2))
+        val end = map.projection.fromScreenLocation(android.graphics.Point(width / 2 + maximumWidth, height / 2))
+        val distance = FloatArray(1)
+        android.location.Location.distanceBetween(origin.latitude, origin.longitude, end.latitude, end.longitude, distance)
+        val metres = distance[0].toDouble()
+        if (!metres.isFinite() || metres <= 0) { scaleView.visibility = View.GONE; return }
+        val magnitude = Math.pow(10.0, kotlin.math.floor(kotlin.math.log10(metres)))
+        val length = listOf(5.0, 2.0, 1.0).firstOrNull { it * magnitude <= metres }?.times(magnitude) ?: magnitude
+        scaleLabel.text = if (length >= 1000) "${length / 1000} km" else "${length.roundToInt()} m"
+        scaleLine.layoutParams = LinearLayout.LayoutParams((maximumWidth * length / metres).roundToInt().coerceAtLeast(1), 2)
+        scaleView.visibility = View.VISIBLE
+    }
+
+    private fun applyCameraOrientation() {
+        val map = googleMap ?: return
+        val camera = map.cameraPosition
+        val pitch = (pendingProps.opt("cameraPitch") as? Number)?.toDouble()?.takeIf { it.isFinite() }?.coerceIn(0.0, 60.0)?.toFloat() ?: camera.tilt
+        val heading = (pendingProps.opt("cameraHeading") as? Number)?.toDouble()?.takeIf { it.isFinite() }?.toFloat() ?: camera.bearing
+        if (kotlin.math.abs(camera.tilt - pitch) > 0.01f || kotlin.math.abs(camera.bearing - heading) > 0.01f) {
+            map.moveCamera(CameraUpdateFactory.newCameraPosition(com.google.android.gms.maps.model.CameraPosition.Builder(camera).tilt(pitch).bearing(heading).build()))
+        }
+    }
+
+    private fun pinMarkerIcon(id: String): com.google.android.gms.maps.model.BitmapDescriptor {
+        val color = markerPinColors[id] ?: return BitmapDescriptorFactory.defaultMarker()
+        return pinIcons.getOrPut(color) {
+            val size = (18 * resources.displayMetrics.density).roundToInt().coerceAtLeast(18)
+            val bitmap = Bitmap.createBitmap(size, size, Bitmap.Config.ARGB_8888)
+            val canvas = Canvas(bitmap)
+            val paint = Paint(Paint.ANTI_ALIAS_FLAG)
+            paint.color = Color.WHITE
+            canvas.drawCircle(size / 2f, size / 2f, size / 2f, paint)
+            paint.color = color
+            canvas.drawCircle(size / 2f, size / 2f, size * 0.38f, paint)
+            BitmapDescriptorFactory.fromBitmap(bitmap)
+        }
+    }
+
+    private fun directionMarkerIcon(): com.google.android.gms.maps.model.BitmapDescriptor {
+        directionIcon?.let { return it }
+        val size = (26 * resources.displayMetrics.density).roundToInt().coerceAtLeast(24)
+        val bitmap = Bitmap.createBitmap(size, size, Bitmap.Config.ARGB_8888)
+        val canvas = Canvas(bitmap)
+        val paint = Paint(Paint.ANTI_ALIAS_FLAG)
+        paint.color = Color.WHITE
+        canvas.drawCircle(size / 2f, size / 2f, size / 2f, paint)
+        paint.color = Color.rgb(36, 114, 75)
+        canvas.drawCircle(size / 2f, size / 2f, size * 0.43f, paint)
+        paint.color = Color.WHITE
+        paint.textSize = size * 0.76f
+        paint.textAlign = Paint.Align.CENTER
+        paint.typeface = Typeface.DEFAULT_BOLD
+        canvas.drawText("↑", size / 2f, size / 2f - (paint.ascent() + paint.descent()) / 2, paint)
+        return BitmapDescriptorFactory.fromBitmap(bitmap).also { directionIcon = it }
+    }
+
+    override fun onSizeChanged(width: Int, height: Int, oldWidth: Int, oldHeight: Int) {
+        super.onSizeChanged(width, height, oldWidth, oldHeight)
+        applyMapPadding()
+        updateScale()
+        // MapView can become ready before its host has a usable viewport. Do
+        // not mark a fit as complete until the camera update can be issued.
+        if (width > 0 && height > 0 && craftNativeBoolean(pendingProps.opt("fitToBounds")) && initialCameraKey == null) {
+            applyPending()
+        }
+    }
+
+    private fun moveCamera(bounds: LatLngBounds, padding: Int = 24) {
+        post {
+            if (width > 0 && height > 0) {
+                googleMap?.moveCamera(CameraUpdateFactory.newLatLngBounds(bounds, padding))
+                applyCameraOrientation()
+            }
+        }
+    }
+
+    private fun overlayKey(
+        markers: Map<String, Pair<LatLng, String?>>,
+        polylines: Map<String, Triple<List<LatLng>, Int, Float>>,
+    ): String {
+        val markerKey = markers.toSortedMap().entries.joinToString("|") { (id, value) ->
+            "$id:${value.first.latitude},${value.first.longitude}"
+        }
+        val polylineKey = polylines.toSortedMap().entries.joinToString("|") { (id, value) ->
+            "$id:" + value.first.joinToString(";") { point -> "${point.latitude},${point.longitude}" }
+        }
+        return "m[$markerKey]p[$polylineKey]"
+    }
+
+    private fun fitToBounds(): Boolean {
+        val map = googleMap ?: return false
+        if (width <= 0 || height <= 0) return false
+        val builder = LatLngBounds.Builder()
+        var count = 0
+        markers.values.forEach { builder.include(it.position); count++ }
+        polylines.values.flatMap { it.points }.forEach { builder.include(it); count++ }
+        if (count == 0) return false
+        post {
+            if (width > 0 && height > 0) {
+                applyMapPadding()
+                val padding = if (pendingProps.has("edgePadding")) 0 else (24 * resources.displayMetrics.density).roundToInt()
+                map.moveCamera(CameraUpdateFactory.newLatLngBounds(builder.build(), padding))
+                applyCameraOrientation()
+            }
+        }
+        return true
+    }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        if (destroyed) return
+        mapView.onStart()
+        mapView.onResume()
+        lifecycleStarted = true
+    }
+
+    override fun onDetachedFromWindow() {
+        if (lifecycleStarted) {
+            mapView.onPause()
+            mapView.onStop()
+            lifecycleStarted = false
+        }
+        super.onDetachedFromWindow()
+    }
+
+    fun destroy() {
+        if (destroyed) return
+        destroyed = true
+        if (lifecycleStarted) {
+            mapView.onPause()
+            mapView.onStop()
+            lifecycleStarted = false
+        }
+        onMarkerTap = null
+        onMapPress = null
+        onRegionChangeComplete = null
+        directionIcon = null
+        pinIcons.clear(); markerPinColors.clear()
+        tileOverlay?.remove(); tileOverlay = null
+        markerHandlers.clear()
+        markers.values.forEach { it.remove() }
+        markers.clear()
+        polylines.values.forEach { it.remove() }
+        polylines.clear()
+        mapView.onDestroy()
+        googleMap = null
+    }
+
+    fun lowMemory() {
+        if (!destroyed) mapView.onLowMemory()
+    }
+
+    private fun hasLocationPermission(): Boolean =
+        ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED ||
+            ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED
+
+    private fun coordinates(geometry: JSONArray?): List<LatLng> {
+        if (geometry == null) return emptyList()
+        return (0 until geometry.length() - 1 step 2).mapNotNull { index ->
+            val latitude = finiteNumber(geometry.opt(index)) ?: return@mapNotNull null
+            val longitude = finiteNumber(geometry.opt(index + 1)) ?: return@mapNotNull null
+            if (latitude.isFinite() && longitude.isFinite() &&
+                latitude >= -90.0 && latitude <= 90.0 &&
+                longitude >= -180.0 && longitude <= 180.0
+            ) LatLng(latitude, longitude) else null
+        }
+    }
+
+    private fun region(value: JSONObject?): LatLngBounds? {
+        val center = value?.optJSONObject("center") ?: return null
+        val span = value.optJSONObject("span") ?: return null
+        val latitude = finiteNumber(center.opt("latitude")) ?: return null
+        val longitude = finiteNumber(center.opt("longitude")) ?: return null
+        val latitudeDelta = finiteNumber(span.opt("latitudeDelta"))
+            ?: finiteNumber(span.opt("latitude_delta"))
+            ?: return null
+        val longitudeDelta = finiteNumber(span.opt("longitudeDelta"))
+            ?: finiteNumber(span.opt("longitude_delta"))
+            ?: return null
+        if (!latitude.isFinite() || !longitude.isFinite() || !latitudeDelta.isFinite() || !longitudeDelta.isFinite() ||
+            latitude < -90.0 || latitude > 90.0 || longitude < -180.0 || longitude > 180.0 ||
+            latitudeDelta <= 0.0 || latitudeDelta > 180.0 ||
+            longitudeDelta <= 0.0 || longitudeDelta > 360.0 ||
+            latitude - latitudeDelta / 2.0 < -90.0 || latitude + latitudeDelta / 2.0 > 90.0
+        ) return null
+        return LatLngBounds(LatLng(latitude - latitudeDelta / 2, longitude - longitudeDelta / 2), LatLng(latitude + latitudeDelta / 2, longitude + longitudeDelta / 2))
+    }
+
+    private fun finiteNumber(value: Any?): Double? =
+        (value as? Number)?.toDouble()?.takeIf { it.isFinite() }
+
+    private fun color(value: String): Int = runCatching { craftNativeColor(value) }.getOrDefault(Color.BLUE)
+}
+