@thelacanians/vue-native-cli 0.4.13 → 0.4.15

package/native/android/VueNativeCore/build.gradle.kts

@@ -119,7 +119,7 @@ afterEvaluate {
             create<MavenPublication>("release") {
                 groupId = "com.vuenative"
                 artifactId = "core"
-                version = "0.4.13"
+                version = "0.4.14"
                 from(components["release"])
             }
         }

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

@@ -23,6 +23,20 @@ class NativeBridge(private val context: Context) {
             "create", "createText", "appendChild", "insertBefore", "removeChild",
             "setRootView", "setText", "setElementText"
         )
+
+        /** Style properties that affect layout and require a layout pass when changed. */
+        private val layoutAffectingStyles = setOf(
+            "width", "height", "minWidth", "minHeight", "maxWidth", "maxHeight",
+            "flex", "flexGrow", "flexShrink", "flexBasis", "flexDirection",
+            "flexWrap", "alignItems", "alignSelf", "alignContent", "justifyContent",
+            "padding", "paddingTop", "paddingRight", "paddingBottom", "paddingLeft",
+            "paddingHorizontal", "paddingVertical", "paddingStart", "paddingEnd",
+            "margin", "marginTop", "marginRight", "marginBottom", "marginLeft",
+            "marginHorizontal", "marginVertical", "marginStart", "marginEnd",
+            "gap", "rowGap", "columnGap",
+            "position", "top", "right", "bottom", "left", "start", "end",
+            "aspectRatio", "display", "overflow", "direction",
+        )
     }
 
     private val mainHandler = Handler(Looper.getMainLooper())
