@thelacanians/vue-native-cli 0.4.14 → 0.4.15

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/NativeBridge.swift

@@ -69,6 +69,59 @@ public final class NativeBridge {
 
     private static var traitObserverKey: UInt8 = 99
 
+    // MARK: - Bridge Function Registration
+
+    /// Register `__VN_flushOperations`, `__VN_teardown`, `__VN_log`, and `__VN_handleError`
+    /// on the given JSContext. Called from both `initialize()` and `reloadWithBundle()`.
+    private func registerBridgeFunctions(on context: JSContext) {
+        let flushOps: @convention(block) (JSValue) -> Void = { [weak self] opsValue in
+            guard let self = self else { return }
+            guard let jsonString = opsValue.toString(), !jsonString.isEmpty else {
+                NSLog("[VueNative Bridge] Warning: Empty operations batch")
+                return
+            }
+
+            guard let data = jsonString.data(using: .utf8),
+                  let operations = try? JSONSerialization.jsonObject(with: data) as? [[String: Any]] else {
+                NSLog("[VueNative Bridge] Error: Failed to parse operations JSON")
+                return
+            }
+
+            DispatchQueue.main.async { [weak self] in
+                self?.processOperations(operations)
+            }
+        }
+        context.setObject(flushOps, forKeyedSubscript: "__VN_flushOperations" as NSString)
+
+        let teardown: @convention(block) () -> Void = { [weak self] in
+            NSLog("[VueNative] Teardown called from JS")
+            _ = self
+        }
+        context.setObject(teardown, forKeyedSubscript: "__VN_teardown" as NSString)
+
+        let log: @convention(block) (JSValue) -> Void = { message in
+            NSLog("[VueNative JS] \(message.toString() ?? "")")
+        }
+        context.setObject(log, forKeyedSubscript: "__VN_log" as NSString)
+
+        let handleError: @convention(block) (JSValue) -> Void = { errorInfoValue in
+            let jsonString = errorInfoValue.toString() ?? "{}"
+            NSLog("[VueNative Error] %@", jsonString)
+
+            if let data = jsonString.data(using: .utf8),
+               let info = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
+                let message = info["message"] as? String ?? "Unknown error"
+                let stack = info["stack"] as? String ?? ""
+                let componentName = info["componentName"] as? String ?? "unknown"
+                NSLog("[VueNative Error] Component: %@, Message: %@", componentName, message)
+                if !stack.isEmpty {
+                    NSLog("[VueNative Error] Stack: %@", stack)
+                }
+            }
+        }
+        context.setObject(handleError, forKeyedSubscript: "__VN_handleError" as NSString)
+    }
+
     // MARK: - Setup
 
     /// Initialize the bridge. Must be called after JSRuntime.initialize().
