@thelacanians/vue-native-cli 0.4.2 → 0.4.4

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Components/Factories/VActionSheetFactory.kt

@@ -0,0 +1,78 @@
+package com.vuenative.core
+
+import android.content.Context
+import android.view.View
+import android.view.ViewGroup
+import androidx.appcompat.app.AlertDialog
+import org.json.JSONArray
+
+class VActionSheetFactory : NativeComponentFactory {
+    data class SheetProps(
+        var title: String = "",
+        var message: String = "",
+        var actions: List<Map<String, String>> = emptyList()
+    )
+    private val props         = mutableMapOf<View, SheetProps>()
+    private val actionHandlers = mutableMapOf<View, (Any?) -> Unit>()
+    private val cancelHandlers = mutableMapOf<View, (Any?) -> Unit>()
+
+    override fun createView(context: Context): View = View(context).apply {
+        layoutParams = ViewGroup.LayoutParams(0, 0)
+        visibility = View.GONE
+    }
+
+    override fun updateProp(view: View, key: String, value: Any?) {
+        val p = props.getOrPut(view) { SheetProps() }
+        when (key) {
+            "visible" -> { if (value == true || value == "true") showSheet(view, p) }
+            "title"   -> p.title = value?.toString() ?: ""
+            "message" -> p.message = value?.toString() ?: ""
+            "actions" -> {
+                p.actions = when (value) {
+                    is JSONArray -> (0 until value.length()).map { i ->
+                        val a = value.getJSONObject(i)
+                        mapOf("label" to a.optString("label",""), "style" to a.optString("style","default"))
+                    }
+                    is List<*> -> value.filterIsInstance<Map<String, String>>()
+                    else -> emptyList()
+                }
+            }
+        }
+    }
+
+    private fun showSheet(view: View, p: SheetProps) {
+        val ctx = view.context
+        val items = p.actions.map { it["label"] ?: "" }.toTypedArray()
+        val cancelIdx = p.actions.indexOfFirst { it["style"] == "cancel" }
+
+        AlertDialog.Builder(ctx)
+            .setTitle(p.title.ifEmpty { null })
+            .setMessage(p.message.ifEmpty { null })
+            .setItems(items) { _, which ->
+                val action = p.actions.getOrNull(which)
+                if (action?.get("style") == "cancel") {
+                    cancelHandlers[view]?.invoke(null)
+                } else {
+                    actionHandlers[view]?.invoke(mapOf("label" to (action?.get("label") ?: ""), "index" to which))
+                }
+            }
+            .setNegativeButton("Cancel") { d, _ ->
+                d.dismiss()
+                cancelHandlers[view]?.invoke(null)
+            }
+            .show()
+    }
+
+    override fun addEventListener(view: View, event: String, handler: (Any?) -> Unit) {
+        when (event) {
+            "action" -> actionHandlers[view] = handler
+            "cancel" -> cancelHandlers[view] = handler
+        }
+    }
+    override fun removeEventListener(view: View, event: String) {
+        when (event) {
+            "action" -> actionHandlers.remove(view)
+            "cancel" -> cancelHandlers.remove(view)
+        }
+    }
+}

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Components/Factories/VActivityIndicatorFactory.kt

@@ -0,0 +1,46 @@
+package com.vuenative.core
+
+import android.content.Context
+import android.content.res.ColorStateList
+import android.view.View
+import android.view.ViewGroup
+import android.widget.ProgressBar
+
+class VActivityIndicatorFactory : NativeComponentFactory {
+    override fun createView(context: Context): View {
+        return ProgressBar(context).apply {
+            isIndeterminate = true
+            layoutParams = ViewGroup.LayoutParams(
+                ViewGroup.LayoutParams.WRAP_CONTENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT
+            )
+        }
+    }
+
+    override fun updateProp(view: View, key: String, value: Any?) {
+        val pb = view as? ProgressBar ?: return
+        when (key) {
+            "animating" -> pb.visibility = if (value == true || value == "true") View.VISIBLE else View.GONE
+            "size" -> {
+                val sizePx = when (value) {
+                    "small" -> (20 * view.context.resources.displayMetrics.density).toInt()
+                    "large" -> (48 * view.context.resources.displayMetrics.density).toInt()
+                    else    -> (32 * view.context.resources.displayMetrics.density).toInt()
+                }
+                pb.layoutParams?.also { lp ->
+                    lp.width = sizePx
+                    lp.height = sizePx
+                    pb.layoutParams = lp
+                }
+            }
+            "color" -> {
+                val color = StyleEngine.parseColor(value) ?: return
+                pb.indeterminateTintList = ColorStateList.valueOf(color)
+            }
+            else -> StyleEngine.apply(key, value, view)
+        }
+    }
+
+    override fun addEventListener(view: View, event: String, handler: (Any?) -> Unit) {}
+    override fun removeEventListener(view: View, event: String) {}
+}

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Components/Factories/VAlertDialogFactory.kt

