@apexnative/navigation 0.0.0-stage → 1.0.0-alpha.1

package/android/src/main/java/dev/apexnative/navigation/options/params/Fraction.kt

@@ -0,0 +1,12 @@
+package dev.apexnative.navigation.options.params
+
+/**
+ * A number of the options: a size in dp, a radius, an alpha, an index, a duration in milliseconds. Area code
+ * truncates it where its option is a whole number.
+ */
+open class Fraction(value: Double?) : Param<Double>(value)
+
+/** A number the options don't give. */
+class NullFraction : Fraction(null) {
+    override fun hasValue(): Boolean = false
+}

package/android/src/main/java/dev/apexnative/navigation/options/params/LayoutDirection.kt

@@ -0,0 +1,26 @@
+package dev.apexnative.navigation.options.params
+
+import android.view.View
+
+/** `layout.direction`: how a view lays out its children, from the left, from the right or as the language does. */
+enum class LayoutDirection(private val direction: Int) {
+    LTR(View.LAYOUT_DIRECTION_LTR),
+    RTL(View.LAYOUT_DIRECTION_RTL),
+    LOCALE(View.LAYOUT_DIRECTION_LOCALE),
+    DEFAULT(View.LAYOUT_DIRECTION_INHERIT),
+    ;
+
+    /** The direction as [View.setLayoutDirection] takes it. */
+    fun get(): Int = direction
+
+    companion object {
+        /** `ltr`, `rtl`, `locale`; anything else is [DEFAULT]. */
+        @JvmStatic
+        fun fromString(value: String?): LayoutDirection = when (value) {
+            "ltr" -> LTR
+            "rtl" -> RTL
+            "locale" -> LOCALE
+            else -> DEFAULT
+        }
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/options/params/Param.kt

@@ -0,0 +1,24 @@
+package dev.apexnative.navigation.options.params
+
+/**
+ * A value of the options that may be unset: the options give it, or they don't, and the layouts around or the default
+ * options give it then.
+ */
+abstract class Param<T : Any>(@JvmField val value: T?) {
+    /** The options give the value. */
+    open fun hasValue(): Boolean = value != null
+
+    /** The value; only for a value that is set. */
+    fun get(): T = requireNotNull(value) { "the option has no value: check hasValue() first" }
+
+    /** The value, or [defaultValue] when the options don't give it. */
+    fun get(defaultValue: T): T = value ?: defaultValue
+
+    /** The value, or null when the options don't give it. */
+    fun get(@Suppress("UNUSED_PARAMETER") defaultValue: Nothing?): T? = value
+
+    override fun equals(other: Any?): Boolean =
+        other is Param<*> && other.javaClass == javaClass && other.value == value
+
+    override fun hashCode(): Int = value?.hashCode() ?: 0
+}

package/android/src/main/java/dev/apexnative/navigation/options/params/Text.kt

@@ -0,0 +1,24 @@
+package dev.apexnative.navigation.options.params
+
+/** A text of the options: a title, an id, a name, an icon's path, one of the values of an enum. */
+open class Text(value: String?) : Param<String>(value) {
+    /**
+     * The options give `null` for this text: an explicit "no text" that replaces what the layers below give; its value
+     * is the empty text.
+     */
+    open val isNone: Boolean
+        get() = false
+
+    override fun toString(): String = value ?: ""
+}
+
+/** A text the options don't give. */
+class NullText : Text(null) {
+    override fun hasValue(): Boolean = false
+}
+
+/** `null` of a text: set, and no text. */
+class NoneText : Text("") {
+    override val isNone: Boolean
+        get() = true
+}

package/android/src/main/java/dev/apexnative/navigation/options/params/ThemeColour.kt

@@ -0,0 +1,259 @@
+package dev.apexnative.navigation.options.params
+
+import android.content.Context
+import android.content.res.Configuration
+import android.graphics.Color
+import androidx.appcompat.app.AppCompatDelegate
+import com.facebook.react.bridge.ColorPropConverter
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import dev.apexnative.navigation.options.OptionsReader
+import dev.apexnative.navigation.options.has
+import dev.apexnative.navigation.options.opt
+import dev.apexnative.navigation.utils.DevelopmentLog
+import java.util.Collections
+
+/**
+ * A color of the options as JavaScript gives it on Android: a pair `{ light, dark }`, one side for each mode of the
+ * app. A side is a color (ARGB), `'NoColor'` (explicitly no color: the place looks as without the option), a platform
+ * color (`PlatformColor`, its resource paths, resolved again at each [get] so that it follows the theme), or unset (the
+ * layers below give it). [get] takes the side of the mode the app shows now. Immutable: merged colors are new objects,
+ * and one may be shared between options.
+ */
+open class ThemeColour private constructor(
+    private val context: Context?,
+    private val lightSide: Side?,
+    private val darkSide: Side?,
+) {
+    /** A pair of ARGB colors; null leaves a side unset. */
+    constructor(light: Int?, dark: Int?) : this(null, light?.let(Side::Argb), dark?.let(Side::Argb))
+
+    /** One side of a pair. */
+    sealed class Side {
+        /** A color, ARGB. Transparent (alpha 0) is an ordinary color. */
+        data class Argb(val colour: Int) : Side()
+
+        /** `'NoColor'`: the place looks as without the option. */
+        object None : Side()
+
+        /** `PlatformColor`: theme attributes (`?attr/…`) or color resources (`@color/…`); first found. */
+        data class Platform(val paths: List<String>) : Side()
+    }
+
+    /** The options give the color: either side is set, `'NoColor'` included. */
+    open fun hasValue(): Boolean = lightSide != null || darkSide != null
+
+    /** The color of the current mode; [defaultValue] when that side is `'NoColor'` or unset. */
+    open fun get(defaultValue: Int?): Int? = get(context, defaultValue)
+
+    /**
+     * The color of the current mode, platform colors resolved with [context] (an activity's theme); [defaultValue]
+     * when that side is `'NoColor'`, unset, or a platform color that doesn't resolve.
+     */
+    open fun get(context: Context?, defaultValue: Int?): Int? {
+        val themed = context ?: this.context
+        val side = sideOf(isDark(themed))
+        val colour = resolve(side, themed)
+        if (colour == null && side is Side.Platform && themed != null) unresolved(side, themed)
+        return colour ?: defaultValue
+    }
+
+    /**
+     * The color of the current mode; transparent when that side has none ([hasColour]), which is the look of no color
+     * where the option is a background. Never throws.
+     */
+    fun get(): Int = get(null) ?: Color.TRANSPARENT
+
+    /** The side of the current mode gives a color. */
+    fun hasColour(): Boolean = get(null) != null
+
+    /** The side of the current mode is `'NoColor'`. */
+    fun isNoColour(): Boolean = sideOf(isDark(context)) == Side.None
+
+    /** The color of the [dark] or the light side; [defaultValue] as [get] gives it. */
+    fun get(dark: Boolean, defaultValue: Int?): Int? = resolve(sideOf(dark), context) ?: defaultValue
+
+    /** The side of the light or the [dark] mode as the options give it; null when unset. */
+    fun sideOf(dark: Boolean): Side? = if (dark) darkSide else lightSide
+
+    /**
+     * This color with [other] over it, side by side: a side [other] doesn't set stays this one's. A new object; neither
+     * changes.
+     */
+    fun mergeWith(other: ThemeColour): ThemeColour {
+        if (!other.hasValue()) return this
+        if (!hasValue() || (other.lightSide != null && other.darkSide != null)) return other
+        return ThemeColour(other.context ?: context, other.lightSide ?: lightSide, other.darkSide ?: darkSide)
+    }
+
+    /** This color, its unset sides taken from [defaults]. A new object; neither changes. */
+    fun withDefault(defaults: ThemeColour): ThemeColour = defaults.mergeWith(this)
+
+    override fun equals(other: Any?): Boolean =
+        other is ThemeColour && other.lightSide == lightSide && other.darkSide == darkSide
+
+    override fun hashCode(): Int = 31 * (lightSide?.hashCode() ?: 0) + (darkSide?.hashCode() ?: 0)
+
+    override fun toString(): String = "ThemeColour(light=$lightSide, dark=$darkSide)"
+
+    companion object {
+        private const val NO_COLOUR = "NoColor"
+        private const val RESOURCE_PATHS = "resource_paths"
+        private const val ATTRIBUTE_PREFIX = "?"
+        private const val ATTR = "attr"
+        private const val ANDROID = "android"
+        // The platform colors already told of, so each is told once.
+        private val told = Collections.synchronizedSet(HashSet<List<String>>())
+
+        /**
+         * The color of [key] in [parent], in any form JavaScript sends: `{ light, dark }`, a platform color
+         * `{ resource_paths }` (both sides), a number (both sides), `'NoColor'` or `null` (no color, both sides).
+         * Unset when the key is missing; a form it can't read is unset with a warning in development.
+         */
+        @JvmStatic
+        fun parse(context: Context?, parent: ReadableMap?, key: String): ThemeColour {
+            if (parent == null || !parent.has(key)) return NullThemeColour()
+            val path = OptionsReader.pathOf(key)
+            val app = context?.applicationContext ?: context
+            return when (val value = parent.opt(key)) {
+                null -> ThemeColour(app, Side.None, Side.None)
+                is ReadableMap -> parseObject(app, value, path)
+                else -> readSide(app, value, path)?.let { ThemeColour(app, it, it) } ?: NullThemeColour()
+            }
+        }
+
+        /** The color of the object [map]: `{ light, dark }` or `{ resource_paths }`; unset for none. */
+        @JvmStatic
+        fun parse(context: Context?, map: ReadableMap?): ThemeColour {
+            if (map == null) return NullThemeColour()
+            return parseObject(context?.applicationContext ?: context, map, OptionsReader.pathOf("color"))
+        }
+
+        private fun parseObject(context: Context?, map: ReadableMap, path: String): ThemeColour {
+            // An empty object is a pair whose sides JavaScript couldn't read.
+            if (!map.has("light") && !map.has("dark") && map.keySetIterator().hasNextKey()) {
+                val side = readSide(context, map, path) ?: return NullThemeColour()
+                return ThemeColour(context, side, side)
+            }
+            val light = pairSide(context, map, "light", path)
+            val dark = pairSide(context, map, "dark", path)
+            if (light == null && dark == null) return NullThemeColour()
+            return ThemeColour(context, light, dark)
+        }
+
+        // A side of a pair; a missing one is a color JavaScript couldn't read: unset, and a warning.
+        private fun pairSide(context: Context?, map: ReadableMap, side: String, path: String): Side? {
+            if (!map.has(side)) {
+                warn(path, "its $side side is missing: JavaScript could not read the color")
+                return null
+            }
+            return readSide(context, map.opt(side), "$path.$side")
+        }
+
+        // One side: a number, 'NoColor' (null too), a platform color, or another object React Native's converter
+        // reads. What it can't read is unset, with a warning.
+        private fun readSide(context: Context?, value: Any?, path: String): Side? = when (value) {
+            null, NO_COLOUR -> Side.None
+            is Double -> if (value.isFinite()) Side.Argb(value.toLong().toInt()) else unreadable(path, "$value")
+            is ReadableMap -> objectSide(context, value, path)
+            else -> unreadable(path, "$value")
+        }
+
+        private fun objectSide(context: Context?, map: ReadableMap, path: String): Side? {
+            val paths = map.opt(RESOURCE_PATHS)
+            if (paths is ReadableArray) {
+                val names = (0 until paths.size()).mapNotNull { paths.opt(it) as? String }
+                if (names.isEmpty()) return unreadable(path, "a platform color without paths")
+                // Without a context (unit tests) the paths are kept as they are; they resolve at each get.
+                if (context != null && names.none { exists(context, it) }) {
+                    return unreadable(path, "none of the platform colors ${names.joinToString()} exists")
+                }
+                return Side.Platform(names)
+            }
+            if (context == null) return unreadable(path, "an object without a context to convert it")
+            val colour = try {
+                ColorPropConverter.getColor(map, context)
+            } catch (e: Exception) {
+                null
+            }
+            return colour?.let(Side::Argb) ?: unreadable(path, "an object React Native can't convert")
+        }
+
+        private fun unreadable(path: String, what: String): Side? {
+            warn(path, "$what is not a color")
+            return null
+        }
+
+        private fun warn(path: String, why: String) =
+            DevelopmentLog.warn("the option '$path' has a color the navigation can't read: $why")
+
+        // A platform color that resolves with no theme: the parse kept it for an activity's theme, and the activity's
+        // theme doesn't set it either. Told in development, once; the app's own context alone tells nothing, as the
+        // activity's theme may still set it.
+        private fun unresolved(side: Side.Platform, context: Context) {
+            if (context === context.applicationContext || !told.add(side.paths)) return
+            DevelopmentLog.warn(
+                "the platform color ${side.paths.joinToString()} resolves with neither the app's nor the activity's " +
+                    "theme: the default color shows",
+            )
+        }
+
+        // Whether the app has [path]: it resolves with [context] (the app's), or it is a theme attribute the app or
+        // Android declares. An activity's own theme may set an attribute the app's theme doesn't; its value comes at
+        // each get, with the theme of the activity.
+        private fun exists(context: Context, path: String): Boolean {
+            if (resolvePath(context, path) != null) return true
+            val (owner, name) = attributeOf(path) ?: return false
+            return try {
+                val resources = context.resources
+                resources.getIdentifier(name, ATTR, owner ?: context.packageName) != 0 ||
+                    resources.getIdentifier(name, ATTR, ANDROID) != 0
+            } catch (e: RuntimeException) {
+                false
+            }
+        }
+
+        /**
+         * The package (none: the app's) and the name of a theme attribute's path — `?attr/name`, `?name`,
+         * `?package:attr/name` —, as React Native's converter reads it; none for another path.
+         */
+        internal fun attributeOf(path: String): Pair<String?, String>? {
+            if (!path.startsWith(ATTRIBUTE_PREFIX) || path.length <= ATTRIBUTE_PREFIX.length) return null
+            val rest = path.substring(ATTRIBUTE_PREFIX.length).replace("$ATTR/", "")
+            val tokens = rest.split(":")
+            return if (tokens.size > 1) tokens[0] to tokens[1] else null to rest
+        }
+
+        // A platform color's path, resolved with the theme of [context]; none when it doesn't exist or can't be read.
+        private fun resolvePath(context: Context, path: String): Int? = try {
+            ColorPropConverter.resolveResourcePath(context, path)
+        } catch (e: RuntimeException) {
+            null
+        }
+
+        private fun resolve(side: Side?, context: Context?): Int? = when (side) {
+            is Side.Argb -> side.colour
+            is Side.Platform -> context?.let { c -> side.paths.firstNotNullOfOrNull { resolvePath(c, it) } }
+            Side.None, null -> null
+        }
+
+        // The dark side when the app forces night mode, the light one when it forces day, else as the configuration.
+        private fun isDark(context: Context?): Boolean = when (AppCompatDelegate.getDefaultNightMode()) {
+            AppCompatDelegate.MODE_NIGHT_YES -> true
+            AppCompatDelegate.MODE_NIGHT_NO -> false
+            else -> {
+                val mode = context?.resources?.configuration?.uiMode ?: 0
+                (mode and Configuration.UI_MODE_NIGHT_MASK) == Configuration.UI_MODE_NIGHT_YES
+            }
+        }
+    }
+}
+
+/** A color the options don't give. */
+class NullThemeColour : ThemeColour(null, null) {
+    override fun hasValue(): Boolean = false
+
+    override fun get(defaultValue: Int?): Int? = defaultValue
+
+    override fun get(context: Context?, defaultValue: Int?): Int? = defaultValue
+}

package/android/src/main/java/dev/apexnative/navigation/options/params/Variant.kt

@@ -0,0 +1,36 @@
+package dev.apexnative.navigation.options.params
+
+/**
+ * A value whose option takes several forms (`popGesture: boolean | 'edge'`, a button's `badge: number | string |
+ * boolean | null`): a `Boolean`, a `Double` or a `String`, as the option allows (`VariantParser`).
+ */
+open class Variant(value: Any?) : Param<Any>(value) {
+    /** The options give `null` for it, where its option takes `null` as "none" (a badge taken away). */
+    open val isNone: Boolean
+        get() = false
+
+    /** The value when it is a yes or no. */
+    fun asBoolean(): Boolean? = value as? Boolean
+
+    /** The value when it is a number. */
+    fun asNumber(): Double? = value as? Double
+
+    /** The value when it is a text. */
+    fun asText(): String? = value as? String
+}
+
+/** A value the options don't give. */
+class NullVariant : Variant(null) {
+    override fun hasValue(): Boolean = false
+}
+
+/** `null` of a value whose option takes it as "none": set, and neither a yes or no, a number nor a text. */
+class NoneVariant : Variant(NONE) {
+    override val isNone: Boolean
+        get() = true
+
+    private companion object {
+        // What a none holds: nothing area code reads as a value.
+        val NONE = Any()
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/options/parsers/BoolParser.kt

@@ -0,0 +1,15 @@
+package dev.apexnative.navigation.options.parsers
+
+import com.facebook.react.bridge.ReadableMap
+import dev.apexnative.navigation.options.opt
+import dev.apexnative.navigation.options.params.Bool
+import dev.apexnative.navigation.options.params.NullBool
+
+/** Reads a yes or no of the options: `true` or `false` only; anything else, numbers and `null` too, is unset. */
+object BoolParser {
+    @JvmStatic
+    fun parse(map: ReadableMap?, key: String): Bool = when (val value = map?.opt(key)) {
+        is Boolean -> Bool(value)
+        else -> NullBool()
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/options/parsers/FontParser.kt

@@ -0,0 +1,28 @@
+package dev.apexnative.navigation.options.parsers
+
+import com.facebook.react.bridge.ReadableMap
+import dev.apexnative.navigation.options.FontOptions
+
+/**
+ * Reads the font of a text of the options from the text's own object: `fontFamily`, `fontStyle`, `fontWeight`. Its
+ * `fontSize` is a field of the text itself, in sp.
+ */
+object FontParser {
+    /** The values of `fontStyle`. */
+    @JvmField
+    val FONT_STYLES = setOf("normal", "italic")
+
+    /** The values of `fontWeight` (the names of UIKit's weights are iOS's; Android draws them normal). */
+    @JvmField
+    val FONT_WEIGHTS = setOf(
+        "normal", "bold", "100", "200", "300", "400", "500", "600", "700", "800", "900",
+        "ultralight", "thin", "light", "regular", "medium", "semibold", "heavy", "black",
+    )
+
+    @JvmStatic
+    fun parse(map: ReadableMap?): FontOptions = FontOptions(
+        fontFamily = TextParser.parse(map, "fontFamily"),
+        fontStyle = TextParser.parse(map, "fontStyle", FONT_STYLES),
+        fontWeight = TextParser.parse(map, "fontWeight", FONT_WEIGHTS),
+    )
+}

package/android/src/main/java/dev/apexnative/navigation/options/parsers/FractionParser.kt

@@ -0,0 +1,24 @@
+package dev.apexnative.navigation.options.parsers
+
+import com.facebook.react.bridge.ReadableMap
+import dev.apexnative.navigation.options.opt
+import dev.apexnative.navigation.options.params.Fraction
+import dev.apexnative.navigation.options.params.NullFraction
+
+/**
+ * Reads a number of the options: a finite number only; `NaN`, infinity, strings, booleans and `null` are unset.
+ */
+object FractionParser {
+    @JvmStatic
+    fun parse(map: ReadableMap?, key: String): Fraction {
+        val value = map?.opt(key) as? Double ?: return NullFraction()
+        return if (value.isFinite()) Fraction(value) else NullFraction()
+    }
+
+    /** A duration in milliseconds (`duration`, `startDelay`): a number as [parse] reads one, and not below 0. */
+    @JvmStatic
+    fun parseDuration(map: ReadableMap?, key: String): Fraction {
+        val value = parse(map, key)
+        return if (value.get(-1.0) >= 0) value else NullFraction()
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/options/parsers/IconParser.kt

@@ -0,0 +1,48 @@
+package dev.apexnative.navigation.options.parsers
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import dev.apexnative.navigation.options.OptionsReader
+import dev.apexnative.navigation.options.has
+import dev.apexnative.navigation.options.opt
+import dev.apexnative.navigation.options.params.NullText
+import dev.apexnative.navigation.options.params.Text
+import dev.apexnative.navigation.utils.DevelopmentLog
+
+/**
+ * Reads an image of the options as the image loader takes it: the string itself (a drawable of the app by name, a file,
+ * Metro's address in development), the `uri` of an image source, or the Android side of an `{ ios, android }` icon. The
+ * other fields of a source are not read. An icon without an Android side, and `null`, are unset; an array of sources is
+ * unset with an error in development.
+ */
+object IconParser {
+    @JvmStatic
+    fun parse(map: ReadableMap?, key: String): Text = when (val value = map?.opt(key)) {
+        is String -> Text(value)
+        is ReadableMap -> sourceOf(value)
+        is ReadableArray -> {
+            DevelopmentLog.error(
+                "the option '${OptionsReader.pathOf(key)}' gives several image sources: the navigation takes one " +
+                    "source, an object or a string",
+            )
+            NullText()
+        }
+        else -> NullText()
+    }
+
+    private fun sourceOf(icon: ReadableMap): Text {
+        if (icon.has("ios") || icon.has("android")) {
+            return when (val android = icon.opt("android")) {
+                is String -> Text(android)
+                is ReadableMap -> uriOf(android)
+                else -> NullText()
+            }
+        }
+        return uriOf(icon)
+    }
+
+    private fun uriOf(source: ReadableMap): Text {
+        val uri = source.opt("uri") as? String
+        return if (uri.isNullOrEmpty()) NullText() else Text(uri)
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/options/parsers/StringListParser.kt

@@ -0,0 +1,27 @@
+package dev.apexnative.navigation.options.parsers
+
+import com.facebook.react.bridge.ReadableMap
+import dev.apexnative.navigation.options.UnreadableValueException
+import dev.apexnative.navigation.options.opt
+import dev.apexnative.navigation.options.optArray
+
+/**
+ * Reads an array of texts (`safeAreaEdges`, `orientation`, `modifiers`): null when it is missing or isn't an array;
+ * items that aren't strings are dropped, and with [allowed] the unknown values too. `[]` is an empty list, which
+ * replaces what the layers below give.
+ */
+object StringListParser {
+    @JvmStatic
+    @JvmOverloads
+    fun parse(map: ReadableMap?, key: String, allowed: Set<String>? = null): List<String>? {
+        val array = map?.optArray(key) ?: return null
+        return (0 until array.size()).mapNotNull { index ->
+            val item = try {
+                array.opt(index)
+            } catch (e: UnreadableValueException) {
+                throw UnreadableValueException("$key[$index]", e)
+            }
+            (item as? String)?.takeIf { allowed == null || it in allowed }
+        }
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/options/parsers/TextParser.kt

@@ -0,0 +1,32 @@
+package dev.apexnative.navigation.options.parsers
+
+import com.facebook.react.bridge.ReadableMap
+import dev.apexnative.navigation.options.has
+import dev.apexnative.navigation.options.opt
+import dev.apexnative.navigation.options.params.NoneText
+import dev.apexnative.navigation.options.params.NullText
+import dev.apexnative.navigation.options.params.Text
+
+/** Reads a text of the options, or one of the values of an enum. A value of another kind is unset. */
+object TextParser {
+    /** A text: a string; `null` is an explicit "no text" ([NoneText]). */
+    @JvmStatic
+    fun parse(map: ReadableMap?, key: String): Text {
+        if (map == null || !map.has(key)) return NullText()
+        return when (val value = map.opt(key)) {
+            null -> NoneText()
+            is String -> Text(value)
+            else -> NullText()
+        }
+    }
+
+    /**
+     * One of the [allowed] values of an enum; an unknown value, and `null`, are unset: the option's default behavior
+     * holds.
+     */
+    @JvmStatic
+    fun parse(map: ReadableMap?, key: String, allowed: Set<String>): Text {
+        val value = map?.opt(key) as? String ?: return NullText()
+        return if (value in allowed) Text(value) else NullText()
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/options/parsers/TypefaceLoader.kt

@@ -0,0 +1,42 @@
+package dev.apexnative.navigation.options.parsers
+
+import android.content.Context
+import android.graphics.Typeface
+import com.facebook.react.views.text.ReactTypefaceUtils
+
+/**
+ * Makes the typeface of a font of the options as React Native's text makes it: the app's own family from
+ * `assets/fonts/` or React Native's `res/font` registry, else the system family by that name; the weight and the slant
+ * as React Native reads them, also over an own family. A typeface is made once for each family, weight, slant and place
+ * font. Main thread only.
+ */
+class TypefaceLoader(private val context: Context) {
+    /**
+     * The typeface of [fontFamily] with [fontWeight] (`'bold'`, `'100'`…`'900'`) and [fontStyle] (`'italic'`), over
+     * [defaultTypeface] (the place's own) where no family is given.
+     */
+    fun getTypeface(
+        fontFamily: String?,
+        fontWeight: String?,
+        fontStyle: String?,
+        defaultTypeface: Typeface?,
+    ): Typeface {
+        val key = Key(fontFamily, fontWeight, fontStyle, defaultTypeface)
+        return cache.getOrPut(key) {
+            ReactTypefaceUtils.applyStyles(
+                defaultTypeface,
+                ReactTypefaceUtils.parseFontStyle(fontStyle),
+                ReactTypefaceUtils.parseFontWeight(fontWeight),
+                fontFamily,
+                context.assets,
+            )
+        }
+    }
+
+    // A typeface made: its family, weight, slant and the place font it was made over.
+    private data class Key(val family: String?, val weight: String?, val style: String?, val base: Typeface?)
+
+    private companion object {
+        val cache = HashMap<Key, Typeface>()
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/options/parsers/VariantParser.kt

@@ -0,0 +1,34 @@
+package dev.apexnative.navigation.options.parsers
+
+import com.facebook.react.bridge.ReadableMap
+import dev.apexnative.navigation.options.has
+import dev.apexnative.navigation.options.opt
+import dev.apexnative.navigation.options.params.NoneVariant
+import dev.apexnative.navigation.options.params.NullVariant
+import dev.apexnative.navigation.options.params.Variant
+
+/**
+ * Reads a value whose option takes several forms, with the check of the forms its type allows: [booleans] takes
+ * `true` / `false`, [numbers] a finite number, [texts] the strings it names (null: any string), [noneOnNull] takes
+ * `null` as "none" ([NoneVariant]). Any other value is unset.
+ */
+object VariantParser {
+    @JvmStatic
+    fun parse(
+        map: ReadableMap?,
+        key: String,
+        booleans: Boolean = false,
+        numbers: Boolean = false,
+        texts: Set<String>? = emptySet(),
+        noneOnNull: Boolean = false,
+    ): Variant {
+        if (map == null || !map.has(key)) return NullVariant()
+        return when (val value = map.opt(key)) {
+            null -> if (noneOnNull) NoneVariant() else NullVariant()
+            is Boolean -> if (booleans) Variant(value) else NullVariant()
+            is Double -> if (numbers && value.isFinite()) Variant(value) else NullVariant()
+            is String -> if (texts == null || value in texts) Variant(value) else NullVariant()
+            else -> NullVariant()
+        }
+    }
+}