@@ -81,20 +95,34 @@ class NativeBridge(private val context: Context) {
         }
 
         mainHandler.post {
-            var hasMutations = false
+            var needsLayout = false
             for (op in ops) {
                 try {
                     val opName = op.optString("op")
-                    if (!hasMutations && opName in treeMutationOps) {
-                        hasMutations = true
+                    if (!needsLayout && opName in treeMutationOps) {
+                        needsLayout = true
+                    }
+                    // Check if updateStyle changes any layout-affecting property
+                    if (!needsLayout && opName == "updateStyle") {
+                        val args = op.optJSONArray("args")
+                        val styleObj = args?.optJSONObject(1)
+                        if (styleObj != null) {
+                            val keys = styleObj.keys()
+                            while (keys.hasNext()) {
+                                if (keys.next() in layoutAffectingStyles) {
+                                    needsLayout = true
+                                    break
+                                }
+                            }
+                        }
                     }
                     handleOperation(op)
                 } catch (e: Exception) {
                     Log.e(TAG, "Error handling op '${op.optString("op")}': ${e.message}")
                 }
             }
-            // Only trigger layout when the batch mutated the view tree
-            if (hasMutations) {
+            // Trigger layout when tree was mutated or layout-affecting styles changed
+            if (needsLayout) {
                 triggerLayout()
             }
         }
@@ -380,6 +408,11 @@ class NativeBridge(private val context: Context) {
 
     /** Clear all registries. Called during hot reload after JS teardown. Must run on main thread. */
     fun clearAllRegistries() {
+        // Destroy all views via their factories before clearing maps
+        for ((_, view) in nodeViews) {
+            val factory = componentRegistry.factoryForView(view)
+            factory?.destroyView(view)
+        }
         nodeViews.clear()
         nodeTypes.clear()
         eventHandlers.clear()

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

@@ -98,9 +98,16 @@ class VListFactory : NativeComponentFactory {
                 cumulativeX += dx
                 cumulativeY += dy
 
-                // Dispatch scroll event with cumulative position
+                // Dispatch scroll event with cumulative position and dimensions
                 scrollHandlers[recyclerView]?.invoke(
-                    mapOf("x" to cumulativeX, "y" to cumulativeY)
+                    mapOf(
+                        "x" to cumulativeX,
+                        "y" to cumulativeY,
+                        "contentWidth" to (recyclerView.computeHorizontalScrollRange()),
+                        "contentHeight" to (recyclerView.computeVerticalScrollRange()),
+                        "layoutWidth" to recyclerView.width,
+                        "layoutHeight" to recyclerView.height,
+                    )
                 )
 
                 // endReached detection (threshold = 20% from bottom)
@@ -167,20 +174,33 @@ class VListFactory : NativeComponentFactory {
 }
 
 class VListAdapter(private val items: List<View>) : RecyclerView.Adapter<VListAdapter.VH>() {
-    class VH(val view: View) : RecyclerView.ViewHolder(view)
+    class VH(itemView: View) : RecyclerView.ViewHolder(itemView)
 
     override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): VH {
-        val v = items.getOrNull(viewType) ?: android.widget.FrameLayout(parent.context)
-        // Remove from any existing parent
-        (v.parent as? ViewGroup)?.removeView(v)
-        v.layoutParams = RecyclerView.LayoutParams(
-            RecyclerView.LayoutParams.MATCH_PARENT,
-            RecyclerView.LayoutParams.WRAP_CONTENT
-        )
-        return VH(v)
+        val container = android.widget.FrameLayout(parent.context).apply {
+            layoutParams = RecyclerView.LayoutParams(
+                RecyclerView.LayoutParams.MATCH_PARENT,
+                RecyclerView.LayoutParams.WRAP_CONTENT
+            )
+        }
+        return VH(container)
+    }
+
+    override fun onBindViewHolder(holder: VH, position: Int) {
+        val container = holder.itemView as android.widget.FrameLayout
+        // Remove the previous item view from this recycled container
+        container.removeAllViews()
+        val itemView = items.getOrNull(position) ?: return
+        // Remove from any existing parent (previous container or direct parent)
+        (itemView.parent as? ViewGroup)?.removeView(itemView)
+        container.addView(itemView, ViewGroup.LayoutParams(
+            ViewGroup.LayoutParams.MATCH_PARENT,
+            ViewGroup.LayoutParams.WRAP_CONTENT
+        ))
     }
 
-    override fun onBindViewHolder(holder: VH, position: Int) {}
     override fun getItemCount(): Int = items.size
-    override fun getItemViewType(position: Int): Int = position
+
+    // Use a single view type so RecyclerView can reuse all ViewHolders
+    override fun getItemViewType(position: Int): Int = 0
 }

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

@@ -64,6 +64,9 @@ class VScrollViewFactory : NativeComponentFactory {
         }
     }
 
+    private val scrollThrottles = mutableMapOf<SwipeRefreshLayout, EventThrottle>()
+    private val scrollListeners = mutableMapOf<SwipeRefreshLayout, android.view.ViewTreeObserver.OnScrollChangedListener>()
+
     override fun addEventListener(view: View, event: String, handler: (Any?) -> Unit) {
         val srf = view as? SwipeRefreshLayout ?: return
         val scroll = states[srf]?.scrollView
@@ -73,20 +76,38 @@ class VScrollViewFactory : NativeComponentFactory {
                 srf.setOnRefreshListener { handler(null) }
             }
             "scroll" -> {
-                scroll?.viewTreeObserver?.addOnScrollChangedListener {
-                    handler(mapOf(
-                        "contentOffset" to mapOf("x" to scroll.scrollX, "y" to scroll.scrollY)
+                val throttle = EventThrottle(intervalMs = 16L, handler = handler)
+                scrollThrottles[srf] = throttle
+                val listener = android.view.ViewTreeObserver.OnScrollChangedListener {
+                    val child = if (scroll != null && scroll.childCount > 0) scroll.getChildAt(0) else null
+                    throttle.fire(mapOf(
+                        "x" to (scroll?.scrollX ?: 0),
+                        "y" to (scroll?.scrollY ?: 0),
+                        "contentWidth" to (child?.width ?: scroll?.width ?: 0),
+                        "contentHeight" to (child?.height ?: scroll?.height ?: 0),
+                        "layoutWidth" to (scroll?.width ?: 0),
+                        "layoutHeight" to (scroll?.height ?: 0),
                     ))
                 }
+                scrollListeners[srf] = listener
+                scroll?.viewTreeObserver?.addOnScrollChangedListener(listener)
             }
         }
     }
 
     override fun removeEventListener(view: View, event: String) {
         val srf = view as? SwipeRefreshLayout ?: return
-        if (event == "refresh") {
-            srf.setOnRefreshListener(null)
-            srf.isEnabled = false
+        when (event) {
+            "refresh" -> {
+                srf.setOnRefreshListener(null)
+                srf.isEnabled = false
+            }
+            "scroll" -> {
+                scrollListeners.remove(srf)?.let { listener ->
+                    states[srf]?.scrollView?.viewTreeObserver?.removeOnScrollChangedListener(listener)
+                }
+                scrollThrottles.remove(srf)?.cancel()
+            }
         }
     }
 

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

@@ -48,18 +48,24 @@ class VSliderFactory : NativeComponentFactory {
         }
     }
 
+    private val throttles = mutableMapOf<SeekBar, EventThrottle>()
+
     override fun addEventListener(view: View, event: String, handler: (Any?) -> Unit) {
         val sb = view as? SeekBar ?: return
         when (event) {
             "change", "valueChange" -> {
                 changeHandlers[sb] = handler
+                val throttle = EventThrottle(intervalMs = 16L, handler = handler)
+                throttles[sb] = throttle
                 sb.setOnSeekBarChangeListener(object : SeekBar.OnSeekBarChangeListener {
                     override fun onProgressChanged(s: SeekBar, progress: Int, fromUser: Boolean) {
-                        if (fromUser) changeHandlers[s]?.invoke(mapOf("value" to progress.toFloat()))
+                        if (fromUser) throttle.fire(mapOf("value" to progress.toFloat() / s.max.toFloat()))
                     }
                     override fun onStartTrackingTouch(s: SeekBar) {}
                     override fun onStopTrackingTouch(s: SeekBar) {
-                        changeHandlers[s]?.invoke(mapOf("value" to s.progress.toFloat()))
+                        // Always deliver the final value immediately on release
+                        throttle.cancel()
+                        changeHandlers[s]?.invoke(mapOf("value" to s.progress.toFloat() / s.max.toFloat()))
                     }
                 })
             }
@@ -69,6 +75,7 @@ class VSliderFactory : NativeComponentFactory {
     override fun removeEventListener(view: View, event: String) {
         val sb = view as? SeekBar ?: return
         changeHandlers.remove(sb)
+        throttles.remove(sb)?.cancel()
         sb.setOnSeekBarChangeListener(null)
     }
 }

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

@@ -0,0 +1,57 @@
+package com.vuenative.core
+
+import android.os.Handler
+import android.os.Looper
+import android.os.SystemClock
+
+/**
+ * Throttles high-frequency event handlers to avoid flooding the JS bridge.
+ *
+ * When a high-frequency event (scroll, slider drag) fires many times per frame,
+ * each invocation becomes a bridge round-trip. This utility ensures at most one
+ * call per [intervalMs] milliseconds, with a trailing call to deliver the latest value.
+ *
+ * Default interval: 16ms (~60 FPS).
+ */
+class EventThrottle(
+    private val intervalMs: Long = 16L,
+    private val handler: (Any?) -> Unit
+) {
+    private var lastFireTime: Long = 0
+    private var pendingTrailing = false
+    private var latestPayload: Any? = null
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    private val trailingRunnable = Runnable {
+        lastFireTime = SystemClock.uptimeMillis()
+        pendingTrailing = false
+        handler(latestPayload)
+    }
+
+    /**
+     * Call this from the native event callback instead of the original handler.
+     * Fires immediately if enough time has elapsed, otherwise schedules a trailing call.
+     */
+    fun fire(payload: Any?) {
+        val now = SystemClock.uptimeMillis()
+        val elapsed = now - lastFireTime
+        latestPayload = payload
+
+        if (elapsed >= intervalMs) {
+            lastFireTime = now
+            pendingTrailing = false
+            mainHandler.removeCallbacks(trailingRunnable)
+            handler(payload)
+        } else if (!pendingTrailing) {
+            pendingTrailing = true
+            mainHandler.postDelayed(trailingRunnable, intervalMs - elapsed)
+        }
+        // If trailing is already pending, latestPayload is updated above
+    }
+
+    /** Cancel any pending trailing call. */
+    fun cancel() {
+        mainHandler.removeCallbacks(trailingRunnable)
+        pendingTrailing = false
+    }
+}

package/native/ios/VueNativeCore/Sources/VueNativeCore/Bridge/EventThrottle.swift

@@ -0,0 +1,79 @@
+#if canImport(UIKit)
+import Foundation
+
+/// Throttles high-frequency event handlers to avoid flooding the JS bridge.
+///
+/// When a high-frequency event (scroll, slider drag, text input) fires many
+/// times per frame, each invocation becomes a bridge round-trip. This utility
+/// ensures at most one call per `interval` seconds, with a trailing call
+/// to deliver the latest value.
+///
+/// Default interval: 16ms (~60 FPS). Callers can customize via `interval`.
+final class EventThrottle {
+
+    /// Minimum time between handler invocations (seconds).
+    let interval: TimeInterval
+
+    /// The throttled handler to call.
+    private let handler: (Any?) -> Void
+
+    /// Timestamp of the last invocation.
+    private var lastFireTime: CFTimeInterval = 0
+
+    /// Whether a trailing call is pending.
+    private var pendingTrailing = false
+
+    /// The most recent payload, used for the trailing call.
+    private var latestPayload: Any?
+
+    /// Timer for delivering the trailing call.
+    private var trailingTimer: DispatchSourceTimer?
+
+    /// Create a throttled event handler.
+    /// - Parameters:
+    ///   - interval: Minimum seconds between invocations. Default 0.016 (~60fps).
+    ///   - handler: The closure to invoke with the event payload.
+    init(interval: TimeInterval = 0.016, handler: @escaping (Any?) -> Void) {
+        self.interval = interval
+        self.handler = handler
+    }
+
+    deinit {
+        trailingTimer?.cancel()
+    }
+
+    /// Call this from the native event callback instead of the original handler.
+    /// Fires immediately if enough time has elapsed, otherwise schedules a trailing call.
+    func fire(_ payload: Any?) {
+        let now = CACurrentMediaTime()
+        let elapsed = now - lastFireTime
+
+        latestPayload = payload
+
+        if elapsed >= interval {
+            // Enough time has passed — fire immediately
+            lastFireTime = now
+            pendingTrailing = false
+            trailingTimer?.cancel()
+            trailingTimer = nil
+            handler(payload)
+        } else if !pendingTrailing {
+            // Schedule a trailing call for the remaining time
+            pendingTrailing = true
+            let remaining = interval - elapsed
+            let timer = DispatchSource.makeTimerSource(queue: .main)
+            timer.schedule(deadline: .now() + remaining)
+            timer.setEventHandler { [weak self] in
+                guard let self = self else { return }
+                self.lastFireTime = CACurrentMediaTime()
+                self.pendingTrailing = false
+                self.trailingTimer = nil
+                self.handler(self.latestPayload)
+            }
+            trailingTimer = timer
+            timer.resume()
+        }
+        // If a trailing call is already pending, just update latestPayload (done above)
+    }
+}
+#endif

package/native/ios/VueNativeCore/Sources/VueNativeCore/Bridge/JSPolyfills.swift

@@ -704,8 +704,21 @@ enum JSPolyfills {
 /// Produce a JSON-safe string literal (with quotes) for embedding in JS eval strings.
 private enum JSPolyfillsJSON {
     static func encode(_ str: String) -> String {
-        let data = (try? JSONSerialization.data(withJSONObject: str)) ?? Data()
-        return String(data: data, encoding: .utf8) ?? "\"\""
+        // Wrap in array so JSONSerialization gets a valid top-level type.
+        // String alone causes an NSException that try? cannot catch.
+        if let data = try? JSONSerialization.data(withJSONObject: [str]),
+           let json = String(data: data, encoding: .utf8),
+           json.count >= 2 {
+            return String(json.dropFirst().dropLast())
+        }
+        // Fallback: manual escaping
+        let escaped = str
+            .replacingOccurrences(of: "\\", with: "\\\\")
+            .replacingOccurrences(of: "\"", with: "\\\"")
+            .replacingOccurrences(of: "\n", with: "\\n")
+            .replacingOccurrences(of: "\r", with: "\\r")
+            .replacingOccurrences(of: "\t", with: "\\t")
+        return "\"\(escaped)\""
     }
 }