@@ -0,0 +1,84 @@
+package com.vuenative.core
+
+import android.content.Context
+import android.view.View
+import android.view.ViewGroup
+import androidx.appcompat.app.AlertDialog
+import org.json.JSONArray
+
+class VAlertDialogFactory : NativeComponentFactory {
+    data class DialogProps(
+        var title: String = "",
+        var message: String = "",
+        var buttons: List<Map<String, String>> = emptyList()
+    )
+    private val props = mutableMapOf<View, DialogProps>()
+    private val confirmHandlers = mutableMapOf<View, (Any?) -> Unit>()
+    private val cancelHandlers  = mutableMapOf<View, (Any?) -> Unit>()
+    private val actionHandlers  = mutableMapOf<View, (Any?) -> Unit>()
+
+    override fun createView(context: Context): View {
+        return View(context).apply {
+            layoutParams = ViewGroup.LayoutParams(0, 0)
+            visibility = View.GONE
+        }
+    }
+
+    override fun updateProp(view: View, key: String, value: Any?) {
+        val p = props.getOrPut(view) { DialogProps() }
+        when (key) {
+            "visible" -> {
+                if (value == true || value == "true") showDialog(view, p)
+            }
+            "title"   -> p.title = value?.toString() ?: ""
+            "message" -> p.message = value?.toString() ?: ""
+            "buttons" -> {
+                p.buttons = when (value) {
+                    is JSONArray -> (0 until value.length()).map { i ->
+                        val btn = value.getJSONObject(i)
+                        mapOf("label" to btn.optString("label","OK"), "style" to btn.optString("style","default"))
+                    }
+                    is List<*> -> value.filterIsInstance<Map<String, String>>()
+                    else -> emptyList()
+                }
+            }
+        }
+    }
+
+    private fun showDialog(view: View, p: DialogProps) {
+        val ctx = view.context
+        val builder = AlertDialog.Builder(ctx)
+            .setTitle(p.title.ifEmpty { null })
+            .setMessage(p.message.ifEmpty { null })
+
+        if (p.buttons.isEmpty()) {
+            builder.setPositiveButton("OK") { d, _ -> d.dismiss(); confirmHandlers[view]?.invoke(null) }
+        } else {
+            p.buttons.forEach { btn ->
+                val label = btn["label"] ?: "OK"
+                val style = btn["style"] ?: "default"
+                when (style) {
+                    "cancel"      -> builder.setNegativeButton(label) { d, _ -> d.dismiss(); cancelHandlers[view]?.invoke(null) }
+                    "destructive" -> builder.setNeutralButton(label)  { d, _ -> d.dismiss(); confirmHandlers[view]?.invoke(mapOf("label" to label)) }
+                    else          -> builder.setPositiveButton(label) { d, _ -> d.dismiss(); confirmHandlers[view]?.invoke(mapOf("label" to label)) }
+                }
+            }
+        }
+        builder.create().show()
+    }
+
+    override fun addEventListener(view: View, event: String, handler: (Any?) -> Unit) {
+        when (event) {
+            "confirm" -> confirmHandlers[view] = handler
+            "cancel"  -> cancelHandlers[view]  = handler
+            "action"  -> actionHandlers[view]  = handler
+        }
+    }
+    override fun removeEventListener(view: View, event: String) {
+        when (event) {
+            "confirm" -> confirmHandlers.remove(view)
+            "cancel"  -> cancelHandlers.remove(view)
+            "action"  -> actionHandlers.remove(view)
+        }
+    }
+}

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Components/Factories/VButtonFactory.kt

