@thelacanians/vue-native-cli 0.4.2 → 0.4.4

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

@@ -0,0 +1,109 @@
+package com.vuenative.core
+
+import android.content.Context
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewGroup
+import com.google.android.flexbox.FlexboxLayout
+
+/**
+ * Factory for VPressable — a generic pressable container component.
+ *
+ * Like VButton but without built-in text/label support. Uses PressableView,
+ * a subclass of TouchableView that adds pressIn/pressOut callbacks.
+ */
+class VPressableFactory : NativeComponentFactory {
+
+    override fun createView(context: Context): View {
+        return PressableView(context)
+    }
+
+    override fun updateProp(view: View, key: String, value: Any?) {
+        val pressable = view as? PressableView
+        if (pressable == null) {
+            StyleEngine.apply(key, value, view)
+            return
+        }
+
+        when (key) {
+            "disabled" -> {
+                pressable.isDisabled = value == true || value == "true" ||
+                        (value is Number && value.toInt() != 0)
+            }
+            "activeOpacity" -> {
+                pressable.activeOpacity = when (value) {
+                    is Double -> value.toFloat()
+                    is Float -> value
+                    is Int -> value.toFloat()
+                    is String -> value.toFloatOrNull() ?: 0.7f
+                    else -> 0.7f
+                }
+            }
+            else -> StyleEngine.apply(key, value, view)
+        }
+    }
+
+    override fun addEventListener(view: View, event: String, handler: (Any?) -> Unit) {
+        val pressable = view as? PressableView ?: return
+
+        when (event) {
+            "press" -> pressable.onPress = { handler(null) }
+            "longPress", "longpress" -> pressable.onLongPress = { handler(null) }
+            "pressIn", "pressin" -> pressable.onPressIn = { handler(null) }
+            "pressOut", "pressout" -> pressable.onPressOut = { handler(null) }
+        }
+    }
+
+    override fun removeEventListener(view: View, event: String) {
+        val pressable = view as? PressableView ?: return
+
+        when (event) {
+            "press" -> pressable.onPress = null
+            "longPress", "longpress" -> pressable.onLongPress = null
+            "pressIn", "pressin" -> pressable.onPressIn = null
+            "pressOut", "pressout" -> pressable.onPressOut = 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)
+    }
+}
+
+/**
+ * Extension of TouchableView that adds pressIn and pressOut callbacks.
+ * Fires pressIn when a touch begins and pressOut when the touch ends or is cancelled.
+ */
+class PressableView(context: android.content.Context) : TouchableView(context) {
+
+    /** Called when a touch begins inside the view bounds. */
+    var onPressIn: (() -> Unit)? = null
+
+    /** Called when a touch ends or is cancelled. */
+    var onPressOut: (() -> Unit)? = null
+
+    override fun onTouchEvent(event: MotionEvent): Boolean {
+        if (isDisabled) return false
+
+        when (event.action) {
+            MotionEvent.ACTION_DOWN -> {
+                onPressIn?.invoke()
+            }
+            MotionEvent.ACTION_UP -> {
+                onPressOut?.invoke()
+            }
+            MotionEvent.ACTION_CANCEL -> {
+                onPressOut?.invoke()
+            }
+        }
+
+        return super.onTouchEvent(event)
+    }
+}

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

