voltra 1.4.1 → 2.0.0-rc.3

package/android/src/main/java/voltra/models/parameters/AndroidSquareIconButtonParameters.kt

@@ -1,28 +0,0 @@
-//
-//  AndroidSquareIconButtonParameters.kt
-//
-//  AUTO-GENERATED from data/components.json
-//  DO NOT EDIT MANUALLY - Changes will be overwritten
-//  Schema version: 1.0.0
-
-package voltra.models.parameters
-
-import kotlinx.serialization.Serializable
-
-/**
- * Parameters for AndroidSquareIconButton component
- * Android Square Icon Button component
- */
-@Serializable
-data class AndroidSquareIconButtonParameters(
-    /** Icon source */
-    val icon: String,
-    /** Accessibility description */
-    val contentDescription: String? = null,
-    /** Whether the button is enabled */
-    val enabled: Boolean? = null,
-    /** Background color */
-    val backgroundColor: String? = null,
-    /** Icon color */
-    val contentColor: String? = null,
-)

package/android/src/main/java/voltra/models/parameters/AndroidSwitchParameters.kt

@@ -1,24 +0,0 @@
-//
-//  AndroidSwitchParameters.kt
-//
-//  AUTO-GENERATED from data/components.json
-//  DO NOT EDIT MANUALLY - Changes will be overwritten
-//  Schema version: 1.0.0
-
-package voltra.models.parameters
-
-import kotlinx.serialization.Serializable
-
-/**
- * Parameters for AndroidSwitch component
- * Android Switch component
- */
-@Serializable
-data class AndroidSwitchParameters(
-    /** Unique identifier for interaction events */
-    val id: String,
-    /** Initial checked state */
-    val checked: Boolean? = null,
-    /** Whether the switch is enabled */
-    val enabled: Boolean? = null,
-)

package/android/src/main/java/voltra/models/parameters/AndroidTextParameters.kt

@@ -1,26 +0,0 @@
-//
-//  AndroidTextParameters.kt
-//
-//  AUTO-GENERATED from data/components.json
-//  DO NOT EDIT MANUALLY - Changes will be overwritten
-//  Schema version: 1.0.0
-
-package voltra.models.parameters
-
-import kotlinx.serialization.Serializable
-
-/**
- * Parameters for AndroidText component
- * Android Text component
- */
-@Serializable
-data class AndroidTextParameters(
-    /** Text content */
-    val text: String,
-    /** Text color */
-    val color: String? = null,
-    /** Font size */
-    val fontSize: Double? = null,
-    /** Maximum lines */
-    val maxLines: Double? = null,
-)

package/android/src/main/java/voltra/models/parameters/AndroidTitleBarParameters.kt

@@ -1,24 +0,0 @@
-//
-//  AndroidTitleBarParameters.kt
-//
-//  AUTO-GENERATED from data/components.json
-//  DO NOT EDIT MANUALLY - Changes will be overwritten
-//  Schema version: 1.0.0
-
-package voltra.models.parameters
-
-import kotlinx.serialization.Serializable
-
-/**
- * Parameters for AndroidTitleBar component
- * Android Title Bar component
- */
-@Serializable
-data class AndroidTitleBarParameters(
-    /** Title text */
-    val title: String,
-    /** Background color */
-    val backgroundColor: String? = null,
-    /** Text color */
-    val contentColor: String? = null,
-)

package/android/src/main/java/voltra/ongoingnotification/AndroidOngoingNotificationPayload.kt