@@ -0,0 +1,73 @@
+package com.vuenative.core
+
+import android.content.Context
+import android.view.View
+import android.widget.TextView
+import com.google.android.flexbox.FlexboxLayout
+
+class VButtonFactory : NativeComponentFactory {
+    override fun createView(context: Context): View {
+        return TouchableView(context)
+    }
+
+    override fun updateProp(view: View, key: String, value: Any?) {
+        val touchable = view as? TouchableView
+        if (touchable == null) {
+            StyleEngine.apply(key, value, view)
+            return
+        }
+
+        when (key) {
+            "disabled" -> {
+                touchable.isDisabled = value == true || value == "true" ||
+                        (value is Number && value.toInt() != 0)
+            }
+            "activeOpacity" -> {
+                touchable.activeOpacity = when (value) {
+                    is Double -> value.toFloat()
+                    is Float -> value
+                    is Int -> value.toFloat()
+                    is String -> value.toFloatOrNull() ?: 0.7f
+                    else -> 0.7f
+                }
+            }
+            "title" -> {
+                val flex = view as? FlexboxLayout
+                val tv = (0 until (flex?.childCount ?: 0))
+                    .mapNotNull { flex?.getChildAt(it) as? TextView }
+                    .firstOrNull()
+                tv?.text = value?.toString() ?: ""
+            }
+            else -> StyleEngine.apply(key, value, view)
+        }
+    }
+
+    override fun addEventListener(view: View, event: String, handler: (Any?) -> Unit) {
+        val touchable = view as? TouchableView ?: return
+
+        when (event) {
+            "press" -> touchable.onPress = { handler(null) }
+            "longPress", "longpress" -> touchable.onLongPress = { handler(null) }
+        }
+    }
+
+    override fun removeEventListener(view: View, event: String) {
+        val touchable = view as? TouchableView ?: return
+
+        when (event) {
+            "press" -> touchable.onPress = null
+            "longPress", "longpress" -> touchable.onLongPress = null
+        }
+    }
+
+    override fun insertChild(parent: View, child: View, index: Int) {
+        val flex = parent as? FlexboxLayout ?: return
+        val lp = StyleEngine.buildFlexLayoutParams(child)
+        if (index >= flex.childCount) flex.addView(child, lp)
+        else flex.addView(child, index, lp)
+    }
+
+    override fun removeChild(parent: View, child: View) {
+        (parent as? FlexboxLayout)?.removeView(child)
+    }
+}

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Components/Factories/VCheckboxFactory.kt

@@ -0,0 +1,93 @@
+package com.vuenative.core
+
+import android.content.Context
+import android.view.View
+import android.view.ViewGroup
+import android.widget.CheckBox
+import android.widget.LinearLayout
+import android.widget.TextView
+
+class VCheckboxFactory : NativeComponentFactory {
+    private val changeHandlers = mutableMapOf<View, (Any?) -> Unit>()
+
+    override fun createView(context: Context): View {
+        return LinearLayout(context).apply {
+            orientation = LinearLayout.HORIZONTAL
+            gravity = android.view.Gravity.CENTER_VERTICAL
+            layoutParams = ViewGroup.LayoutParams(
+                ViewGroup.LayoutParams.WRAP_CONTENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT
+            )
+
+            val checkbox = CheckBox(context).apply {
+                tag = "checkbox"
+                layoutParams = LinearLayout.LayoutParams(
+                    LinearLayout.LayoutParams.WRAP_CONTENT,
+                    LinearLayout.LayoutParams.WRAP_CONTENT
+                )
+            }
+
+            val label = TextView(context).apply {
+                tag = "label"
+                textSize = 16f
+                layoutParams = LinearLayout.LayoutParams(
+                    LinearLayout.LayoutParams.WRAP_CONTENT,
+                    LinearLayout.LayoutParams.WRAP_CONTENT
+                ).apply { marginStart = 8 }
+            }
+
+            addView(checkbox)
+            addView(label)
+        }
+    }
+
+    override fun updateProp(view: View, key: String, value: Any?) {
+        val container = view as? LinearLayout ?: return
+        val checkbox = container.findViewWithTag<CheckBox>("checkbox") ?: return
+        val label = container.findViewWithTag<TextView>("label") ?: return
+
+        when (key) {
+            "value" -> {
+                val checked = value == true || value == "true" || value == 1
+                if (checkbox.isChecked != checked) checkbox.isChecked = checked
+            }
+            "label" -> {
+                label.text = value?.toString() ?: ""
+                label.visibility = if ((value?.toString() ?: "").isEmpty()) View.GONE else View.VISIBLE
+            }
+            "disabled" -> {
+                val disabled = value == true || value == "true"
+                checkbox.isEnabled = !disabled
+                container.alpha = if (disabled) 0.4f else 1.0f
+            }
+            "checkColor", "tintColor" -> {
+                val color = StyleEngine.parseColor(value) ?: return
+                checkbox.buttonTintList = android.content.res.ColorStateList.valueOf(color)
+            }
+            else -> StyleEngine.apply(key, value, view)
+        }
+    }
+
+    override fun addEventListener(view: View, event: String, handler: (Any?) -> Unit) {
+        if (event != "change") return
+        val container = view as? LinearLayout ?: return
+        val checkbox = container.findViewWithTag<CheckBox>("checkbox") ?: return
+        changeHandlers[view] = handler
+        checkbox.setOnCheckedChangeListener { _, isChecked ->
+            changeHandlers[view]?.invoke(mapOf("value" to isChecked))
+        }
+        // Also allow tapping the whole row
+        container.setOnClickListener {
+            checkbox.isChecked = !checkbox.isChecked
+        }
+    }
+
+    override fun removeEventListener(view: View, event: String) {
+        if (event != "change") return
+        val container = view as? LinearLayout ?: return
+        val checkbox = container.findViewWithTag<CheckBox>("checkbox")
+        changeHandlers.remove(view)
+        checkbox?.setOnCheckedChangeListener(null)
+        container.setOnClickListener(null)
+    }
+}

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Components/Factories/VDropdownFactory.kt