@@ -0,0 +1,43 @@
+package com.vuenative.core
+
+import android.content.Context
+import android.view.View
+import android.view.ViewGroup
+import android.widget.ProgressBar
+
+class VProgressBarFactory : NativeComponentFactory {
+    override fun createView(context: Context): View {
+        return ProgressBar(context, null, android.R.attr.progressBarStyleHorizontal).apply {
+            isIndeterminate = false
+            max = 1000
+            progress = 0
+            layoutParams = ViewGroup.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT
+            )
+        }
+    }
+
+    override fun updateProp(view: View, key: String, value: Any?) {
+        val pb = view as? ProgressBar ?: return
+        when (key) {
+            "progress" -> {
+                val f = StyleEngine.toFloat(value, 0f).coerceIn(0f, 1f)
+                pb.progress = (f * pb.max).toInt()
+            }
+            "progressTintColor" -> {
+                val color = StyleEngine.parseColor(value) ?: return
+                pb.progressTintList = android.content.res.ColorStateList.valueOf(color)
+            }
+            "trackTintColor" -> {
+                val color = StyleEngine.parseColor(value) ?: return
+                pb.progressBackgroundTintList = android.content.res.ColorStateList.valueOf(color)
+            }
+            "animated" -> {} // Android ProgressBar animates by default
+            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/VRadioFactory.kt

@@ -0,0 +1,103 @@
+package com.vuenative.core
+
+import android.content.Context
+import android.view.View
+import android.view.ViewGroup
+import android.widget.RadioButton
+import android.widget.RadioGroup
+import org.json.JSONArray
+
+class VRadioFactory : NativeComponentFactory {
+    private val changeHandlers = mutableMapOf<RadioGroup, (Any?) -> Unit>()
+    private val optionValues = mutableMapOf<RadioGroup, List<String>>()
+
+    override fun createView(context: Context): View {
+        return RadioGroup(context).apply {
+            orientation = RadioGroup.VERTICAL
+            layoutParams = ViewGroup.LayoutParams(
+                ViewGroup.LayoutParams.WRAP_CONTENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT
+            )
+        }
+    }
+
+    override fun updateProp(view: View, key: String, value: Any?) {
+        val rg = view as? RadioGroup ?: 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()
+                }
+                optionValues[rg] = items.map { it.second }
+                rg.removeAllViews()
+                items.forEachIndexed { i, (label, _) ->
+                    val btn = RadioButton(rg.context).apply {
+                        text = label
+                        id = View.generateViewId()
+                        setPadding(0, 16, 24, 16)
+                    }
+                    rg.addView(btn)
+                }
+                // Re-apply selection
+                applySelection(rg)
+            }
+            "selectedValue" -> {
+                rg.tag = value?.toString()
+                applySelection(rg)
+            }
+            "disabled" -> {
+                val disabled = value == true || value == "true"
+                rg.isEnabled = !disabled
+                rg.alpha = if (disabled) 0.4f else 1.0f
+                (0 until rg.childCount).forEach {
+                    rg.getChildAt(it).isEnabled = !disabled
+                }
+            }
+            "tintColor" -> {
+                val color = StyleEngine.parseColor(value) ?: return
+                (0 until rg.childCount).forEach { i ->
+                    (rg.getChildAt(i) as? RadioButton)?.buttonTintList =
+                        android.content.res.ColorStateList.valueOf(color)
+                }
+            }
+            else -> StyleEngine.apply(key, value, view)
+        }
+    }
+
+    override fun addEventListener(view: View, event: String, handler: (Any?) -> Unit) {
+        val rg = view as? RadioGroup ?: return
+        if (event == "change") {
+            changeHandlers[rg] = handler
+            rg.setOnCheckedChangeListener { group, checkedId ->
+                val idx = (0 until group.childCount).indexOfFirst { group.getChildAt(it).id == checkedId }
+                val value = optionValues[group]?.getOrNull(idx) ?: ""
+                changeHandlers[group]?.invoke(mapOf("value" to value))
+            }
+        }
+    }
+
+    override fun removeEventListener(view: View, event: String) {
+        val rg = view as? RadioGroup ?: return
+        if (event == "change") {
+            changeHandlers.remove(rg)
+            rg.setOnCheckedChangeListener(null)
+        }
+    }
+
+    private fun applySelection(rg: RadioGroup) {
+        val selected = rg.tag as? String ?: return
+        val values = optionValues[rg] ?: return
+        val idx = values.indexOf(selected)
+        if (idx >= 0 && idx < rg.childCount) {
+            val child = rg.getChildAt(idx) as? RadioButton
+            child?.id?.let { rg.check(it) }
+        }
+    }
+}

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

