voltra 1.4.1 → 2.0.0-rc.3

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

@@ -1,261 +0,0 @@
-package voltra.styling
-
-import androidx.compose.ui.unit.dp
-
-/**
- * Converts JavaScript style dictionary into structured style objects.
- * Mirrors iOS StyleConverter.swift - parses JS values into typed Kotlin structures.
- */
-object StyleConverter {
-    private const val TAG = "StyleConverter"
-
-    /**
-     * Convert JavaScript style dictionary into structured styles.
-     * Returns CompositeStyle with all style categories parsed.
-     *
-     * Mirrors iOS: StyleConverter.convert(_ js: [String: Any])
-     */
-    fun convert(js: Map<String, Any?>): CompositeStyle =
-        CompositeStyle(
-            layout = parseLayout(js),
-            decoration = parseDecoration(js),
-            rendering = parseRendering(js),
-            text = parseText(js),
-        )
-
-    /**
-     * Parse layout-related styles (dimensions, spacing, flex).
-     * Uses expanded property names after decompression (e.g., "width" for width, "flex" for flex).
-     */
-    private fun parseLayout(js: Map<String, Any?>): LayoutStyle {
-        // Flex logic: RN "flex: 1" implies grow. "flexGrow" is specific.
-        // In Glance, we use weight() modifier for proper flex behavior.
-        // Expanded names: flex, flexGrow
-        val flexVal = JSStyleParser.number(js["flex"]) ?: 0f
-        val flexGrow = JSStyleParser.number(js["flexGrow"]) ?: 0f
-        val finalWeight = maxOf(flexVal, flexGrow)
-        val weight = if (finalWeight > 0f) finalWeight else null
-
-        // Position parsing (left/top -> Offset)
-        // Expanded names: left, top
-        var position: Offset? = null
-        val left = JSStyleParser.dp(js["left"])
-        val top = JSStyleParser.dp(js["top"])
-        if (left != null || top != null) {
-            position = Offset(left ?: 0.dp, top ?: 0.dp)
-        }
-
-        // zIndex: only set if explicitly provided in JS
-        // Expanded name: zIndex
-        val zIndex = JSStyleParser.number(js["zIndex"])
-
-        return LayoutStyle(
-            // Dimensions (width, height, minWidth/maxWidth/minHeight/maxHeight)
-            // Support number (dp), "100%" (fill), "auto" (wrap), or null (wrap)
-            width = parseSizeValue(js["width"]),
-            height = parseSizeValue(js["height"]),
-            minWidth = JSStyleParser.dp(js["minWidth"]),
-            maxWidth = JSStyleParser.dp(js["maxWidth"]),
-            minHeight = JSStyleParser.dp(js["minHeight"]),
-            maxHeight = JSStyleParser.dp(js["maxHeight"]),
-            // Flex Logic (aspectRatio)
-            weight = weight,
-            aspectRatio = JSStyleParser.number(js["aspectRatio"]),
-            // Spacing (padding)
-            padding = JSStyleParser.parseInsets(js, "padding"),
-            // Positioning
-            position = position,
-            zIndex = zIndex,
-            // Visibility logic:
-            // display: 'none' -> Gone (takes no space)
-            // visibility: 'hidden' -> Invisible (hides but takes space)
-            visibility =
-                run {
-                    val d = JSStyleParser.visibility(js["display"])
-                    val v = JSStyleParser.visibility(js["visibility"])
-
-                    when {
-                        d == androidx.glance.Visibility.Gone -> androidx.glance.Visibility.Gone
-                        v == androidx.glance.Visibility.Invisible -> androidx.glance.Visibility.Invisible
-                        else -> d ?: v
-                    }
-                },
-        )
-    }
-
-    /**
-     * Parse size value from JS - can be number (dp), "100%" (fill), or null/auto (wrap).
-     */
-    private fun parseSizeValue(value: Any?): SizeValue? =
-        when (value) {
-            is Number -> {
-                SizeValue.Fixed(value.toFloat().dp)
-            }
-
-            "100%" -> {
-                SizeValue.Fill
-            }
-
-            "auto" -> {
-                SizeValue.Wrap
-            }
-
-            null -> {
-                SizeValue.Wrap
-            }
-
-            else -> {
-                // Try to parse as string percentage or number
-                val str = value.toString()
-                when {
-                    str == "100%" -> {
-                        SizeValue.Fill
-                    }
-
-                    str == "auto" -> {
-                        SizeValue.Wrap
-                    }
-
-                    else -> {
-                        // Try to parse as number
-                        str.toFloatOrNull()?.let { SizeValue.Fixed(it.dp) } ?: SizeValue.Wrap
-                    }
-                }
-            }
-        }
-
-    /**
-     * Parse decoration-related styles (background, border, shadow).
-     * Uses expanded property names after decompression.
-     */
-    private fun parseDecoration(js: Map<String, Any?>): DecorationStyle {
-        // Border Logic (borderWidth, borderColor)
-        var border: BorderStyle? = null
-        val borderWidth = JSStyleParser.dp(js["borderWidth"])
-        if (borderWidth != null && borderWidth.value > 0) {
-            val borderColor =
-                JSStyleParser.color(js["borderColor"])
-                    ?: VoltraColorValue.Static(androidx.compose.ui.graphics.Color.Transparent)
-            border = BorderStyle(borderWidth, borderColor)
-        }
-
-        // Shadow Logic (RN iOS style) - not supported in Glance
-        // Expanded names: shadowRadius, shadowOpacity, shadowOffset, shadowColor
-        var shadow: ShadowStyle? = null
-        val shadowRadius = JSStyleParser.dp(js["shadowRadius"])
-        val shadowOpacity = JSStyleParser.number(js["shadowOpacity"])
-        val shadowOffset = JSStyleParser.size(js["shadowOffset"])
-        val shadowColor = JSStyleParser.color(js["shadowColor"])
-
-        if (shadowRadius != null || shadowOpacity != null || shadowOffset != null || shadowColor != null) {
-            val finalRadius = shadowRadius ?: 0.dp
-            val finalOpacity = shadowOpacity ?: 1.0f
-            val finalOffset = shadowOffset ?: Offset(0.dp, 0.dp)
-            val finalColor = shadowColor ?: VoltraColorValue.Static(androidx.compose.ui.graphics.Color.Black)
-
-            if (finalOpacity > 0) {
-                shadow = ShadowStyle(finalRadius, finalColor, finalOpacity, finalOffset)
-            }
-        }
-
-        // Expanded names: glassEffect, overflow, backgroundColor, borderRadius
-        val glassEffect = JSStyleParser.glassEffect(js["glassEffect"])
-        val overflow = JSStyleParser.overflow(js["overflow"])
-        val clipToOutline = overflow == Overflow.HIDDEN
-
-        return DecorationStyle(
-            backgroundColor = JSStyleParser.color(js["backgroundColor"]),
-            cornerRadius = JSStyleParser.dp(js["borderRadius"]),
-            clipToOutline = clipToOutline,
-            border = border,
-            shadow = shadow,
-            glassEffect = glassEffect,
-            overflow = overflow,
-        )
-    }
-
-    /**
-     * Parse rendering-related styles (opacity, transform).
-     * Uses expanded property names: opacity, transform
-     */
-    private fun parseRendering(js: Map<String, Any?>): RenderingStyle {
-        val opacity = JSStyleParser.number(js["opacity"]) ?: 1.0f
-        return RenderingStyle(
-            opacity = opacity,
-            transform = JSStyleParser.transform(js["transform"]),
-        )
-    }
-
-    /**
-     * Parse text-related styles.
-     * Uses expanded property names after decompression.
-     */
-    private fun parseText(js: Map<String, Any?>): TextStyle {
-        var style = TextStyle.Default
-
-        // Color
-        val color = JSStyleParser.color(js["color"])
-        if (color != null) {
-            style = style.copy(color = color)
-        }
-
-        // Font size
-        val fontSize = JSStyleParser.sp(js["fontSize"])
-        if (fontSize != null) {
-            style = style.copy(fontSize = fontSize)
-        }
-
-        // Line height: CSS lineHeight includes text size. We calculate extra spacing.
-        // Note: Glance has limited line spacing support
-        val lineHeight = JSStyleParser.number(js["lineHeight"])
-        if (lineHeight != null) {
-            val currentFontSize = fontSize?.value ?: 17f
-            val spacing = lineHeight - currentFontSize
-            style = style.copy(lineSpacing = maxOf(0f, spacing).dp)
-        }
-
-        // Font weight
-        val fontWeight = JSStyleParser.fontWeight(js["fontWeight"])
-        if (fontWeight != null) {
-            style = style.copy(fontWeight = fontWeight)
-        }
-
-        // Font family
-        val fontFamily = js["fontFamily"] as? String
-        if (fontFamily != null) {
-            style = style.copy(fontFamily = fontFamily)
-        }
-
-        // Text alignment
-        val textAlign = js["textAlign"]
-        if (textAlign != null) {
-            style = style.copy(alignment = JSStyleParser.textAlignment(textAlign))
-        }
-
-        // Text decoration
-        val decoration = js["textDecorationLine"]
-        if (decoration != null) {
-            style = style.copy(decoration = JSStyleParser.textDecoration(decoration))
-        }
-
-        // Number of lines
-        val numberOfLines = (js["numberOfLines"] as? Number)?.toInt()
-        if (numberOfLines != null) {
-            style = style.copy(lineLimit = numberOfLines)
-        }
-
-        // Letter spacing (not supported in Glance)
-        val letterSpacing = JSStyleParser.dp(js["letterSpacing"])
-        if (letterSpacing != null) {
-            style = style.copy(letterSpacing = letterSpacing)
-        }
-
-        // Font variant (not supported in Glance)
-        val fontVariant = js["fontVariant"]
-        if (fontVariant != null) {
-            style = style.copy(fontVariant = JSStyleParser.fontVariant(fontVariant))
-        }
-
-        return style
-    }
-}

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