@@ -0,0 +1,125 @@
+package com.vuenative.core
+
+import android.content.Context
+import android.view.View
+import android.view.ViewGroup
+import android.widget.AdapterView
+import android.widget.ArrayAdapter
+import android.widget.Spinner
+import org.json.JSONArray
+
+class VDropdownFactory : NativeComponentFactory {
+    private val changeHandlers = mutableMapOf<Spinner, (Any?) -> Unit>()
+    private val optionValues = mutableMapOf<Spinner, List<String>>()
+    private val optionLabels = mutableMapOf<Spinner, List<String>>()
+
+    override fun createView(context: Context): View {
+        return Spinner(context).apply {
+            layoutParams = ViewGroup.LayoutParams(
+                ViewGroup.LayoutParams.WRAP_CONTENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT
+            )
+        }
+    }
+
+    override fun updateProp(view: View, key: String, value: Any?) {
+        val spinner = view as? Spinner ?: return
+        when (key) {
+            "options" -> {
+                val items = when (value) {
+                    is JSONArray -> (0 until value.length()).map { i ->
+                        val obj = value.getJSONObject(i)
+                        Pair(obj.optString("label", ""), obj.optString("value", ""))
+                    }
+                    is List<*> -> value.filterIsInstance<Map<*, *>>().map { m ->
+                        Pair(m["label"]?.toString() ?: "", m["value"]?.toString() ?: "")
+                    }
+                    else -> emptyList()
+                }
+
+                val labels = items.map { it.first }
+                val values = items.map { it.second }
+                optionLabels[spinner] = labels
+                optionValues[spinner] = values
+
+                // Add placeholder if set
+                val placeholder = spinner.tag as? String ?: "Select..."
+                val displayLabels = listOf(placeholder) + labels
+
+                val adapter = ArrayAdapter(
+                    spinner.context,
+                    android.R.layout.simple_spinner_item,
+                    displayLabels
+                ).apply {
+                    setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
+                }
+                spinner.adapter = adapter
+
+                // Re-apply selection
+                applySelection(spinner)
+            }
+            "selectedValue" -> {
+                spinner.setTag(android.R.id.text1, value?.toString())
+                applySelection(spinner)
+            }
+            "placeholder" -> {
+                spinner.tag = value?.toString() ?: "Select..."
+                // Rebuild adapter with new placeholder
+                val labels = optionLabels[spinner] ?: return
+                val displayLabels = listOf(value?.toString() ?: "Select...") + labels
+                val adapter = ArrayAdapter(
+                    spinner.context,
+                    android.R.layout.simple_spinner_item,
+                    displayLabels
+                ).apply {
+                    setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
+                }
+                spinner.adapter = adapter
+            }
+            "disabled" -> {
+                spinner.isEnabled = value != true && value != "true"
+            }
+            else -> StyleEngine.apply(key, value, view)
+        }
+    }
+
+    override fun addEventListener(view: View, event: String, handler: (Any?) -> Unit) {
+        val spinner = view as? Spinner ?: return
+        if (event == "change") {
+            changeHandlers[spinner] = handler
+            spinner.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
+                override fun onItemSelected(parent: AdapterView<*>?, v: View?, position: Int, id: Long) {
+                    // Position 0 is placeholder
+                    if (position == 0) return
+                    val values = optionValues[spinner] ?: return
+                    val labels = optionLabels[spinner] ?: return
+                    val idx = position - 1
+                    if (idx < values.size) {
+                        changeHandlers[spinner]?.invoke(mapOf(
+                            "value" to values[idx],
+                            "label" to labels[idx]
+                        ))
+                    }
+                }
+                override fun onNothingSelected(parent: AdapterView<*>?) {}
+            }
+        }
+    }
+
+    override fun removeEventListener(view: View, event: String) {
+        val spinner = view as? Spinner ?: return
+        if (event == "change") {
+            changeHandlers.remove(spinner)
+            spinner.onItemSelectedListener = null
+        }
+    }
+
+    private fun applySelection(spinner: Spinner) {
+        val selected = spinner.getTag(android.R.id.text1) as? String ?: return
+        val values = optionValues[spinner] ?: return
+        val idx = values.indexOf(selected)
+        if (idx >= 0) {
+            spinner.setSelection(idx + 1) // +1 for placeholder
+        }
+    }
+}

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Components/Factories/VImageFactory.kt

