voltra 1.4.1 → 2.0.0-rc.3

package/android/src/main/java/voltra/payload/ComponentTypeID.kt

@@ -1,65 +0,0 @@
-//
-//  ComponentTypeID.kt
-//
-//  AUTO-GENERATED from data/components.json
-//  DO NOT EDIT MANUALLY - Changes will be overwritten
-//  Schema version: 1.0.0
-
-package voltra.payload
-
-/**
- * Component type IDs mapped from data/components.json
- * IDs are assigned sequentially based on order in components.json (0-indexed)
- */
-object ComponentTypeID {
-    const val FILLED_BUTTON = 0
-    const val IMAGE = 1
-    const val SWITCH = 2
-    const val CHECK_BOX = 3
-    const val RADIO_BUTTON = 4
-    const val BOX = 5
-    const val BUTTON = 6
-    const val CIRCLE_ICON_BUTTON = 7
-    const val CIRCULAR_PROGRESS_INDICATOR = 8
-    const val COLUMN = 9
-    const val LAZY_COLUMN = 10
-    const val LAZY_VERTICAL_GRID = 11
-    const val LINEAR_PROGRESS_INDICATOR = 12
-    const val OUTLINE_BUTTON = 13
-    const val ROW = 14
-    const val SCAFFOLD = 15
-    const val SPACER = 16
-    const val SQUARE_ICON_BUTTON = 17
-    const val TEXT = 18
-    const val TITLE_BAR = 19
-    const val CHART = 20
-
-    /**
-     * Get component name from numeric ID
-     */
-    fun getComponentName(id: Int): String? =
-        when (id) {
-            0 -> "AndroidFilledButton"
-            1 -> "AndroidImage"
-            2 -> "AndroidSwitch"
-            3 -> "AndroidCheckBox"
-            4 -> "AndroidRadioButton"
-            5 -> "AndroidBox"
-            6 -> "AndroidButton"
-            7 -> "AndroidCircleIconButton"
-            8 -> "AndroidCircularProgressIndicator"
-            9 -> "AndroidColumn"
-            10 -> "AndroidLazyColumn"
-            11 -> "AndroidLazyVerticalGrid"
-            12 -> "AndroidLinearProgressIndicator"
-            13 -> "AndroidOutlineButton"
-            14 -> "AndroidRow"
-            15 -> "AndroidScaffold"
-            16 -> "AndroidSpacer"
-            17 -> "AndroidSquareIconButton"
-            18 -> "AndroidText"
-            19 -> "AndroidTitleBar"
-            20 -> "AndroidChart"
-            else -> null
-        }
-}

package/android/src/main/java/voltra/styling/JSColorParser.kt