@@ -1,336 +0,0 @@
-package voltra.styling
-
-import android.os.Build
-import android.util.Log
-import androidx.compose.runtime.Composable
-import androidx.glance.GlanceModifier
-import androidx.glance.appwidget.cornerRadius
-import androidx.glance.background
-import androidx.glance.layout.*
-import androidx.glance.text.FontFamily
-import androidx.glance.unit.ColorProvider
-import androidx.glance.visibility
-import androidx.glance.text.TextDecoration as GlanceTextDecoration
-import androidx.glance.text.TextStyle as GlanceTextStyle
-
-/**
- * Extension functions to apply structured styles to Glance modifiers.
- * Mirrors iOS View+applyStyle.swift - provides clean interface for style application.
- *
- * Apply composite style to a GlanceModifier.
- * This is the main entry point for applying styles.
- *
- * Order of application (mirrors iOS):
- * 1. Layout (dimensions, flex, padding)
- * 2. Decoration (background, border)
- * 3. Rendering (opacity - limited support)
- *
- * Usage:
- *   GlanceModifier.applyStyle(style)
- */
-@Composable
-fun GlanceModifier.applyStyle(style: CompositeStyle): GlanceModifier {
-    var modifier = this
-
-    // 1. Apply Layout (dimensions, flex, inner padding)
-    modifier = modifier.applyLayout(style.layout)
-
-    // 2. Apply Decoration (background, border)
-    modifier = modifier.applyDecoration(style.decoration)
-
-    // 3. Apply Rendering (opacity - limited in Glance)
-    modifier = modifier.applyRendering(style.rendering)
-
-    return modifier
-}
-
-/**
- * Extension for ROW scope to apply flex/weight modifier.
- * .defaultWeight() and .weight() are only available in RowScope.
- */
-fun RowScope.applyFlex(
-    modifier: GlanceModifier,
-    flex: Float?,
-): GlanceModifier =
-    if (flex != null && flex > 0) {
-        // .defaultWeight() is available here because we are in RowScope
-        modifier.defaultWeight()
-    } else {
-        modifier
-    }
-
-/**
- * Extension for COLUMN scope to apply flex/weight modifier.
- * .defaultWeight() and .weight() are only available in ColumnScope.
- */
-fun ColumnScope.applyFlex(
-    modifier: GlanceModifier,
-    flex: Float?,
-): GlanceModifier =
-    if (flex != null && flex > 0) {
-        // .defaultWeight() is available here because we are in ColumnScope
-        modifier.defaultWeight()
-    } else {
-        modifier
-    }
-
-/**
- * Apply layout styles to modifier.
- * Handles dimensions and inner padding.
- * Note: Weight/Flex is handled separately in RowScope/ColumnScope via applyFlex().
- *
- * Order of application:
- * 1. FillMaxSize optimization (if both width and height are Fill)
- * 2. Width (Fill, Fixed, or Wrap)
- * 3. Height (Fill, Fixed, or Wrap)
- * 4. Padding
- */
-private fun GlanceModifier.applyLayout(layout: LayoutStyle): GlanceModifier {
-    var modifier = this
-
-    // --- PHASE 1: Fill Max Size (Optimization) ---
-    // Check if BOTH are set to Fill (100%) to use the specialized fillMaxSize modifier
-    val isFullWidth = layout.width is SizeValue.Fill
-    val isFullHeight = layout.height is SizeValue.Fill
-
-    if (isFullWidth && isFullHeight) {
-        // Optimization: Use one modifier instead of two
-        modifier = modifier.fillMaxSize()
-    } else {
-        // --- PHASE 3: Width (Fill vs Wrap vs Fixed) ---
-        modifier =
-            when (val width = layout.width) {
-                is SizeValue.Fill -> modifier.fillMaxWidth()
-                is SizeValue.Fixed -> modifier.width(width.value)
-                is SizeValue.Wrap -> modifier.wrapContentWidth()
-                null -> modifier.wrapContentWidth()
-            }
-
-        // --- PHASE 4: Height (Fill vs Wrap vs Fixed) ---
-        modifier =
-            when (val height = layout.height) {
-                is SizeValue.Fill -> modifier.fillMaxHeight()
-                is SizeValue.Fixed -> modifier.height(height.value)
-                is SizeValue.Wrap -> modifier.wrapContentHeight()
-                null -> modifier.wrapContentHeight()
-            }
-    }
-
-    // --- PHASE 5: Min/Max constraints (not supported in Glance - log warning) ---
-    if (layout.minWidth != null ||
-        layout.maxWidth != null ||
-        layout.minHeight != null ||
-        layout.maxHeight != null
-    ) {
-        Log.w(
-            "StyleModifier",
-            "Min/max width/height constraints not supported in Glance widgets",
-        )
-    }
-
-    // --- PHASE 6: Aspect ratio (not supported in Glance) ---
-    if (layout.aspectRatio != null) {
-        Log.w("StyleModifier", "aspectRatio not supported in Glance widgets")
-    }
-
-    // --- PHASE 7: Inner padding (applied after sizing) ---
-    val padding = layout.padding
-    if (padding != null && !padding.isZero()) {
-        modifier =
-            modifier.padding(
-                start = padding.leading,
-                top = padding.top,
-                end = padding.trailing,
-                bottom = padding.bottom,
-            )
-    }
-
-    // --- PHASE 8: Visibility ---
-    if (layout.visibility != null) {
-        modifier = modifier.visibility(layout.visibility)
-    }
-
-    return modifier
-}
-
-/**
- * Apply decoration styles to modifier.
- * Handles background color, corner radius, and borders.
- */
-@Composable
-private fun GlanceModifier.applyDecoration(decoration: DecorationStyle): GlanceModifier {
-    var modifier = this
-
-    // A. Background color
-    if (decoration.backgroundColor != null) {
-        modifier = modifier.background(decoration.backgroundColor.toColorProvider())
-    }
-
-    // B. Corner radius (requires Android 12+/API 31+)
-    if (decoration.cornerRadius != null && decoration.cornerRadius.value > 0) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-            modifier = modifier.cornerRadius(decoration.cornerRadius)
-        } else {
-            Log.w(
-                "StyleModifier",
-                "cornerRadius requires Android 12+ (API 31+), current: ${Build.VERSION.SDK_INT}",
-            )
-        }
-    }
-
-    // C. Border (not yet implemented in Glance)
-    if (decoration.border != null) {
-        Log.w("StyleModifier", "Border styling not yet implemented for Glance widgets")
-        // TODO: Implement using GlanceModifier.border() when available
-    }
-
-    // D. Shadow (not supported in Glance)
-    if (decoration.shadow != null) {
-        Log.w("StyleModifier", "Shadow effects not supported in Glance widgets")
-    }
-
-    // E. Overflow (not supported in Glance)
-    if (decoration.overflow != null) {
-        Log.w("StyleModifier", "Overflow control not supported in Glance widgets")
-    }
-
-    // F. Glass effect (iOS-specific, not supported)
-    if (decoration.glassEffect != null) {
-        Log.w("StyleModifier", "Glass effects not supported in Glance widgets")
-    }
-
-    return modifier
-}
-
-/**
- * Apply rendering styles to modifier.
- * Handles opacity and transforms (limited support in Glance).
- */
-private fun GlanceModifier.applyRendering(rendering: RenderingStyle): GlanceModifier {
-    var modifier = this
-
-    // A. Opacity (Glance doesn't have opacity modifier)
-    // Would need to apply alpha to all colors instead
-    if (rendering.opacity < 1.0f) {
-        Log.w(
-            "StyleModifier",
-            "Opacity modifier not supported in Glance - apply alpha to colors instead",
-        )
-    }
-
-    // B. Transform (not supported in Glance)
-    if (rendering.transform != null) {
-        Log.w("StyleModifier", "Transform effects not supported in Glance widgets")
-    }
-
-    return modifier
-}
-
-/**
- * Convert TextStyle to GlanceTextStyle.
- * Glance has limited text styling compared to SwiftUI.
- */
-@Composable
-fun TextStyle.toGlanceTextStyle(): GlanceTextStyle {
-    var glanceStyle = GlanceTextStyle()
-    val colorProvider = color?.toColorProvider()
-
-    // Font size
-    if (fontSize.value > 0) {
-        glanceStyle = GlanceTextStyle(fontSize = fontSize)
-    }
-
-    // Color
-    if (color != null) {
-        glanceStyle =
-            GlanceTextStyle(
-                fontSize = fontSize,
-                color = colorProvider!!,
-            )
-    }
-
-    // Font weight
-    if (fontWeight != null) {
-        glanceStyle =
-            GlanceTextStyle(
-                fontSize = fontSize,
-                color = colorProvider ?: ColorProvider(androidx.compose.ui.graphics.Color.Unspecified),
-                fontWeight = fontWeight,
-            )
-    }
-
-    // Text decoration (limited support)
-    val glanceDecoration =
-        when (decoration) {
-            TextDecoration.UNDERLINE -> {
-                GlanceTextDecoration.Underline
-            }
-
-            TextDecoration.LINE_THROUGH -> {
-                GlanceTextDecoration.LineThrough
-            }
-
-            TextDecoration.UNDERLINE_LINE_THROUGH -> {
-                Log.w("StyleModifier", "Combined underline + line-through not supported, using underline")
-                GlanceTextDecoration.Underline
-            }
-
-            TextDecoration.NONE -> {
-                null
-            }
-        }
-
-    if (glanceDecoration != null) {
-        glanceStyle =
-            GlanceTextStyle(
-                fontSize = fontSize,
-                color = colorProvider ?: ColorProvider(androidx.compose.ui.graphics.Color.Unspecified),
-                fontWeight = fontWeight,
-                textDecoration = glanceDecoration,
-            )
-    }
-
-    // Text alignment - handled at Text component level, not in TextStyle
-    // Line limit - handled at Text component level
-    // Letter spacing - not supported in Glance
-    // Font variant - not supported in Glance
-
-    // Font family (built-in generic families only; custom fonts require renderAsBitmap)
-    val glanceFontFamily =
-        when (fontFamily) {
-            "monospace" -> FontFamily.Monospace
-            "serif" -> FontFamily.Serif
-            "sans-serif" -> FontFamily.SansSerif
-            "cursive" -> FontFamily.Cursive
-            else -> null
-        }
-    if (glanceFontFamily != null) {
-        glanceStyle =
-            GlanceTextStyle(
-                fontSize = fontSize,
-                color = colorProvider ?: ColorProvider(androidx.compose.ui.graphics.Color.Unspecified),
-                fontWeight = fontWeight,
-                textDecoration = glanceStyle.textDecoration,
-                fontFamily = glanceFontFamily,
-            )
-    }
-
-    if (letterSpacing.value > 0) {
-        Log.w("StyleModifier", "letterSpacing not supported in Glance TextStyle")
-    }
-
-    if (fontVariant.isNotEmpty()) {
-        Log.w("StyleModifier", "fontVariant not supported in Glance TextStyle")
-    }
-
-    return glanceStyle
-}
-
-/**
- * Check if EdgeInsets are all zero.
- */
-private fun EdgeInsets.isZero(): Boolean =
-    top.value == 0f &&
-        leading.value == 0f &&
-        bottom.value == 0f &&
-        trailing.value == 0f