@@ -0,0 +1,73 @@
+package com.vuenative.core
+
+import android.content.Context
+import android.graphics.Color
+import android.view.View
+import android.view.ViewGroup
+import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
+
+/**
+ * Factory for VRefreshControl — pull-to-refresh indicator.
+ *
+ * Creates a SwipeRefreshLayout that wraps its children. When used as a child
+ * of VScrollView, the bridge should attach this to the parent's refresh mechanism.
+ * For standalone usage, this provides its own SwipeRefreshLayout.
+ */
+class VRefreshControlFactory : NativeComponentFactory {
+
+    override fun createView(context: Context): View {
+        // Create a zero-sized invisible view as a marker.
+        // The actual refresh behavior is wired by the parent VScrollView.
+        val marker = View(context).apply {
+            visibility = View.GONE
+            layoutParams = ViewGroup.LayoutParams(0, 0)
+        }
+        return marker
+    }
+
+    override fun updateProp(view: View, key: String, value: Any?) {
+        // VRefreshControl props are handled by the parent VScrollView.
+        // The bridge forwards refreshing/tintColor to the parent's SwipeRefreshLayout.
+        val parent = view.parent as? SwipeRefreshLayout
+        when (key) {
+            "refreshing" -> {
+                parent?.isRefreshing = value == true || value == "true"
+            }
+            "tintColor" -> {
+                val colorStr = value as? String ?: return
+                try {
+                    val color = Color.parseColor(colorStr)
+                    parent?.setColorSchemeColors(color)
+                } catch (_: IllegalArgumentException) {
+                    // Ignore invalid color strings
+                }
+            }
+            // "title" is iOS-only (UIRefreshControl attributedTitle)
+        }
+    }
+
+    override fun addEventListener(view: View, event: String, handler: (Any?) -> Unit) {
+        if (event == "refresh") {
+            // Store handler on the view for the parent factory to wire up
+            view.setTag(TAG_EVENT_HANDLER, handler)
+
+            // If already inside a SwipeRefreshLayout, wire it up directly
+            val parent = view.parent as? SwipeRefreshLayout
+            if (parent != null) {
+                parent.isEnabled = true
+                parent.setOnRefreshListener { handler(null) }
+            }
+        }
+    }
+
+    override fun removeEventListener(view: View, event: String) {
+        if (event == "refresh") {
+            view.setTag(TAG_EVENT_HANDLER, null)
+            val parent = view.parent as? SwipeRefreshLayout
+            if (parent != null) {
+                parent.setOnRefreshListener(null)
+                parent.isEnabled = false
+            }
+        }
+    }
+}

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

@@ -0,0 +1,39 @@
+package com.vuenative.core
+
+import android.content.Context
+import android.view.View
+import com.google.android.flexbox.FlexDirection
+import com.google.android.flexbox.FlexboxLayout
+
+class VRootFactory : NativeComponentFactory {
+    override fun createView(context: Context): View {
+        return FlexboxLayout(context).apply {
+            flexDirection = FlexDirection.COLUMN
+            layoutParams = android.view.ViewGroup.LayoutParams(
+                android.view.ViewGroup.LayoutParams.MATCH_PARENT,
+                android.view.ViewGroup.LayoutParams.MATCH_PARENT
+            )
+        }
+    }
+
+    override fun updateProp(view: View, key: String, value: Any?) {
+        StyleEngine.apply(key, value, view)
+    }
+
+    override fun addEventListener(view: View, event: String, handler: (Any?) -> Unit) {
+        if (event == "press") {
+            view.setOnClickListener { handler(null) }
+        }
+    }
+
+    override fun removeEventListener(view: View, event: String) {
+        if (event == "press") view.setOnClickListener(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)
+    }
+}

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

@@ -0,0 +1,48 @@
+package com.vuenative.core
+
+import android.content.Context
+import android.os.Build
+import android.view.View
+import android.view.ViewGroup
+import android.view.WindowInsets
+import com.google.android.flexbox.FlexDirection
+import com.google.android.flexbox.FlexboxLayout
+
+class VSafeAreaFactory : NativeComponentFactory {
+    override fun createView(context: Context): View {
+        val flex = FlexboxLayout(context).apply {
+            flexDirection = FlexDirection.COLUMN
+            layoutParams = ViewGroup.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.MATCH_PARENT
+            )
+        }
+        // Apply safe area insets
+        flex.setOnApplyWindowInsetsListener { v, insets ->
+            val top = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                insets.getInsets(WindowInsets.Type.systemBars()).top
+            } else {
+                @Suppress("DEPRECATION")
+                insets.systemWindowInsetTop
+            }
+            val bottom = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                insets.getInsets(WindowInsets.Type.systemBars()).bottom
+            } else {
+                @Suppress("DEPRECATION")
+                insets.systemWindowInsetBottom
+            }
+            v.setPadding(v.paddingLeft, top, v.paddingRight, bottom)
+            insets
+        }
+        return flex
+    }
+
+    override fun updateProp(view: View, key: String, value: Any?) = StyleEngine.apply(key, value, view)
+    override fun addEventListener(view: View, event: String, handler: (Any?) -> Unit) {}
+    override fun removeEventListener(view: View, event: String) {}
+    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)
+    }
+}

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