@@ -1,93 +0,0 @@
-package voltra.ongoingnotification
-
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
-
-@Serializable
-data class AndroidOngoingNotificationImageSource(
-    val assetName: String? = null,
-    val base64: String? = null,
-)
-
-@Serializable
-data class AndroidOngoingNotificationProgressSegmentPayload(
-    val length: Int,
-    val color: String? = null,
-)
-
-@Serializable
-data class AndroidOngoingNotificationProgressPointPayload(
-    val position: Int,
-    val color: String? = null,
-)
-
-@Serializable
-data class AndroidOngoingNotificationActionPayload(
-    val title: String,
-    val deepLinkUrl: String,
-    val icon: AndroidOngoingNotificationImageSource? = null,
-)
-
-@Serializable
-sealed class AndroidOngoingNotificationPayload {
-    abstract val v: Int
-    abstract val title: String?
-    abstract val subText: String?
-    abstract val shortCriticalText: String?
-    abstract val chronometer: Boolean?
-    abstract val whenEpochMillis: Long?
-    abstract val largeIcon: AndroidOngoingNotificationImageSource?
-    abstract val actions: List<AndroidOngoingNotificationActionPayload>?
-}
-
-@Serializable
-@SerialName("progress")
-data class AndroidOngoingNotificationProgressPayload(
-    override val v: Int,
-    override val title: String? = null,
-    override val subText: String? = null,
-    val text: String? = null,
-    val value: Int,
-    val max: Int,
-    val indeterminate: Boolean? = null,
-    override val shortCriticalText: String? = null,
-    @SerialName("when")
-    override val whenEpochMillis: Long? = null,
-    override val chronometer: Boolean? = null,
-    override val largeIcon: AndroidOngoingNotificationImageSource? = null,
-    val progressTrackerIcon: AndroidOngoingNotificationImageSource? = null,
-    val progressStartIcon: AndroidOngoingNotificationImageSource? = null,
-    val progressEndIcon: AndroidOngoingNotificationImageSource? = null,
-    val segments: List<AndroidOngoingNotificationProgressSegmentPayload>? = null,
-    val points: List<AndroidOngoingNotificationProgressPointPayload>? = null,
-    override val actions: List<AndroidOngoingNotificationActionPayload>? = null,
-) : AndroidOngoingNotificationPayload()
-
-@Serializable
-@SerialName("bigText")
-data class AndroidOngoingNotificationBigTextPayload(
-    override val v: Int,
-    override val title: String? = null,
-    override val subText: String? = null,
-    val text: String,
-    val bigText: String? = null,
-    override val shortCriticalText: String? = null,
-    @SerialName("when")
-    override val whenEpochMillis: Long? = null,
-    override val chronometer: Boolean? = null,
-    override val largeIcon: AndroidOngoingNotificationImageSource? = null,
-    override val actions: List<AndroidOngoingNotificationActionPayload>? = null,
-) : AndroidOngoingNotificationPayload()
-
-@Serializable
-data class AndroidOngoingNotificationRecord(
-    val notificationId: String,
-    val systemNotificationId: Int,
-    val channelId: String,
-    val smallIcon: String? = null,
-    val deepLinkUrl: String? = null,
-    val requestPromotedOngoing: Boolean = false,
-    val fallbackBehavior: String = "standard",
-    val active: Boolean = true,
-    val dismissed: Boolean = false,
-)

package/android/src/main/java/voltra/ongoingnotification/AndroidOngoingNotificationPayloadParser.kt

@@ -1,13 +0,0 @@
-package voltra.ongoingnotification
-
-import kotlinx.serialization.json.Json
-
-object AndroidOngoingNotificationPayloadParser {
-    private val json =
-        Json {
-            ignoreUnknownKeys = true
-            classDiscriminator = "kind"
-        }
-
-    fun parse(payload: String): AndroidOngoingNotificationPayload = json.decodeFromString(payload)
-}

package/android/src/main/java/voltra/parsing/VoltraDecompressor.kt