@@ -83,61 +136,7 @@ public final class NativeBridge {
         runtime.jsQueue.async { [weak self] in
             guard let self = self, let context = runtime.context else { return }
 
-            let flushOps: @convention(block) (JSValue) -> Void = { [weak self] opsValue in
-                guard let self = self else { return }
-                guard let jsonString = opsValue.toString(), !jsonString.isEmpty else {
-                    NSLog("[VueNative Bridge] Warning: Empty operations batch")
-                    return
-                }
-
-                // Parse JSON on the JS queue (avoid main thread work)
-                guard let data = jsonString.data(using: .utf8),
-                      let operations = try? JSONSerialization.jsonObject(with: data) as? [[String: Any]] else {
-                    NSLog("[VueNative Bridge] Error: Failed to parse operations JSON")
-                    return
-                }
-
-                // Process operations on the main thread
-                DispatchQueue.main.async { [weak self] in
-                    self?.processOperations(operations)
-                }
-            }
-            context.setObject(flushOps, forKeyedSubscript: "__VN_flushOperations" as NSString)
-
-            // Register __VN_teardown for graceful JS-side shutdown on hot reload
-            let teardown: @convention(block) () -> Void = { [weak self] in
-                // Graceful shutdown: bridge will be re-initialized on reload
-                NSLog("[VueNative] Teardown called from JS")
-                _ = self
-            }
-            context.setObject(teardown, forKeyedSubscript: "__VN_teardown" as NSString)
-
-            // Register __VN_log for debug logging from JS
-            let log: @convention(block) (JSValue) -> Void = { message in
-                NSLog("[VueNative JS] \(message.toString() ?? "")")
-            }
-            context.setObject(log, forKeyedSubscript: "__VN_log" as NSString)
-
-            // Register __VN_handleError for JS error reporting
-            // Called from JS with a JSON-encoded string containing error info
-            // (message, stack, componentName).
-            let handleError: @convention(block) (JSValue) -> Void = { errorInfoValue in
-                let jsonString = errorInfoValue.toString() ?? "{}"
-                NSLog("[VueNative Error] %@", jsonString)
-
-                // Try to extract structured fields for clearer logging
-                if let data = jsonString.data(using: .utf8),
-                   let info = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
-                    let message = info["message"] as? String ?? "Unknown error"
-                    let stack = info["stack"] as? String ?? ""
-                    let componentName = info["componentName"] as? String ?? "unknown"
-                    NSLog("[VueNative Error] Component: %@, Message: %@", componentName, message)
-                    if !stack.isEmpty {
-                        NSLog("[VueNative Error] Stack: %@", stack)
-                    }
-                }
-            }
-            context.setObject(handleError, forKeyedSubscript: "__VN_handleError" as NSString)
+            self.registerBridgeFunctions(on: context)
         }
 
         // Register all native modules synchronously so they are available
@@ -153,19 +152,44 @@ public final class NativeBridge {
         "setRootView", "setText", "setElementText"
     ]
 
+    /// Style properties that affect Yoga layout and require a layout pass when changed.
+    /// When a batch contains only updateStyle ops for non-layout properties (e.g.
+    /// backgroundColor, opacity), we skip the expensive layout recalculation.
+    private static let layoutAffectingStyles: Set<String> = [
+        // Dimensions
+        "width", "height", "minWidth", "minHeight", "maxWidth", "maxHeight",
+        // Flex
+        "flex", "flexGrow", "flexShrink", "flexBasis", "flexDirection",
+        "flexWrap", "alignItems", "alignSelf", "alignContent", "justifyContent",
+        // Spacing
+        "padding", "paddingTop", "paddingRight", "paddingBottom", "paddingLeft",
+        "paddingHorizontal", "paddingVertical", "paddingStart", "paddingEnd",
+        "margin", "marginTop", "marginRight", "marginBottom", "marginLeft",
+        "marginHorizontal", "marginVertical", "marginStart", "marginEnd",
+        // Gap
+        "gap", "rowGap", "columnGap",
+        // Position
+        "position", "top", "right", "bottom", "left", "start", "end",
+        // Other layout
+        "aspectRatio", "display", "overflow", "direction",
+    ]
+
     /// Process a batch of operations on the main thread.
     /// Each operation has an "op" key and "args" array.