@@ -0,0 +1,105 @@
+package com.vuenative.core
+
+import android.content.Context
+import android.view.View
+import android.view.ViewGroup
+import android.widget.ScrollView
+import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
+import com.google.android.flexbox.FlexDirection
+import com.google.android.flexbox.FlexboxLayout
+
+class VScrollViewFactory : NativeComponentFactory {
+
+    // Tracks the inner ScrollView and content FlexboxLayout per SwipeRefreshLayout root
+    private data class ScrollState(val scrollView: ScrollView, val content: FlexboxLayout)
+    private val states = mutableMapOf<SwipeRefreshLayout, ScrollState>()
+
+    override fun createView(context: Context): View {
+        val content = FlexboxLayout(context).apply {
+            flexDirection = FlexDirection.COLUMN
+            layoutParams = ViewGroup.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT
+            )
+        }
+        val scroll = ScrollView(context).apply {
+            isFillViewport = true
+            layoutParams = ViewGroup.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.MATCH_PARENT
+            )
+        }
+        scroll.addView(content)
+
+        val srf = SwipeRefreshLayout(context).apply {
+            layoutParams = ViewGroup.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.MATCH_PARENT
+            )
+            // Disabled by default; enabled when @refresh listener is added
+            isEnabled = false
+        }
+        srf.addView(scroll)
+        states[srf] = ScrollState(scroll, content)
+        return srf
+    }
+
+    override fun updateProp(view: View, key: String, value: Any?) {
+        val srf = view as? SwipeRefreshLayout ?: return
+        val scroll = states[srf]?.scrollView
+        when (key) {
+            "refreshing" -> {
+                srf.isRefreshing = value == true || value == "true"
+            }
+            "showsVerticalScrollIndicator" -> {
+                scroll?.isVerticalScrollBarEnabled = value != false && value != "false"
+            }
+            "showsHorizontalScrollIndicator" -> {
+                scroll?.isHorizontalScrollBarEnabled = value != false && value != "false"
+            }
+            "scrollEnabled" -> {
+                // ScrollView doesn't expose a direct enable toggle; no-op
+            }
+            else -> scroll?.let { StyleEngine.apply(key, value, it) }
+        }
+    }
+
+    override fun addEventListener(view: View, event: String, handler: (Any?) -> Unit) {
+        val srf = view as? SwipeRefreshLayout ?: return
+        val scroll = states[srf]?.scrollView
+        when (event) {
+            "refresh" -> {
+                srf.isEnabled = true
+                srf.setOnRefreshListener { handler(null) }
+            }
+            "scroll" -> {
+                scroll?.viewTreeObserver?.addOnScrollChangedListener {
+                    handler(mapOf(
+                        "contentOffset" to mapOf("x" to scroll.scrollX, "y" to scroll.scrollY)
+                    ))
+                }
+            }
+        }
+    }
+
+    override fun removeEventListener(view: View, event: String) {
+        val srf = view as? SwipeRefreshLayout ?: return
+        if (event == "refresh") {
+            srf.setOnRefreshListener(null)
+            srf.isEnabled = false
+        }
+    }
+
+    override fun insertChild(parent: View, child: View, index: Int) {
+        val srf = parent as? SwipeRefreshLayout ?: return
+        val content = states[srf]?.content ?: return
+        val lp = StyleEngine.buildFlexLayoutParams(child)
+        if (index >= content.childCount) content.addView(child, lp)
+        else content.addView(child, index, lp)
+    }
+
+    override fun removeChild(parent: View, child: View) {
+        val srf = parent as? SwipeRefreshLayout ?: return
+        states[srf]?.content?.removeView(child)
+    }
+}

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