@@ -1,156 +0,0 @@
-package voltra.parsing
-
-import android.util.Log
-import voltra.generated.ShortNames
-import voltra.models.VoltraElement
-import voltra.models.VoltraNode
-import voltra.models.VoltraPayload
-
-/**
- * Utility to expand shortened keys in the Voltra payload back to their full names.
- * This should be run as the first step after JSON parsing.
- */
-object VoltraDecompressor {
-    private const val TAG = "VoltraDecompressor"
-
-    /**
-     * Decompress the entire payload recursively.
-     */
-    fun decompress(payload: VoltraPayload): VoltraPayload =
-        payload.copy(
-            collapsed = payload.collapsed?.let { decompressNode(it) },
-            expanded = payload.expanded?.let { decompressNode(it) },
-            variants = payload.variants?.mapValues { decompressNode(it.value) },
-            s = payload.s?.map { decompressMap(it) },
-            e = payload.e?.map { decompressNode(it) },
-        )
-
-    private fun decompressNode(node: VoltraNode): VoltraNode =
-        when (node) {
-            is VoltraNode.Element -> VoltraNode.Element(decompressElement(node.element))
-            is VoltraNode.Array -> VoltraNode.Array(node.elements.map { decompressNode(it) })
-            else -> node // Text and Ref are primitive/don't have keys
-        }
-
-    private fun decompressElement(element: VoltraElement): VoltraElement =
-        element.copy(
-            p = element.p?.let { decompressMap(it) },
-            c = element.c?.let { decompressNode(it) },
-        )
-
-    /**
-     * Recursively decompress a map of props or styles.
-     */
-    @Suppress("UNCHECKED_CAST")
-    private fun decompressMap(map: Map<String, Any?>): Map<String, Any?> {
-        val result = mutableMapOf<String, Any?>()
-
-        for ((key, value) in map) {
-            val expandedKey = ShortNames.expand(key)
-            val expandedValue =
-                when (value) {
-                    is Map<*, *> -> {
-                        val mapValue = value as Map<String, Any?>
-                        // Detect if this is a VoltraElement structure
-                        if (mapValue["t"] is Number) {
-                            Log.d(
-                                TAG,
-                                "decompressMap: Detected element structure in prop '$key' (expanded: '$expandedKey')",
-                            )
-                            decompressElementStructure(mapValue)
-                        } else {
-                            decompressMap(mapValue)
-                        }
-                    }
-
-                    is List<*> -> {
-                        value.map {
-                            when (it) {
-                                is Map<*, *> -> {
-                                    val mapItem = it as Map<String, Any?>
-                                    // Detect elements in lists too
-                                    if (mapItem["t"] is Number) {
-                                        decompressElementStructure(mapItem)
-                                    } else {
-                                        decompressMap(mapItem)
-                                    }
-                                }
-
-                                else -> {
-                                    it
-                                }
-                            }
-                        }
-                    }
-
-                    else -> {
-                        value
-                    }
-                }
-            result[expandedKey] = expandedValue
-        }
-
-        return result
-    }
-
-    /**
-     * Decompress a VoltraElement structure within props without expanding its structure field keys.
-     * Structure keys like "t", "i", "c" are preserved, but nested props and children are processed.
-     */
-    @Suppress("UNCHECKED_CAST")
-    private fun decompressElementStructure(map: Map<String, Any?>): Map<String, Any?> {
-        Log.d(TAG, "decompressElementStructure: Processing element with type=${map["t"]}")
-        val result = map.toMutableMap()
-
-        // Decompress the "p" (props) field - expand prop keys
-        if (map["p"] is Map<*, *>) {
-            val originalProps = map["p"] as Map<String, Any?>
-            Log.d(TAG, "decompressElementStructure: Original props keys: ${originalProps.keys}")
-            val decompressedProps = decompressMap(originalProps)
-            Log.d(TAG, "decompressElementStructure: Decompressed props keys: ${decompressedProps.keys}")
-            result["p"] = decompressedProps
-        }
-
-        // Decompress the "c" (children) field recursively
-        val childValue = map["c"]
-        if (childValue != null) {
-            result["c"] = decompressNodeValue(childValue)
-        }
-
-        return result
-    }
-
-    /**
-     * Decompress a value that represents a VoltraNode (element, array, text, or ref).
-     */
-    @Suppress("UNCHECKED_CAST")
-    private fun decompressNodeValue(value: Any): Any =
-        when (value) {
-            is Map<*, *> -> {
-                val mapValue = value as Map<String, Any?>
-                // Check if it's an element structure
-                if (mapValue["t"] is Number) {
-                    decompressElementStructure(mapValue)
-                } else {
-                    // Could be a ref ($r) or other map - don't expand keys for refs
-                    mapValue
-                }
-            }
-
-            is List<*> -> {
-                // Array of nodes - recursively decompress each item
-                value.map { item ->
-                    if (item != null) {
-                        decompressNodeValue(item)
-                    } else {
-                        item
-                    }
-                }
-            }
-
-            else -> {
-                // Text nodes (strings, numbers) or null - pass through
-                value
-            }
-        }
-}

package/android/src/main/java/voltra/parsing/VoltraPayloadParser.kt