@@ -0,0 +1,75 @@
+package com.vuenative.core
+
+import android.content.Context
+import android.view.View
+import android.view.ViewGroup
+import android.widget.ImageView
+import coil.load
+import coil.request.CachePolicy
+import org.json.JSONObject
+
+class VImageFactory : NativeComponentFactory {
+    private val loadHandlers  = mutableMapOf<ImageView, (Any?) -> Unit>()
+    private val errorHandlers = mutableMapOf<ImageView, (Any?) -> Unit>()
+
+    override fun createView(context: Context): View {
+        return ImageView(context).apply {
+            scaleType = ImageView.ScaleType.CENTER_CROP
+            layoutParams = ViewGroup.LayoutParams(
+                ViewGroup.LayoutParams.WRAP_CONTENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT
+            )
+        }
+    }
+
+    override fun updateProp(view: View, key: String, value: Any?) {
+        val iv = view as? ImageView ?: return
+        when (key) {
+            "source" -> {
+                val uri = when (value) {
+                    is Map<*, *> -> value["uri"]?.toString()
+                    is JSONObject -> value.optString("uri")
+                    else -> null
+                }
+                if (uri.isNullOrEmpty()) {
+                    iv.setImageDrawable(null)
+                    return
+                }
+                iv.load(uri) {
+                    memoryCachePolicy(CachePolicy.ENABLED)
+                    diskCachePolicy(CachePolicy.ENABLED)
+                    listener(
+                        onSuccess = { _, _ -> loadHandlers[iv]?.invoke(null) },
+                        onError   = { _, err -> errorHandlers[iv]?.invoke(mapOf("message" to (err.throwable.message ?: "Load failed"))) }
+                    )
+                }
+            }
+            "resizeMode" -> {
+                iv.scaleType = when (value) {
+                    "cover"   -> ImageView.ScaleType.CENTER_CROP
+                    "contain" -> ImageView.ScaleType.FIT_CENTER
+                    "stretch" -> ImageView.ScaleType.FIT_XY
+                    "center"  -> ImageView.ScaleType.CENTER
+                    else      -> ImageView.ScaleType.CENTER_CROP
+                }
+            }
+            else -> StyleEngine.apply(key, value, view)
+        }
+    }
+
+    override fun addEventListener(view: View, event: String, handler: (Any?) -> Unit) {
+        val iv = view as? ImageView ?: return
+        when (event) {
+            "load"  -> loadHandlers[iv] = handler
+            "error" -> errorHandlers[iv] = handler
+        }
+    }
+
+    override fun removeEventListener(view: View, event: String) {
+        val iv = view as? ImageView ?: return
+        when (event) {
+            "load"  -> loadHandlers.remove(iv)
+            "error" -> errorHandlers.remove(iv)
+        }
+    }
+}