@@ -1,259 +0,0 @@
-package voltra.styling
-
-import android.util.Log
-import androidx.compose.ui.graphics.Color
-
-/**
- * Parses JavaScript color values into Compose Color.
- * Mirrors iOS JSColorParser.swift - supports hex, rgb, rgba, hsl, hsla, and named colors.
- */
-object JSColorParser {
-    private const val TAG = "JSColorParser"
-
-    /**
-     * Parse color value from any format.
-     * Supports: hex (#RGB, #RRGGBB, #RRGGBBAA), rgb/rgba, hsl/hsla, named colors.
-     */
-    fun parse(value: Any?): VoltraColorValue? {
-        val string = value?.toString()?.trim()?.lowercase() ?: return null
-
-        if (string.isEmpty()) return null
-
-        VoltraThemeColorRole.fromToken(string)?.let { role ->
-            return VoltraColorValue.Dynamic(role)
-        }
-
-        // 1. Hex colors (with or without #)
-        if (string.startsWith("#")) {
-            return parseHex(string)?.let { VoltraColorValue.Static(it) }
-        }
-
-        // Check for hex without # prefix (6 or 8 hex digits)
-        if (isHexColor(string)) {
-            return parseHex("#$string")?.let { VoltraColorValue.Static(it) }
-        }
-
-        // 2. RGB/RGBA
-        if (string.startsWith("rgb")) {
-            return parseRGB(string)?.let { VoltraColorValue.Static(it) }
-        }
-
-        // 3. HSL/HSLA
-        if (string.startsWith("hsl")) {
-            return parseHSL(string)?.let { VoltraColorValue.Static(it) }
-        }
-
-        // 4. Named colors
-        return parseNamedColor(string)?.let { VoltraColorValue.Static(it) }
-    }
-
-    /**
-     * Check if string is valid hex color (6 or 8 hex digits).
-     */
-    private fun isHexColor(string: String): Boolean {
-        if (string.length != 6 && string.length != 8) return false
-        return string.all { it in '0'..'9' || it in 'a'..'f' }
-    }
-
-    /**
-     * Parse hex color: #RGB, #RGBA, #RRGGBB, #RRGGBBAA
-     */
-    private fun parseHex(hex: String): Color? {
-        return try {
-            val hexSanitized = hex.removePrefix("#")
-            val length = hexSanitized.length
-
-            val rgb: Long = hexSanitized.toLong(16)
-
-            val (r, g, b, a) =
-                when (length) {
-                    3 -> { // #RGB
-                        val red = ((rgb shr 8) and 0xF) / 15.0
-                        val green = ((rgb shr 4) and 0xF) / 15.0
-                        val blue = (rgb and 0xF) / 15.0
-                        listOf(red, green, blue, 1.0)
-                    }
-
-                    4 -> { // #RGBA
-                        val red = ((rgb shr 12) and 0xF) / 15.0
-                        val green = ((rgb shr 8) and 0xF) / 15.0
-                        val blue = ((rgb shr 4) and 0xF) / 15.0
-                        val alpha = (rgb and 0xF) / 15.0
-                        listOf(red, green, blue, alpha)
-                    }
-
-                    6 -> { // #RRGGBB
-                        val red = ((rgb shr 16) and 0xFF) / 255.0
-                        val green = ((rgb shr 8) and 0xFF) / 255.0
-                        val blue = (rgb and 0xFF) / 255.0
-                        listOf(red, green, blue, 1.0)
-                    }
-
-                    8 -> { // #RRGGBBAA
-                        val red = ((rgb shr 24) and 0xFF) / 255.0
-                        val green = ((rgb shr 16) and 0xFF) / 255.0
-                        val blue = ((rgb shr 8) and 0xFF) / 255.0
-                        val alpha = (rgb and 0xFF) / 255.0
-                        listOf(red, green, blue, alpha)
-                    }
-
-                    else -> {
-                        return null
-                    }
-                }
-
-            Color(
-                red = r.toFloat(),
-                green = g.toFloat(),
-                blue = b.toFloat(),
-                alpha = a.toFloat(),
-            )
-        } catch (e: Exception) {
-            Log.w(TAG, "Failed to parse hex color: $hex", e)
-            null
-        }
-    }
-
-    /**
-     * Parse RGB/RGBA: rgb(255, 0, 0) or rgba(255, 0, 0, 0.5)
-     */
-    private fun parseRGB(string: String): Color? {
-        return try {
-            val cleaned =
-                string
-                    .replace("rgba", "")
-                    .replace("rgb", "")
-                    .replace("(", "")
-                    .replace(")", "")
-                    .replace(" ", "")
-
-            val components = cleaned.split(",")
-            if (components.size < 3) return null
-
-            val r = components[0].toDouble()
-            val g = components[1].toDouble()
-            val b = components[2].toDouble()
-            val a = if (components.size >= 4) components[3].toDouble() else 1.0
-
-            Color(
-                red = (r / 255.0).toFloat(),
-                green = (g / 255.0).toFloat(),
-                blue = (b / 255.0).toFloat(),
-                alpha = a.toFloat(),
-            )
-        } catch (e: Exception) {
-            Log.w(TAG, "Failed to parse RGB color: $string", e)
-            null
-        }
-    }
-
-    /**
-     * Parse HSL/HSLA: hsl(120, 100%, 50%) or hsla(...)
-     */
-    private fun parseHSL(string: String): Color? {
-        return try {
-            val cleaned =
-                string
-                    .replace("hsla", "")
-                    .replace("hsl", "")
-                    .replace("(", "")
-                    .replace(")", "")
-                    .replace(" ", "")
-                    .replace("%", "")
-
-            val components = cleaned.split(",")
-            if (components.size < 3) return null
-
-            val h = (components[0].toDouble()) / 360.0
-            val s = (components[1].toDouble()) / 100.0
-            val l = (components[2].toDouble()) / 100.0
-            val a = if (components.size >= 4) components[3].toDouble() else 1.0
-
-            val (r, g, b) = hslToRgb(h, s, l)
-
-            Color(
-                red = r.toFloat(),
-                green = g.toFloat(),
-                blue = b.toFloat(),
-                alpha = a.toFloat(),
-            )
-        } catch (e: Exception) {
-            Log.w(TAG, "Failed to parse HSL color: $string", e)
-            null
-        }
-    }
-
-    /**
-     * Convert HSL to RGB.
-     * @param h Hue (0.0 to 1.0)
-     * @param s Saturation (0.0 to 1.0)
-     * @param l Lightness (0.0 to 1.0)
-     * @return RGB triple with values from 0.0 to 1.0
-     */
-    private fun hslToRgb(
-        h: Double,
-        s: Double,
-        l: Double,
-    ): Triple<Double, Double, Double> {
-        // Achromatic case (no saturation)
-        if (s == 0.0) {
-            return Triple(l, l, l)
-        }
-
-        val q = if (l < 0.5) l * (1 + s) else l + s - l * s
-        val p = 2 * l - q
-
-        val r = hueToRgb(p, q, h + 1.0 / 3.0)
-        val g = hueToRgb(p, q, h)
-        val b = hueToRgb(p, q, h - 1.0 / 3.0)
-
-        return Triple(r, g, b)
-    }
-
-    /**
-     * Helper function for HSL to RGB conversion.
-     */
-    private fun hueToRgb(
-        p: Double,
-        q: Double,
-        tInput: Double,
-    ): Double {
-        var t = tInput
-        if (t < 0) t += 1
-        if (t > 1) t -= 1
-
-        return when {
-            t < 1.0 / 6.0 -> p + (q - p) * 6 * t
-            t < 1.0 / 2.0 -> q
-            t < 2.0 / 3.0 -> p + (q - p) * (2.0 / 3.0 - t) * 6
-            else -> p
-        }
-    }
-
-    /**
-     * Parse named color strings.
-     * Supports common CSS/React Native color names.
-     */
-    private fun parseNamedColor(name: String): Color? =
-        when (name) {
-            "red" -> Color.Red
-            "orange" -> Color(0xFFFFA500)
-            "yellow" -> Color.Yellow
-            "green" -> Color.Green
-            "mint" -> Color(0xFF00FF7F)
-            "teal" -> Color(0xFF008080)
-            "cyan" -> Color.Cyan
-            "blue" -> Color.Blue
-            "indigo" -> Color(0xFF4B0082)
-            "purple" -> Color(0xFF800080)
-            "pink" -> Color(0xFFFFC0CB)
-            "brown" -> Color(0xFFA52A2A)
-            "white" -> Color.White
-            "gray", "grey" -> Color.Gray
-            "black" -> Color.Black
-            "clear", "transparent" -> Color.Transparent
-            "lightgray", "lightgrey" -> Color.LightGray
-            "darkgray", "darkgrey" -> Color.DarkGray
-            else -> null
-        }
-}