@@ -1,36 +0,0 @@
-package voltra.parsing
-
-import android.util.Log
-import kotlinx.serialization.ExperimentalSerializationApi
-import kotlinx.serialization.decodeFromString
-import kotlinx.serialization.json.Json
-import voltra.models.VoltraPayload
-
-@OptIn(ExperimentalSerializationApi::class)
-object VoltraPayloadParser {
-    private const val TAG = "VoltraPayloadParser"
-
-    private val json =
-        Json {
-            ignoreUnknownKeys = true
-            explicitNulls = false
-        }
-
-    fun parse(jsonString: String): VoltraPayload {
-        Log.d(TAG, "Parsing payload, length=${jsonString.length}")
-        // Log first 500 chars to see the structure
-        Log.d(TAG, "Payload preview: ${jsonString.take(500)}")
-
-        val rawResult = json.decodeFromString<VoltraPayload>(jsonString)
-
-        Log.d(TAG, "Decompressing payload...")
-        val result = VoltraDecompressor.decompress(rawResult)
-
-        Log.d(
-            TAG,
-            "Parsed and decompressed: collapsed=${result.collapsed != null}, expanded=${result.expanded != null}, variants=${result.variants?.keys}",
-        )
-
-        return result
-    }
-}

package/android/src/main/java/voltra/parsing/VoltraSerializers.kt