-    /// Only triggers a Yoga layout pass when the batch contains tree mutations
-    /// (create, appendChild, insertBefore, removeChild, etc.). Batches that
-    /// only update props/styles/events skip the expensive layout recalculation.
+    /// Triggers a Yoga layout pass when the batch contains tree mutations
+    /// (create, appendChild, insertBefore, removeChild, etc.) OR style changes
+    /// that affect layout (width, height, padding, margin, flex, etc.).
+    /// Batches that only update visual styles/events skip the expensive layout.
     ///
     /// Access: internal (not private) so that `@testable import` can exercise
     /// operation handling without going through JSContext.
     func processOperations(_ operations: [[String: Any]]) {
         dispatchPrecondition(condition: .onQueue(.main))
+        #if DEBUG
         NSLog("[VueNative Bridge] Processing %d operations", operations.count)
+        #endif
 
-        var hasMutations = false
+        var needsLayout = false
 
         for operation in operations {
             guard let op = operation["op"] as? String,
@@ -174,8 +198,20 @@ public final class NativeBridge {
                 continue
             }
 
-            if !hasMutations && NativeBridge.treeMutationOps.contains(op) {
-                hasMutations = true
+            if !needsLayout && NativeBridge.treeMutationOps.contains(op) {
+                needsLayout = true
+            }
+
+            // Check if updateStyle changes any layout-affecting property
+            if !needsLayout && op == "updateStyle",
+               args.count >= 2,
+               let styles = args[1] as? [String: Any] {
+                for key in styles.keys {
+                    if NativeBridge.layoutAffectingStyles.contains(key) {
+                        needsLayout = true
+                        break
+                    }
+                }
             }
 
             switch op {
@@ -212,8 +248,8 @@ public final class NativeBridge {
             }
         }
 
-        // Only trigger layout recalculation when the batch mutated the view tree
-        if hasMutations {
+        // Trigger layout when tree was mutated or layout-affecting styles changed
+        if needsLayout {
             triggerLayout()
         }
     }
@@ -388,8 +424,12 @@ public final class NativeBridge {
         if let factory = ComponentRegistry.factory(for: parentView) {
             factory.insertChild(childView, into: container, before: beforeView)
         } else if let index = container.subviews.firstIndex(of: beforeView) {
-            container.flex.addItem(childView)
             container.insertSubview(childView, at: index)
+            // Rebuild Yoga children to match UIView subview order
+            container.flex.removeAllChildren()
+            for subview in container.subviews {
+                container.flex.addItem(subview)
+            }
         } else {
             container.flex.addItem(childView)
         }
@@ -781,55 +821,9 @@ public final class NativeBridge {
                 return
             }
 
-            // Re-register __VN_flushOperations, __VN_teardown, __VN_log on new context
+            // Re-register bridge functions on new context
             guard let context = self.runtime.context else { return }
-
-            let flushOps: @convention(block) (JSValue) -> Void = { [weak self] opsValue in
-                guard let self = self else { return }
-                guard let jsonString = opsValue.toString(), !jsonString.isEmpty else {
-                    NSLog("[VueNative Bridge] Warning: Empty operations batch")
-                    return
-                }
-
-                guard let data = jsonString.data(using: .utf8),
-                      let operations = try? JSONSerialization.jsonObject(with: data) as? [[String: Any]] else {
-                    NSLog("[VueNative Bridge] Error: Failed to parse operations JSON")
-                    return
-                }
-
-                DispatchQueue.main.async { [weak self] in
-                    self?.processOperations(operations)
-                }
-            }
-            context.setObject(flushOps, forKeyedSubscript: "__VN_flushOperations" as NSString)
-
-            let teardown: @convention(block) () -> Void = { [weak self] in
-                NSLog("[VueNative] Teardown called from JS")
-                _ = self
-            }
-            context.setObject(teardown, forKeyedSubscript: "__VN_teardown" as NSString)
-
-            let log: @convention(block) (JSValue) -> Void = { message in
-                NSLog("[VueNative JS] \(message.toString() ?? "")")
-            }
-            context.setObject(log, forKeyedSubscript: "__VN_log" as NSString)
-
-            let handleError: @convention(block) (JSValue) -> Void = { errorInfoValue in
-                let jsonString = errorInfoValue.toString() ?? "{}"
-                NSLog("[VueNative Error] %@", jsonString)
-
-                if let data = jsonString.data(using: .utf8),
-                   let info = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
-                    let message = info["message"] as? String ?? "Unknown error"
-                    let stack = info["stack"] as? String ?? ""
-                    let componentName = info["componentName"] as? String ?? "unknown"
-                    NSLog("[VueNative Error] Component: %@, Message: %@", componentName, message)
-                    if !stack.isEmpty {
-                        NSLog("[VueNative Error] Stack: %@", stack)
-                    }
-                }
-            }
-            context.setObject(handleError, forKeyedSubscript: "__VN_handleError" as NSString)
+            self.registerBridgeFunctions(on: context)
 
             NSLog("[VueNative Bridge] reloadWithBundle: bridge re-registered on new context")
         }