@thelacanians/vue-native-cli 0.4.12 → 0.4.13

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Styling/StyleEngine.kt

@@ -62,10 +62,22 @@ object StyleEngine {
                 val bg = ensureBackground(view)
                 val radii = bg.cornerRadii ?: FloatArray(8) { 0f }
                 when (key) {
-                    "borderTopLeftRadius"     -> { radii[0] = px; radii[1] = px }
-                    "borderTopRightRadius"    -> { radii[2] = px; radii[3] = px }
-                    "borderBottomRightRadius" -> { radii[4] = px; radii[5] = px }
-                    "borderBottomLeftRadius"  -> { radii[6] = px; radii[7] = px }
+                    "borderTopLeftRadius" -> {
+                        radii[0] = px
+                        radii[1] = px
+                    }
+                    "borderTopRightRadius" -> {
+                        radii[2] = px
+                        radii[3] = px
+                    }
+                    "borderBottomRightRadius" -> {
+                        radii[4] = px
+                        radii[5] = px
+                    }
+                    "borderBottomLeftRadius" -> {
+                        radii[6] = px
+                        radii[7] = px
+                    }
                 }
                 bg.cornerRadii = radii
                 view.background = view.background
@@ -124,37 +136,52 @@ object StyleEngine {
             }
 
             // --- Margin (stored in FlexProps, applied when inserted into parent) ---
-            "margin" -> updateFlexProps(view) { fp -> val px = dpToPx(ctx, toFloat(value, 0f)).toInt(); fp.copy(marginLeft = px, marginTop = px, marginRight = px, marginBottom = px) }
-            "marginHorizontal" -> updateFlexProps(view) { fp -> val px = dpToPx(ctx, toFloat(value, 0f)).toInt(); fp.copy(marginLeft = px, marginRight = px) }
-            "marginVertical"   -> updateFlexProps(view) { fp -> val px = dpToPx(ctx, toFloat(value, 0f)).toInt(); fp.copy(marginTop = px, marginBottom = px) }
-            "marginLeft"       -> updateFlexProps(view) { fp -> fp.copy(marginLeft = dpToPx(ctx, toFloat(value, 0f)).toInt()) }
-            "marginRight"      -> updateFlexProps(view) { fp -> fp.copy(marginRight = dpToPx(ctx, toFloat(value, 0f)).toInt()) }
-            "marginTop"        -> updateFlexProps(view) { fp -> fp.copy(marginTop = dpToPx(ctx, toFloat(value, 0f)).toInt()) }
-            "marginBottom"     -> updateFlexProps(view) { fp -> fp.copy(marginBottom = dpToPx(ctx, toFloat(value, 0f)).toInt()) }
-            "marginStart"      -> updateFlexProps(view) { fp -> fp.copy(marginStart = dpToPx(ctx, toFloat(value, 0f)).toInt()) }
-            "marginEnd"        -> updateFlexProps(view) { fp -> fp.copy(marginEnd = dpToPx(ctx, toFloat(value, 0f)).toInt()) }
+            "margin" -> updateFlexProps(view) { fp ->
+                val px = dpToPx(ctx, toFloat(value, 0f)).toInt()
+                fp.copy(marginLeft = px, marginTop = px, marginRight = px, marginBottom = px)
+            }
+            "marginHorizontal" -> updateFlexProps(view) { fp ->
+                val px = dpToPx(ctx, toFloat(value, 0f)).toInt()
+                fp.copy(marginLeft = px, marginRight = px)
+            }
+            "marginVertical" -> updateFlexProps(view) { fp ->
+                val px = dpToPx(ctx, toFloat(value, 0f)).toInt()
+                fp.copy(marginTop = px, marginBottom = px)
+            }
+            "marginLeft" -> updateFlexProps(view) { fp -> fp.copy(marginLeft = dpToPx(ctx, toFloat(value, 0f)).toInt()) }
+            "marginRight" -> updateFlexProps(view) { fp -> fp.copy(marginRight = dpToPx(ctx, toFloat(value, 0f)).toInt()) }
+            "marginTop" -> updateFlexProps(view) { fp -> fp.copy(marginTop = dpToPx(ctx, toFloat(value, 0f)).toInt()) }
+            "marginBottom" -> updateFlexProps(view) { fp -> fp.copy(marginBottom = dpToPx(ctx, toFloat(value, 0f)).toInt()) }
+            "marginStart" -> updateFlexProps(view) { fp -> fp.copy(marginStart = dpToPx(ctx, toFloat(value, 0f)).toInt()) }
+            "marginEnd" -> updateFlexProps(view) { fp -> fp.copy(marginEnd = dpToPx(ctx, toFloat(value, 0f)).toInt()) }
 
             // --- Dimensions ---
             "width" -> {
                 val pct = parsePercent(value)
-                if (pct != null) updateFlexProps(view) { fp -> fp.copy(width = ViewGroup.LayoutParams.WRAP_CONTENT, widthPercent = pct) }
-                else updateFlexProps(view) { fp -> fp.copy(width = parseDimension(ctx, value), widthPercent = -1f) }
+                if (pct != null) {
+                    updateFlexProps(view) { fp -> fp.copy(width = ViewGroup.LayoutParams.WRAP_CONTENT, widthPercent = pct) }
+                } else {
+                    updateFlexProps(view) { fp -> fp.copy(width = parseDimension(ctx, value), widthPercent = -1f) }
+                }
             }
             "height" -> {
                 val pct = parsePercent(value)
-                if (pct != null) updateFlexProps(view) { fp -> fp.copy(height = ViewGroup.LayoutParams.WRAP_CONTENT, heightPercent = pct) }
-                else updateFlexProps(view) { fp -> fp.copy(height = parseDimension(ctx, value), heightPercent = -1f) }
+                if (pct != null) {
+                    updateFlexProps(view) { fp -> fp.copy(height = ViewGroup.LayoutParams.WRAP_CONTENT, heightPercent = pct) }
+                } else {
+                    updateFlexProps(view) { fp -> fp.copy(height = parseDimension(ctx, value), heightPercent = -1f) }
+                }
             }
-            "minWidth"  -> updateFlexProps(view) { fp -> fp.copy(minWidth = dpToPx(ctx, toFloat(value, 0f)).toInt()) }
+            "minWidth" -> updateFlexProps(view) { fp -> fp.copy(minWidth = dpToPx(ctx, toFloat(value, 0f)).toInt()) }
             "minHeight" -> updateFlexProps(view) { fp -> fp.copy(minHeight = dpToPx(ctx, toFloat(value, 0f)).toInt()) }
-            "maxWidth"  -> updateFlexProps(view) { fp -> fp.copy(maxWidth = dpToPx(ctx, toFloat(value, 0f)).toInt()) }
+            "maxWidth" -> updateFlexProps(view) { fp -> fp.copy(maxWidth = dpToPx(ctx, toFloat(value, 0f)).toInt()) }
 
             // --- Flex props (stored in FlexProps, applied when inserted) ---
             "flex" -> {
                 val f = toFloat(value, 0f)
                 updateFlexProps(view) { fp -> fp.copy(flexGrow = f, flexShrink = 1f, width = 0, height = 0) }
             }
-            "flexGrow"   -> updateFlexProps(view) { fp -> fp.copy(flexGrow = toFloat(value, 0f)) }
+            "flexGrow" -> updateFlexProps(view) { fp -> fp.copy(flexGrow = toFloat(value, 0f)) }
             "flexShrink" -> updateFlexProps(view) { fp -> fp.copy(flexShrink = toFloat(value, 1f)) }
             "flexBasis" -> {
                 if (value == "auto" || value == null) {
@@ -170,8 +197,8 @@ object StyleEngine {
                     }
                 }
             }
-            "alignSelf"  -> updateFlexProps(view) { fp -> fp.copy(alignSelf = parseAlignSelf(value)) }
-            "order"      -> updateFlexProps(view) { fp -> fp.copy(order = toInt(value, 1)) }
+            "alignSelf" -> updateFlexProps(view) { fp -> fp.copy(alignSelf = parseAlignSelf(value)) }
+            "order" -> updateFlexProps(view) { fp -> fp.copy(order = toInt(value, 1)) }
 
             // --- Parent Flex props (applied to FlexboxLayout itself) ---
             "flexDirection" -> {
@@ -281,8 +308,11 @@ object StyleEngine {
                 view.visibility = if (value == "none") View.GONE else View.VISIBLE
             }
             "visible" -> {
-                if (value == false || value == "false") view.visibility = View.INVISIBLE
-                else view.visibility = View.VISIBLE
+                if (value == false || value == "false") {
+                    view.visibility = View.INVISIBLE
+                } else {
+                    view.visibility = View.VISIBLE
+                }
             }
             "hidden" -> {
                 view.visibility = if (value == true || value == "true") View.INVISIBLE else View.VISIBLE
@@ -332,15 +362,15 @@ object StyleEngine {
                     override fun onInitializeAccessibilityNodeInfo(host: View, info: AccessibilityNodeInfoCompat) {
                         super.onInitializeAccessibilityNodeInfo(host, info)
                         when (role) {
-                            "button"     -> info.className = "android.widget.Button"
-                            "link"       -> info.addAction(AccessibilityNodeInfoCompat.AccessibilityActionCompat.ACTION_CLICK)
-                            "header"     -> info.isHeading = true
-                            "image"      -> info.className = "android.widget.ImageView"
-                            "text"       -> info.className = "android.widget.TextView"
-                            "search"     -> info.className = "android.widget.EditText"
+                            "button" -> info.className = "android.widget.Button"
+                            "link" -> info.addAction(AccessibilityNodeInfoCompat.AccessibilityActionCompat.ACTION_CLICK)
+                            "header" -> info.isHeading = true
+                            "image" -> info.className = "android.widget.ImageView"
+                            "text" -> info.className = "android.widget.TextView"
+                            "search" -> info.className = "android.widget.EditText"
                             "adjustable" -> info.className = "android.widget.SeekBar"
-                            "tab"        -> info.roleDescription = "tab"
-                            "none"       -> { /* no special role */ }
+                            "tab" -> info.roleDescription = "tab"
+                            "none" -> { /* no special role */ }
                         }
                     }
                 })
@@ -363,13 +393,16 @@ object StyleEngine {
                 view.importantForAccessibility = View.IMPORTANT_FOR_ACCESSIBILITY_YES
             }
             "accessible" -> view.importantForAccessibility =
-                if (value == true) View.IMPORTANT_FOR_ACCESSIBILITY_YES
-                else View.IMPORTANT_FOR_ACCESSIBILITY_NO
+                if (value == true) {
+                    View.IMPORTANT_FOR_ACCESSIBILITY_YES
+                } else {
+                    View.IMPORTANT_FOR_ACCESSIBILITY_NO
+                }
             "importantForAccessibility" -> {
                 view.importantForAccessibility = when (value) {
                     "auto" -> View.IMPORTANT_FOR_ACCESSIBILITY_AUTO
-                    "yes"  -> View.IMPORTANT_FOR_ACCESSIBILITY_YES
-                    "no"   -> View.IMPORTANT_FOR_ACCESSIBILITY_NO
+                    "yes" -> View.IMPORTANT_FOR_ACCESSIBILITY_YES
+                    "no" -> View.IMPORTANT_FOR_ACCESSIBILITY_NO
                     "no-hide-descendants" -> View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS
                     else -> View.IMPORTANT_FOR_ACCESSIBILITY_AUTO
                 }
@@ -390,23 +423,28 @@ object StyleEngine {
             "fontWeight" -> {
                 val current = tv.typeface ?: android.graphics.Typeface.DEFAULT
                 tv.setTypeface(current,
-                    if (value == "bold" || (value as? Number)?.toInt() ?: 0 >= 600)
+                    if (value == "bold" || (value as? Number)?.toInt() ?: 0 >= 600) {
                         android.graphics.Typeface.BOLD
-                    else android.graphics.Typeface.NORMAL
+                    } else {
+                        android.graphics.Typeface.NORMAL
+                    }
                 )
             }
             "fontStyle" -> {
                 val current = tv.typeface ?: android.graphics.Typeface.DEFAULT
                 tv.setTypeface(current,
-                    if (value == "italic") android.graphics.Typeface.ITALIC
-                    else android.graphics.Typeface.NORMAL
+                    if (value == "italic") {
+                        android.graphics.Typeface.ITALIC
+                    } else {
+                        android.graphics.Typeface.NORMAL
+                    }
                 )
             }
             "textAlign" -> tv.textAlignment = when (value) {
                 "center" -> View.TEXT_ALIGNMENT_CENTER
-                "right"  -> View.TEXT_ALIGNMENT_VIEW_END
-                "left"   -> View.TEXT_ALIGNMENT_VIEW_START
-                else     -> View.TEXT_ALIGNMENT_INHERIT
+                "right" -> View.TEXT_ALIGNMENT_VIEW_END
+                "left" -> View.TEXT_ALIGNMENT_VIEW_START
+                else -> View.TEXT_ALIGNMENT_INHERIT
             }
             "lineHeight" -> {
                 val px = dpToPx(ctx, toFloat(value, 0f))
@@ -419,20 +457,20 @@ object StyleEngine {
             }
             "textDecorationLine" -> {
                 tv.paintFlags = when (value) {
-                    "underline"    -> tv.paintFlags or android.graphics.Paint.UNDERLINE_TEXT_FLAG
+                    "underline" -> tv.paintFlags or android.graphics.Paint.UNDERLINE_TEXT_FLAG
                     "line-through" -> tv.paintFlags or android.graphics.Paint.STRIKE_THRU_TEXT_FLAG
-                    "none"         -> (tv.paintFlags and android.graphics.Paint.UNDERLINE_TEXT_FLAG.inv()
+                    "none" -> (tv.paintFlags and android.graphics.Paint.UNDERLINE_TEXT_FLAG.inv()
                                                and android.graphics.Paint.STRIKE_THRU_TEXT_FLAG.inv())
-                    else           -> tv.paintFlags
+                    else -> tv.paintFlags
                 }
             }
             "textTransform" -> {
                 val t = tv.text?.toString() ?: ""
                 tv.text = when (value) {
-                    "uppercase"  -> t.uppercase()
-                    "lowercase"  -> t.lowercase()
+                    "uppercase" -> t.uppercase()
+                    "lowercase" -> t.lowercase()
                     "capitalize" -> t.split(" ").joinToString(" ") { it.replaceFirstChar(Char::uppercase) }
-                    else         -> t
+                    else -> t
                 }
             }
             "numberOfLines" -> {
@@ -528,7 +566,9 @@ object StyleEngine {
                 s == "gray" || s == "grey" -> Color.GRAY
                 else -> Color.parseColor(s)
             }
-        } catch (e: Exception) { null }
+        } catch (e: Exception) {
+            null
+        }
     }
 
     // -- Dimension helpers --------------------------------------------------------
@@ -546,8 +586,11 @@ object StyleEngine {
             value is String && value.endsWith("%") -> {
                 // 100% maps to MATCH_PARENT; other percentages are handled via widthPercent/heightPercent
                 // in the "width"/"height" cases above — this fallback covers minWidth/minHeight
-                if (value == "100%") ViewGroup.LayoutParams.MATCH_PARENT
-                else ViewGroup.LayoutParams.WRAP_CONTENT
+                if (value == "100%") {
+                    ViewGroup.LayoutParams.MATCH_PARENT
+                } else {
+                    ViewGroup.LayoutParams.WRAP_CONTENT
+                }
             }
             value == "auto" || value == null -> ViewGroup.LayoutParams.WRAP_CONTENT
             else -> dpToPx(context, toFloat(value, 0f)).toInt()
@@ -564,20 +607,20 @@ object StyleEngine {
 
     fun toFloat(value: Any?, default: Float): Float = when (value) {
         is Double -> value.toFloat()
-        is Float  -> value
-        is Int    -> value.toFloat()
-        is Long   -> value.toFloat()
+        is Float -> value
+        is Int -> value.toFloat()
+        is Long -> value.toFloat()
         is String -> value.toFloatOrNull() ?: default
-        else      -> default
+        else -> default
     }
 
     fun toInt(value: Any?, default: Int): Int = when (value) {
-        is Int    -> value
+        is Int -> value
         is Double -> value.toInt()
-        is Float  -> value.toInt()
-        is Long   -> value.toInt()
+        is Float -> value.toInt()
+        is Long -> value.toInt()
         is String -> value.toIntOrNull() ?: default
-        else      -> default
+        else -> default
     }
 
     // -- GradientDrawable management ----------------------------------------------
@@ -593,51 +636,51 @@ object StyleEngine {
     // -- Flex enum parsing --------------------------------------------------------
 
     private fun parseFlexDirection(value: Any?) = when (value) {
-        "row"            -> FlexDirection.ROW
-        "row-reverse"    -> FlexDirection.ROW_REVERSE
+        "row" -> FlexDirection.ROW
+        "row-reverse" -> FlexDirection.ROW_REVERSE
         "column-reverse" -> FlexDirection.COLUMN_REVERSE
-        else             -> FlexDirection.COLUMN
+        else -> FlexDirection.COLUMN
     }
 
     private fun parseFlexWrap(value: Any?) = when (value) {
-        "wrap"         -> FlexWrap.WRAP
+        "wrap" -> FlexWrap.WRAP
         "wrap-reverse" -> FlexWrap.WRAP_REVERSE
-        else           -> FlexWrap.NOWRAP
+        else -> FlexWrap.NOWRAP
     }
 
     private fun parseAlignItems(value: Any?) = when (value) {
         "flex-start" -> AlignItems.FLEX_START
-        "flex-end"   -> AlignItems.FLEX_END
-        "center"     -> AlignItems.CENTER
-        "baseline"   -> AlignItems.BASELINE
-        else         -> AlignItems.STRETCH
+        "flex-end" -> AlignItems.FLEX_END
+        "center" -> AlignItems.CENTER
+        "baseline" -> AlignItems.BASELINE
+        else -> AlignItems.STRETCH
     }
 
     private fun parseAlignContent(value: Any?) = when (value) {
-        "flex-start"    -> AlignContent.FLEX_START
-        "flex-end"      -> AlignContent.FLEX_END
-        "center"        -> AlignContent.CENTER
+        "flex-start" -> AlignContent.FLEX_START
+        "flex-end" -> AlignContent.FLEX_END
+        "center" -> AlignContent.CENTER
         "space-between" -> AlignContent.SPACE_BETWEEN
-        "space-around"  -> AlignContent.SPACE_AROUND
-        else            -> AlignContent.STRETCH
+        "space-around" -> AlignContent.SPACE_AROUND
+        else -> AlignContent.STRETCH
     }
 
     private fun parseJustifyContent(value: Any?) = when (value) {
-        "flex-end"      -> JustifyContent.FLEX_END
-        "center"        -> JustifyContent.CENTER
+        "flex-end" -> JustifyContent.FLEX_END
+        "center" -> JustifyContent.CENTER
         "space-between" -> JustifyContent.SPACE_BETWEEN
-        "space-around"  -> JustifyContent.SPACE_AROUND
-        "space-evenly"  -> JustifyContent.SPACE_EVENLY
-        else            -> JustifyContent.FLEX_START
+        "space-around" -> JustifyContent.SPACE_AROUND
+        "space-evenly" -> JustifyContent.SPACE_EVENLY
+        else -> JustifyContent.FLEX_START
     }
 
     private fun parseAlignSelf(value: Any?) = when (value) {
         "flex-start" -> AlignSelf.FLEX_START
-        "flex-end"   -> AlignSelf.FLEX_END
-        "center"     -> AlignSelf.CENTER
-        "baseline"   -> AlignSelf.BASELINE
-        "stretch"    -> AlignSelf.STRETCH
-        else         -> AlignSelf.AUTO
+        "flex-end" -> AlignSelf.FLEX_END
+        "center" -> AlignSelf.CENTER
+        "baseline" -> AlignSelf.BASELINE
+        "stretch" -> AlignSelf.STRETCH
+        else -> AlignSelf.AUTO
     }
 
     private val FLEX_LAYOUT_KEYS = setOf(

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Tags.kt

@@ -2,42 +2,42 @@ package com.vuenative.core
 
 /** View tag IDs used with View.setTag(id, value) */
 object Tags {
-    const val FLEX_PROPS    = 0x7F_FF_0001
+    const val FLEX_PROPS = 0x7F_FF_0001
     const val EVENT_HANDLER = 0x7F_FF_0002
-    const val NODE_ID       = 0x7F_FF_0003
-    const val FACTORY       = 0x7F_FF_0004
-    const val BORDER_COLOR  = 0x7F_FF_0010
-    const val BORDER_WIDTH  = 0x7F_FF_0011
-    const val GAP           = 0x7F_FF_0012
-    const val SHADOW_COLOR  = 0x7F_FF_0013
-    const val SHADOW_OPACITY= 0x7F_FF_0014
+    const val NODE_ID = 0x7F_FF_0003
+    const val FACTORY = 0x7F_FF_0004
+    const val BORDER_COLOR = 0x7F_FF_0010
+    const val BORDER_WIDTH = 0x7F_FF_0011
+    const val GAP = 0x7F_FF_0012
+    const val SHADOW_COLOR = 0x7F_FF_0013
+    const val SHADOW_OPACITY = 0x7F_FF_0014
     const val SHADOW_RADIUS = 0x7F_FF_0015
     const val SHADOW_OFFSET_X = 0x7F_FF_0016
     const val SHADOW_OFFSET_Y = 0x7F_FF_0017
-    const val POSITION       = 0x7F_FF_0020
-    const val POSITION_TOP   = 0x7F_FF_0021
-    const val POSITION_LEFT  = 0x7F_FF_0022
+    const val POSITION = 0x7F_FF_0020
+    const val POSITION_TOP = 0x7F_FF_0021
+    const val POSITION_LEFT = 0x7F_FF_0022
     const val POSITION_RIGHT = 0x7F_FF_0023
-    const val POSITION_BOTTOM= 0x7F_FF_0024
+    const val POSITION_BOTTOM = 0x7F_FF_0024
     const val INTERNAL_PROPS = 0x7F_FF_0030
 }
 
 /** Alias used throughout the codebase */
-const val TAG_FLEX_PROPS    = Tags.FLEX_PROPS
+const val TAG_FLEX_PROPS = Tags.FLEX_PROPS
 const val TAG_EVENT_HANDLER = Tags.EVENT_HANDLER
-const val TAG_NODE_ID       = Tags.NODE_ID
-const val TAG_FACTORY       = Tags.FACTORY
-const val TAG_BORDER_COLOR  = Tags.BORDER_COLOR
-const val TAG_BORDER_WIDTH  = Tags.BORDER_WIDTH
-const val TAG_GAP           = Tags.GAP
-const val TAG_SHADOW_COLOR    = Tags.SHADOW_COLOR
-const val TAG_SHADOW_OPACITY  = Tags.SHADOW_OPACITY
-const val TAG_SHADOW_RADIUS   = Tags.SHADOW_RADIUS
+const val TAG_NODE_ID = Tags.NODE_ID
+const val TAG_FACTORY = Tags.FACTORY
+const val TAG_BORDER_COLOR = Tags.BORDER_COLOR
+const val TAG_BORDER_WIDTH = Tags.BORDER_WIDTH
+const val TAG_GAP = Tags.GAP
+const val TAG_SHADOW_COLOR = Tags.SHADOW_COLOR
+const val TAG_SHADOW_OPACITY = Tags.SHADOW_OPACITY
+const val TAG_SHADOW_RADIUS = Tags.SHADOW_RADIUS
 const val TAG_SHADOW_OFFSET_X = Tags.SHADOW_OFFSET_X
 const val TAG_SHADOW_OFFSET_Y = Tags.SHADOW_OFFSET_Y
-const val TAG_POSITION        = Tags.POSITION
-const val TAG_POSITION_TOP    = Tags.POSITION_TOP
-const val TAG_POSITION_LEFT   = Tags.POSITION_LEFT
-const val TAG_POSITION_RIGHT  = Tags.POSITION_RIGHT
+const val TAG_POSITION = Tags.POSITION
+const val TAG_POSITION_TOP = Tags.POSITION_TOP
+const val TAG_POSITION_LEFT = Tags.POSITION_LEFT
+const val TAG_POSITION_RIGHT = Tags.POSITION_RIGHT
 const val TAG_POSITION_BOTTOM = Tags.POSITION_BOTTOM
-const val TAG_INTERNAL_PROPS  = Tags.INTERNAL_PROPS
+const val TAG_INTERNAL_PROPS = Tags.INTERNAL_PROPS

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/VueNativeActivity.kt

@@ -4,10 +4,10 @@ import android.content.Intent
 import android.graphics.Color
 import android.os.Build
 import android.os.Bundle
+import android.util.Log
 import android.view.View
 import android.view.ViewGroup
 import android.widget.FrameLayout
-import android.util.Log
 import androidx.appcompat.app.AppCompatActivity
 
 /**

package/native/android/VueNativeCore/src/test/kotlin/com/vuenative/core/ComponentRegistryTest.kt

@@ -0,0 +1,173 @@
+package com.vuenative.core
+
+import android.content.Context
+import android.view.View
+import android.widget.TextView
+import androidx.test.core.app.ApplicationProvider
+import com.google.android.flexbox.FlexboxLayout
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+class ComponentRegistryTest {
+
+    private lateinit var context: Context
+    private lateinit var registry: ComponentRegistry
+
+    @Before
+    fun setUp() {
+        // Reset singleton via reflection for test isolation
+        val field = ComponentRegistry::class.java.getDeclaredField("instance")
+        field.isAccessible = true
+        field.set(null, null)
+
+        context = ApplicationProvider.getApplicationContext()
+        registry = ComponentRegistry.getInstance(context)
+    }
+
+    // -------------------------------------------------------------------------
+    // All 28 default component types should be registered
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testAllComponentsRegistered() {
+        val expectedTypes = listOf(
+            "VView", "VText", "VButton", "VInput", "VSwitch",
+            "VActivityIndicator", "VScrollView", "VImage",
+            "VKeyboardAvoiding", "VSafeArea", "VSlider", "VList",
+            "VModal", "VAlertDialog", "VStatusBar", "VWebView",
+            "VProgressBar", "VPicker", "VSegmentedControl", "VActionSheet",
+            "VRefreshControl", "VPressable", "VSectionList", "VCheckbox",
+            "VRadio", "VDropdown", "VVideo", "__ROOT__"
+        )
+
+        for (type in expectedTypes) {
+            val view = registry.createView(type)
+            assertNotNull("createView('$type') should return non-null", view)
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // Unknown type returns null
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testUnknownTypeReturnsNull() {
+        val view = registry.createView("NonExistent")
+        assertNull("Unknown type should return null", view)
+    }
+
+    // -------------------------------------------------------------------------
+    // Factory is stored on view via tag
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testFactoryStoredOnView() {
+        val view = registry.createView("VView")!!
+        val factory = registry.factoryForView(view)
+        assertNotNull("factoryForView should return non-null after createView", factory)
+    }
+
+    // -------------------------------------------------------------------------
+    // factoryForType
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testFactoryForType() {
+        val factory = registry.factoryForType("VView")
+        assertNotNull("factoryForType('VView') should return non-null", factory)
+        assertTrue("VView factory should be VViewFactory", factory is VViewFactory)
+    }
+
+    @Test
+    fun testFactoryForTypeUnknown() {
+        val factory = registry.factoryForType("NonExistent")
+        assertNull("factoryForType for unknown type should return null", factory)
+    }
+
+    // -------------------------------------------------------------------------
+    // Register a custom factory
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testRegisterCustomFactory() {
+        val customFactory = object : NativeComponentFactory {
+            override fun createView(context: Context): View = View(context)
+            override fun updateProp(view: View, key: String, value: Any?) {}
+            override fun addEventListener(view: View, event: String, handler: (Any?) -> Unit) {}
+            override fun removeEventListener(view: View, event: String) {}
+        }
+
+        registry.register("CustomComponent", customFactory)
+        val view = registry.createView("CustomComponent")
+        assertNotNull("Custom component should be created", view)
+
+        val retrievedFactory = registry.factoryForType("CustomComponent")
+        assertEquals("Retrieved factory should be the custom factory", customFactory, retrievedFactory)
+    }
+
+    // -------------------------------------------------------------------------
+    // VText creates a TextView
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testVTextCreatesTextView() {
+        val view = registry.createView("VText")
+        assertNotNull(view)
+        assertTrue("VText should create a TextView", view is TextView)
+    }
+
+    // -------------------------------------------------------------------------
+    // VView creates a FlexboxLayout
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testVViewCreatesFlexboxLayout() {
+        val view = registry.createView("VView")
+        assertNotNull(view)
+        assertTrue("VView should create a FlexboxLayout", view is FlexboxLayout)
+    }
+
+    // -------------------------------------------------------------------------
+    // Singleton behavior
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testSingletonReturnsSameInstance() {
+        val instance1 = ComponentRegistry.getInstance(context)
+        val instance2 = ComponentRegistry.getInstance(context)
+        assertTrue("getInstance should return the same instance", instance1 === instance2)
+    }
+
+    // -------------------------------------------------------------------------
+    // Register overwrites existing factory
+    // -------------------------------------------------------------------------
+
+    @Test
+    fun testRegisterOverwritesExistingFactory() {
+        val customFactory = object : NativeComponentFactory {
+            override fun createView(context: Context): View = TextView(context)
+            override fun updateProp(view: View, key: String, value: Any?) {}
+            override fun addEventListener(view: View, event: String, handler: (Any?) -> Unit) {}
+            override fun removeEventListener(view: View, event: String) {}
+        }
+
+        // Overwrite the default VView factory
+        registry.register("VView", customFactory)
+
+        val factory = registry.factoryForType("VView")
+        assertEquals("Factory should be the newly registered one", customFactory, factory)
+
+        // The view created should now be a TextView (from custom factory), not FlexboxLayout
+        val view = registry.createView("VView")
+        assertTrue("Overwritten VView should create a TextView", view is TextView)
+    }
+}