@@ -0,0 +1,144 @@
+package com.vuenative.core
+
+import android.content.Context
+import android.view.View
+import android.view.ViewGroup
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+
+/**
+ * Factory for VSectionList — a sectioned list backed by RecyclerView.
+ * Children marked with the `__sectionHeader` internal prop are treated as section headers.
+ * All other children are regular items grouped under the preceding header.
+ */
+class VSectionListFactory : NativeComponentFactory {
+    private val childViews = mutableMapOf<RecyclerView, MutableList<View>>()
+    private val scrollHandlers = mutableMapOf<RecyclerView, (Any?) -> Unit>()
+    private val endReachedHandlers = mutableMapOf<RecyclerView, (Any?) -> Unit>()
+    private val scrollListeners = mutableMapOf<RecyclerView, RecyclerView.OnScrollListener>()
+    private val firedEndReached = mutableMapOf<RecyclerView, Boolean>()
+
+    override fun createView(context: Context): View {
+        val rv = RecyclerView(context).apply {
+            layoutManager = LinearLayoutManager(context)
+            layoutParams = ViewGroup.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.MATCH_PARENT
+            )
+        }
+        childViews[rv] = mutableListOf()
+        firedEndReached[rv] = false
+        rv.adapter = VSectionListAdapter(childViews[rv]!!)
+        return rv
+    }
+
+    override fun updateProp(view: View, key: String, value: Any?) {
+        val rv = view as? RecyclerView ?: return
+        when (key) {
+            "bounces" -> {
+                rv.overScrollMode = if (value == false || value == "false")
+                    View.OVER_SCROLL_NEVER else View.OVER_SCROLL_ALWAYS
+            }
+            "showsScrollIndicator" -> {
+                val show = value != false && value != "false"
+                rv.isVerticalScrollBarEnabled = show
+            }
+            "stickySectionHeaders" -> {
+                // RecyclerView sticky headers would require an ItemDecoration;
+                // for now we store the preference but don't implement sticky behavior
+            }
+            "estimatedItemHeight" -> { /* Used for initial sizing hints */ }
+            else -> StyleEngine.apply(key, value, view)
+        }
+    }
+
+    override fun addEventListener(view: View, event: String, handler: (Any?) -> Unit) {
+        val rv = view as? RecyclerView ?: return
+        when (event) {
+            "scroll" -> {
+                scrollHandlers[rv] = handler
+                ensureScrollListener(rv)
+            }
+            "endReached" -> {
+                endReachedHandlers[rv] = handler
+                ensureScrollListener(rv)
+            }
+        }
+    }
+
+    override fun removeEventListener(view: View, event: String) {
+        val rv = view as? RecyclerView ?: return
+        when (event) {
+            "scroll" -> scrollHandlers.remove(rv)
+            "endReached" -> endReachedHandlers.remove(rv)
+        }
+        if (!scrollHandlers.containsKey(rv) && !endReachedHandlers.containsKey(rv)) {
+            scrollListeners.remove(rv)?.let { rv.removeOnScrollListener(it) }
+        }
+    }
+
+    private fun ensureScrollListener(rv: RecyclerView) {
+        if (scrollListeners.containsKey(rv)) return
+        var cumulativeX = 0
+        var cumulativeY = 0
+        val listener = object : RecyclerView.OnScrollListener() {
+            override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
+                cumulativeX += dx
+                cumulativeY += dy
+                scrollHandlers[recyclerView]?.invoke(mapOf("x" to cumulativeX, "y" to cumulativeY))
+
+                val lm = recyclerView.layoutManager as? LinearLayoutManager ?: return
+                val totalItems = lm.itemCount
+                if (totalItems == 0) return
+                val lastVisible = lm.findLastVisibleItemPosition()
+                val threshold = (totalItems * 0.2).toInt().coerceAtLeast(1)
+
+                if (lastVisible >= totalItems - threshold) {
+                    if (firedEndReached[recyclerView] != true) {
+                        firedEndReached[recyclerView] = true
+                        endReachedHandlers[recyclerView]?.invoke(null)
+                    }
+                } else {
+                    firedEndReached[recyclerView] = false
+                }
+            }
+        }
+        scrollListeners[rv] = listener
+        rv.addOnScrollListener(listener)
+    }
+
+    override fun insertChild(parent: View, child: View, index: Int) {
+        val rv = parent as? RecyclerView ?: return
+        val list = childViews[rv] ?: return
+        if (index >= list.size) list.add(child) else list.add(index, child)
+        rv.adapter?.notifyItemInserted(if (index >= list.size - 1) list.size - 1 else index)
+    }
+
+    override fun removeChild(parent: View, child: View) {
+        val rv = parent as? RecyclerView ?: return
+        val list = childViews[rv] ?: return
+        val idx = list.indexOf(child)
+        if (idx >= 0) {
+            list.removeAt(idx)
+            rv.adapter?.notifyItemRemoved(idx)
+        }
+    }
+}
+
+private class VSectionListAdapter(private val items: List<View>) : RecyclerView.Adapter<VSectionListAdapter.VH>() {
+    class VH(val view: View) : RecyclerView.ViewHolder(view)
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): VH {
+        val v = items.getOrNull(viewType) ?: android.widget.FrameLayout(parent.context)
+        (v.parent as? ViewGroup)?.removeView(v)
+        v.layoutParams = RecyclerView.LayoutParams(
+            RecyclerView.LayoutParams.MATCH_PARENT,
+            RecyclerView.LayoutParams.WRAP_CONTENT
+        )
+        return VH(v)
+    }
+
+    override fun onBindViewHolder(holder: VH, position: Int) {}
+    override fun getItemCount(): Int = items.size
+    override fun getItemViewType(position: Int): Int = position
+}