package/android/src/main/java/voltra/styling/JSStyleParser.kt

@@ -1,338 +0,0 @@
-package voltra.styling
-
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.TextUnit
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.glance.text.FontWeight
-
-/**
- * Parses JavaScript style values into Kotlin types.
- * Mirrors iOS JSStyleParser.swift - handles type conversions and fallbacks.
- */
-object JSStyleParser {
-    private const val TAG = "JSStyleParser"
-
-    /**
-     * Parse a number value (Int, Long, Float, Double) to Float.
-     * Returns null if value cannot be converted.
-     */
-    fun number(value: Any?): Float? =
-        when (value) {
-            is Int -> value.toFloat()
-            is Long -> value.toFloat()
-            is Float -> value
-            is Double -> value.toFloat()
-            is String -> value.toFloatOrNull()
-            else -> null
-        }
-
-    /**
-     * Parse a number value to Dp.
-     */
-    fun dp(value: Any?): Dp? = number(value)?.dp
-
-    /**
-     * Parse a number value to sp (for font sizes).
-     */
-    fun sp(value: Any?): TextUnit? = number(value)?.sp
-
-    /**
-     * Parse boolean values with fallback support.
-     */
-    fun boolean(value: Any?): Boolean =
-        when (value) {
-            is Boolean -> value
-            is Int -> value == 1
-            is String -> value.equals("true", ignoreCase = true)
-            else -> false
-        }
-
-    /**
-     * Parse a size object {width: number, height: number}.
-     */
-    fun size(value: Any?): Offset? {
-        if (value !is Map<*, *>) return null
-        val w = number(value["width"]) ?: 0f
-        val h = number(value["height"]) ?: 0f
-        return Offset(w.dp, h.dp)
-    }
-
-    /**
-     * Parse color string (delegates to JSColorParser).
-     */
-    fun color(value: Any?): VoltraColorValue? = JSColorParser.parse(value)
-
-    /**
-     * Parse edge insets using short property names from JS payload.
-     *
-     * Short name mappings:
-     * - padding: pad, pt (top), pb (bottom), pl (left), pr (right), pv (vertical), ph (horizontal)
-     */
-    fun parseInsets(
-        from: Map<String, Any?>,
-        prefix: String,
-    ): EdgeInsets {
-        // Determine the expanded names based on prefix
-        val keys =
-            when (prefix) {
-                "padding" -> {
-                    arrayOf(
-                        "padding",
-                        "paddingTop",
-                        "paddingBottom",
-                        "paddingLeft",
-                        "paddingRight",
-                        "paddingVertical",
-                        "paddingHorizontal",
-                    )
-                }
-
-                "margin" -> {
-                    arrayOf(
-                        "margin",
-                        "marginTop",
-                        "marginBottom",
-                        "marginLeft",
-                        "marginRight",
-                        "marginVertical",
-                        "marginHorizontal",
-                    )
-                }
-
-                else -> {
-                    arrayOf(
-                        prefix,
-                        "${prefix}Top",
-                        "${prefix}Bottom",
-                        "${prefix}Left",
-                        "${prefix}Right",
-                        "${prefix}Vertical",
-                        "${prefix}Horizontal",
-                    )
-                }
-            }
-
-        val allKey = keys[0]
-        val topKey = keys[1]
-        val bottomKey = keys[2]
-        val leftKey = keys[3]
-        val rightKey = keys[4]
-        val verticalKey = keys[5]
-        val horizontalKey = keys[6]
-
-        val all = number(from[allKey]) ?: 0f
-        val v = number(from[verticalKey]) ?: all
-        val h = number(from[horizontalKey]) ?: all
-
-        val top = number(from[topKey]) ?: v
-        val bottom = number(from[bottomKey]) ?: v
-        val leading = number(from[leftKey]) ?: h
-        val trailing = number(from[rightKey]) ?: h
-
-        return EdgeInsets(
-            top = top.dp,
-            leading = leading.dp,
-            bottom = bottom.dp,
-            trailing = trailing.dp,
-        )
-    }
-
-    /**
-     * Parse font weight from string or number.
-     * Maps "bold", "600", "normal" -> FontWeight
-     */
-    fun fontWeight(value: Any?): FontWeight? {
-        val string = value?.toString()?.lowercase() ?: return null
-
-        return when (string) {
-            "bold", "700" -> FontWeight.Bold
-
-            "medium", "500" -> FontWeight.Medium
-
-            "normal", "400", "regular" -> FontWeight.Normal
-
-            // Glance doesn't support these weights, but we map to closest
-            "semibold", "600" -> FontWeight.Bold
-
-            "light", "300" -> FontWeight.Normal
-
-            "thin", "100", "200" -> FontWeight.Normal
-
-            "heavy", "800", "900", "black" -> FontWeight.Bold
-
-            else -> null
-        }
-    }
-
-    /**
-     * Parse text alignment from string.
-     * Maps "center", "right", "justify" -> TextAlignment
-     */
-    fun textAlignment(value: Any?): TextAlignment {
-        val string = value?.toString()?.lowercase() ?: return TextAlignment.START
-
-        return when (string) {
-            "center" -> TextAlignment.CENTER
-            "right", "end" -> TextAlignment.END
-            "left", "start" -> TextAlignment.START
-            else -> TextAlignment.START
-        }
-    }
-
-    /**
-     * Parse text decoration from string.
-     * Supports "underline", "line-through", "strikethrough".
-     */
-    fun textDecoration(value: Any?): TextDecoration {
-        val string = value?.toString()?.lowercase() ?: return TextDecoration.NONE
-
-        val hasUnderline = string.contains("underline")
-        val hasLineThrough = string.contains("line-through") || string.contains("strikethrough")
-
-        return when {
-            hasUnderline && hasLineThrough -> TextDecoration.UNDERLINE_LINE_THROUGH
-            hasUnderline -> TextDecoration.UNDERLINE
-            hasLineThrough -> TextDecoration.LINE_THROUGH
-            else -> TextDecoration.NONE
-        }
-    }
-
-    /**
-     * Parse visibility from generic value.
-     */
-    fun visibility(value: Any?): androidx.glance.Visibility? {
-        val string = value?.toString()?.lowercase() ?: return null
-        return when (string) {
-            "none" -> androidx.glance.Visibility.Gone
-            "hidden", "invisible" -> androidx.glance.Visibility.Invisible
-            "flex", "visible" -> androidx.glance.Visibility.Visible
-            else -> null
-        }
-    }
-
-    /**
-     * Parse overflow behavior.
-     */
-    fun overflow(value: Any?): Overflow? {
-        val string = value?.toString()?.lowercase() ?: return null
-
-        return when (string) {
-            "hidden" -> Overflow.HIDDEN
-            "visible" -> Overflow.VISIBLE
-            else -> null
-        }
-    }
-
-    /**
-     * Parse glass effect (iOS-specific, not supported in Glance).
-     */
-    fun glassEffect(value: Any?): GlassEffect? {
-        val string = value?.toString()?.lowercase() ?: return null
-
-        return when (string) {
-            "clear" -> GlassEffect.CLEAR
-            "identity" -> GlassEffect.IDENTITY
-            "regular" -> GlassEffect.REGULAR
-            "none" -> GlassEffect.NONE
-            else -> null
-        }
-    }
-
-    /**
-     * Parse font variants from array or single string.
-     */
-    fun fontVariant(value: Any?): Set<FontVariant> {
-        val variants = mutableSetOf<FontVariant>()
-
-        when (value) {
-            is List<*> -> {
-                value.forEach { variantString ->
-                    FontVariant
-                        .values()
-                        .find {
-                            it.value == variantString.toString()
-                        }?.let { variants.add(it) }
-                }
-            }
-
-            is String -> {
-                FontVariant
-                    .values()
-                    .find {
-                        it.value == value
-                    }?.let { variants.add(it) }
-            }
-        }
-
-        return variants
-    }
-
-    /**
-     * Parse RN transform array: [{ rotate: '45deg' }, { scale: 1.5 }]
-     * Returns null if no valid transforms found.
-     */
-    fun transform(value: Any?): TransformStyle? {
-        if (value !is List<*>) return null
-
-        var rotate: Float? = null
-        var scale: Float? = null
-        var scaleX: Float? = null
-        var scaleY: Float? = null
-
-        value.forEach { item ->
-            if (item is Map<*, *>) {
-                // Handle rotate: '45deg' or rotate: '0.785rad'
-                item["rotate"]?.let { rotateStr ->
-                    rotate = parseAngle(rotateStr.toString())
-                }
-                item["rotateZ"]?.let { rotateStr ->
-                    rotate = parseAngle(rotateStr.toString())
-                }
-                // Handle scale
-                item["scale"]?.let { scaleValue ->
-                    scale = number(scaleValue)
-                }
-                // Handle scaleX
-                item["scaleX"]?.let { scaleValue ->
-                    scaleX = number(scaleValue)
-                }
-                // Handle scaleY
-                item["scaleY"]?.let { scaleValue ->
-                    scaleY = number(scaleValue)
-                }
-            }
-        }
-
-        // Only return if at least one transform is set
-        return if (rotate != null || scale != null || scaleX != null || scaleY != null) {
-            TransformStyle(rotate, scale, scaleX, scaleY)
-        } else {
-            null
-        }
-    }
-
-    /**
-     * Parse angle string like '45deg' or '0.785rad' to degrees.
-     */
-    private fun parseAngle(value: String): Float? {
-        val trimmed = value.trim()
-
-        return when {
-            trimmed.endsWith("deg") -> {
-                trimmed.dropLast(3).toFloatOrNull()
-            }
-
-            trimmed.endsWith("rad") -> {
-                trimmed.dropLast(3).toFloatOrNull()?.let {
-                    it * 180f / Math.PI.toFloat()
-                }
-            }
-
-            else -> {
-                // Try parsing as plain number (assume degrees)
-                trimmed.toFloatOrNull()
-            }
-        }
-    }
-}