@@ -1,231 +0,0 @@
-package voltra.parsing
-
-import kotlinx.serialization.KSerializer
-import kotlinx.serialization.SerializationException
-import kotlinx.serialization.builtins.ListSerializer
-import kotlinx.serialization.descriptors.SerialDescriptor
-import kotlinx.serialization.descriptors.buildClassSerialDescriptor
-import kotlinx.serialization.descriptors.element
-import kotlinx.serialization.encoding.Decoder
-import kotlinx.serialization.encoding.Encoder
-import kotlinx.serialization.json.Json
-import kotlinx.serialization.json.JsonArray
-import kotlinx.serialization.json.JsonDecoder
-import kotlinx.serialization.json.JsonElement
-import kotlinx.serialization.json.JsonEncoder
-import kotlinx.serialization.json.JsonNull
-import kotlinx.serialization.json.JsonObject
-import kotlinx.serialization.json.JsonPrimitive
-import kotlinx.serialization.json.booleanOrNull
-import kotlinx.serialization.json.decodeFromJsonElement
-import kotlinx.serialization.json.doubleOrNull
-import kotlinx.serialization.json.encodeToJsonElement
-import kotlinx.serialization.json.intOrNull
-import kotlinx.serialization.json.jsonPrimitive
-import kotlinx.serialization.json.longOrNull
-import voltra.models.VoltraElement
-import voltra.models.VoltraNode
-
-object VoltraNodeSerializer : KSerializer<VoltraNode> {
-    override val descriptor: SerialDescriptor =
-        buildClassSerialDescriptor("voltra.models.VoltraNode") {
-            element<String>("shape")
-        }
-
-    override fun deserialize(decoder: Decoder): VoltraNode {
-        val jsonDecoder = decoder as? JsonDecoder ?: error("VoltraNodeSerializer only supports JSON")
-        return jsonDecoder.decodeJsonElement().toVoltraNode(jsonDecoder.json)
-    }
-
-    override fun serialize(
-        encoder: Encoder,
-        value: VoltraNode,
-    ) {
-        val jsonEncoder = encoder as? JsonEncoder ?: error("VoltraNodeSerializer only supports JSON")
-        val jsonElement =
-            when (value) {
-                is VoltraNode.Text -> JsonPrimitive(value.text)
-                is VoltraNode.Array -> JsonArray(value.elements.map { toJsonElement(jsonEncoder.json, it) })
-                is VoltraNode.Ref -> JsonObject(mapOf("\$r" to JsonPrimitive(value.ref)))
-                is VoltraNode.Element -> jsonEncoder.json.encodeToJsonElement(VoltraElement.serializer(), value.element)
-            }
-        jsonEncoder.encodeJsonElement(jsonElement)
-    }
-}
-
-object DynamicObjectSerializer : KSerializer<Map<String, Any?>> {
-    override val descriptor: SerialDescriptor =
-        buildClassSerialDescriptor("voltra.parsing.DynamicObject")
-
-    override fun deserialize(decoder: Decoder): Map<String, Any?> {
-        val jsonDecoder = decoder as? JsonDecoder ?: error("DynamicObjectSerializer only supports JSON")
-        val element = jsonDecoder.decodeJsonElement()
-        return element.toDynamicObject()
-    }
-
-    override fun serialize(
-        encoder: Encoder,
-        value: Map<String, Any?>,
-    ) {
-        val jsonEncoder = encoder as? JsonEncoder ?: error("DynamicObjectSerializer only supports JSON")
-        jsonEncoder.encodeJsonElement(toJsonElement(jsonEncoder.json, value))
-    }
-}
-
-object DynamicObjectListSerializer : KSerializer<List<Map<String, Any?>>> {
-    private val delegate = ListSerializer(DynamicObjectSerializer)
-
-    override val descriptor: SerialDescriptor = delegate.descriptor
-
-    override fun deserialize(decoder: Decoder): List<Map<String, Any?>> = delegate.deserialize(decoder)
-
-    override fun serialize(
-        encoder: Encoder,
-        value: List<Map<String, Any?>>,
-    ) {
-        delegate.serialize(encoder, value)
-    }
-}
-
-internal fun JsonElement.toVoltraNode(json: Json): VoltraNode =
-    when (this) {
-        is JsonPrimitive -> {
-            if (isString) {
-                VoltraNode.Text(content)
-            } else {
-                throw SerializationException("Unsupported VoltraNode primitive: $this")
-            }
-        }
-
-        is JsonArray -> {
-            VoltraNode.Array(map { it.toVoltraNode(json) })
-        }
-
-        is JsonObject -> {
-            when {
-                "\$r" in this -> {
-                    val ref =
-                        this.getValue("\$r").jsonPrimitive.intOrNull
-                            ?: throw SerializationException("VoltraNode ref must be an integer: $this")
-                    VoltraNode.Ref(ref)
-                }
-
-                "t" in this -> {
-                    VoltraNode.Element(json.decodeFromJsonElement(VoltraElement.serializer(), this))
-                }
-
-                else -> {
-                    throw SerializationException("Unsupported VoltraNode shape: $this")
-                }
-            }
-        }
-    }
-
-internal fun JsonElement.toDynamicValue(): Any? =
-    when (this) {
-        JsonNull -> {
-            null
-        }
-
-        is JsonObject -> {
-            toDynamicObject()
-        }
-
-        is JsonArray -> {
-            map { it.toDynamicValue() }
-        }
-
-        is JsonPrimitive -> {
-            when {
-                isString -> content
-                booleanOrNull != null -> booleanOrNull
-                intOrNull != null -> intOrNull
-                longOrNull != null -> longOrNull
-                doubleOrNull != null -> doubleOrNull
-                else -> throw SerializationException("Unsupported JSON primitive: $this")
-            }
-        }
-    }
-
-internal fun JsonElement.toDynamicObject(): Map<String, Any?> {
-    val jsonObject =
-        this as? JsonObject
-            ?: throw SerializationException("Expected JSON object but found: $this")
-    return linkedMapOf<String, Any?>().apply {
-        jsonObject.forEach { (key, value) ->
-            put(key, value.toDynamicValue())
-        }
-    }
-}
-
-private fun toJsonElement(
-    json: Json,
-    value: Any?,
-): JsonElement =
-    when (value) {
-        null -> {
-            JsonNull
-        }
-
-        is VoltraNode -> {
-            toJsonElement(json, value)
-        }
-
-        is Map<*, *> -> {
-            JsonObject(
-                value.entries.associate { (key, itemValue) ->
-                    val stringKey =
-                        key as? String
-                            ?: throw SerializationException("Dynamic object keys must be strings: $key")
-                    stringKey to toJsonElement(json, itemValue)
-                },
-            )
-        }
-
-        is List<*> -> {
-            JsonArray(value.map { toJsonElement(json, it) })
-        }
-
-        is String -> {
-            JsonPrimitive(value)
-        }
-
-        is Boolean -> {
-            JsonPrimitive(value)
-        }
-
-        is Int -> {
-            JsonPrimitive(value)
-        }
-
-        is Long -> {
-            JsonPrimitive(value)
-        }
-
-        is Float -> {
-            JsonPrimitive(value)
-        }
-
-        is Double -> {
-            JsonPrimitive(value)
-        }
-
-        is Number -> {
-            JsonPrimitive(value.toDouble())
-        }
-
-        else -> {
-            throw SerializationException("Unsupported dynamic value type: ${value::class.qualifiedName}")
-        }
-    }
-
-private fun toJsonElement(
-    json: Json,
-    node: VoltraNode,
-): JsonElement =
-    when (node) {
-        is VoltraNode.Text -> JsonPrimitive(node.text)
-        is VoltraNode.Array -> JsonArray(node.elements.map { toJsonElement(json, it) })
-        is VoltraNode.Ref -> JsonObject(mapOf("\$r" to JsonPrimitive(node.ref)))
-        is VoltraNode.Element -> json.encodeToJsonElement(VoltraElement.serializer(), node.element)
-    }