@thelacanians/vue-native-cli 0.4.14 → 0.6.0

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

@@ -6,6 +6,7 @@ import android.os.Looper
 import android.util.Log
 import android.view.View
 import android.view.ViewGroup
+import android.widget.FrameLayout
 import org.json.JSONArray
 import org.json.JSONObject
 
@@ -23,6 +24,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())
@@ -53,6 +68,26 @@ class NativeBridge(private val context: Context) {
     /** The container view from the host Activity — where the root view is attached. */
     var hostContainer: ViewGroup? = null
 
+    // -- Teleport support --
+    /** Maps teleport marker IDs for cleanup */
+    private val teleportMarkers = mutableMapOf<Int, Pair<Int, Int>>()
+
+    /** Maps parent node IDs to their teleport containers */
+    private val teleportContainers = mutableMapOf<Int, ViewGroup>()
+
+    /** Modal container for teleporting modals */
+    private val modalContainer: FrameLayout by lazy {
+        FrameLayout(context).apply {
+            layoutParams = FrameLayout.LayoutParams(
+                FrameLayout.LayoutParams.MATCH_PARENT,
+                FrameLayout.LayoutParams.MATCH_PARENT
+            )
+            setBackgroundColor(android.graphics.Color.TRANSPARENT)
+            isClickable = true
+            isFocusable = false
+        }
+    }
+
     /** Called when native fires an event to JS (nodeId, eventName, payloadJson). */
     var onFireEvent: ((nodeId: Int, eventName: String, payloadJson: String) -> Unit)? = null
 
@@ -81,20 +116,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()
             }
         }
@@ -115,6 +164,9 @@ class NativeBridge(private val context: Context) {
             "insertBefore" -> handleInsertBefore(args)
             "removeChild" -> handleRemoveChild(args)
             "setRootView" -> handleSetRootView(args)
+            "createTeleport" -> handleCreateTeleport(args)
+            "removeTeleport" -> handleRemoveTeleport(args)
+            "teleportTo" -> handleTeleportTo(args)
             "addEventListener" -> handleAddEventListener(args)
             "removeEventListener" -> handleRemoveEventListener(args)
             "invokeNativeModule" -> handleInvokeNativeModule(args)
@@ -283,6 +335,100 @@ class NativeBridge(private val context: Context) {
                 ViewGroup.LayoutParams.MATCH_PARENT
             )
         )
+
+        // Add modal container for teleport
+        container.addView(
+            modalContainer,
+            ViewGroup.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.MATCH_PARENT
+            )
+        )
+    }
+
+    // -- Teleport handlers --
+
+    private fun handleCreateTeleport(args: JSONArray) {
+        val parentId = args.getInt(0)
+        val startId = args.getInt(1)
+        val endId = args.getInt(2)
+
+        val parentView = nodeViews[parentId] ?: run {
+            Log.w(TAG, "Parent view not found for teleport (id: $parentId)")
+            return
+        }
+
+        // Store teleport marker IDs
+        teleportMarkers[parentId] = Pair(startId, endId)
+
+        // Create container for teleported content
+        val container = FrameLayout(context).apply {
+            id = View.generateViewId()
+            setBackgroundColor(android.graphics.Color.TRANSPARENT)
+            isClickable = true
+            isFocusable = false
+        }
+
+        if (parentView is ViewGroup) {
+            parentView.addView(container)
+            teleportContainers[parentId] = container
+        }
+
+        Log.d(TAG, "Created teleport container for parent $parentId")
+    }
+
+    private fun handleRemoveTeleport(args: JSONArray) {
+        val parentId = args.getInt(0)
+
+        // Remove teleport container
+        teleportContainers.remove(parentId)?.let { container ->
+            mainHandler.post {
+                (container.parent as? ViewGroup)?.removeView(container)
+            }
+        }
+
+        // Clean up markers
+        teleportMarkers.remove(parentId)
+
+        Log.d(TAG, "Removed teleport container for parent $parentId")
+    }
+
+    private fun handleTeleportTo(args: JSONArray) {
+        val target = args.getString(0)
+        val nodeId = args.getInt(1)
+
+        val targetView = getTeleportTarget(target) ?: run {
+            Log.w(TAG, "Teleport target '$target' not found")
+            return
+        }
+
+        val childView = nodeViews[nodeId] ?: run {
+            Log.w(TAG, "Node view not found for teleport (id: $nodeId)")
+            return
+        }
+
+        // Move view to teleport target
+        mainHandler.post {
+            (childView.parent as? ViewGroup)?.removeView(childView)
+            targetView.addView(childView)
+            childView.requestLayout()
+        }
+
+        Log.d(TAG, "Teleported node $nodeId to target '$target'")
+    }
+
+    private fun getTeleportTarget(target: String): ViewGroup? {
+        return when (target) {
+            "root" -> rootView as? ViewGroup
+            "modal" -> {
+                // Ensure modal container is added to root if not already
+                if (modalContainer.parent == null && rootView != null) {
+                    (rootView as? ViewGroup)?.addView(modalContainer)
+                }
+                modalContainer
+            }
+            else -> null
+        }
     }
 
     private fun handleAddEventListener(args: JSONArray) {
@@ -380,6 +526,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/Components/Factories/VViewFactory.kt

@@ -1,10 +1,16 @@
 package com.vuenative.core
 
 import android.content.Context
+import android.view.GestureDetector
+import android.view.MotionEvent
+import android.view.ScaleGestureDetector
 import android.view.View
 import android.view.ViewGroup
 import com.google.android.flexbox.FlexDirection
 import com.google.android.flexbox.FlexboxLayout
+import kotlin.math.abs
+import kotlin.math.atan2
+import kotlin.math.sqrt
 
 class VViewFactory : NativeComponentFactory {
     override fun createView(context: Context): View {
@@ -28,6 +34,125 @@ class VViewFactory : NativeComponentFactory {
                 handler(null)
                 true
             }
+            "pan", "swipeLeft", "swipeRight", "swipeUp", "swipeDown", "pinch", "rotate" -> {
+                setupGestureListener(view, event, handler)
+            }
+        }
+    }
+
+    private fun setupGestureListener(view: View, event: String, handler: (Any?) -> Unit) {
+        val context = view.context
+
+        when (event) {
+            "pan" -> {
+                val gestureDetector = GestureDetector(context, object : GestureDetector.SimpleOnGestureListener() {
+                    override fun onScroll(e1: MotionEvent?, e2: MotionEvent, distanceX: Float, distanceY: Float): Boolean {
+                        val payload = mapOf(
+                            "translationX" to -distanceX,
+                            "translationY" to -distanceY,
+                            "velocityX" to 0f,
+                            "velocityY" to 0f,
+                            "state" to "changed"
+                        )
+                        handler(payload)
+                        return true
+                    }
+                })
+                view.setOnTouchListener { _, motionEvent ->
+                    gestureDetector.onTouchEvent(motionEvent)
+                    false
+                }
+            }
+            "swipeLeft" -> {
+                val gestureDetector = GestureDetector(context, object : GestureDetector.SimpleOnGestureListener() {
+                    override fun onFling(e1: MotionEvent?, e2: MotionEvent, velocityX: Float, velocityY: Float): Boolean {
+                        if (abs(velocityX) > abs(velocityY) && velocityX < 0) {
+                            val payload = mapOf("direction" to "left")
+                            handler(payload)
+                        }
+                        return true
+                    }
+                })
+                view.setOnTouchListener { _, motionEvent ->
+                    gestureDetector.onTouchEvent(motionEvent)
+                    false
+                }
+            }
+            "swipeRight" -> {
+                val gestureDetector = GestureDetector(context, object : GestureDetector.SimpleOnGestureListener() {
+                    override fun onFling(e1: MotionEvent?, e2: MotionEvent, velocityX: Float, velocityY: Float): Boolean {
+                        if (abs(velocityX) > abs(velocityY) && velocityX > 0) {
+                            val payload = mapOf("direction" to "right")
+                            handler(payload)
+                        }
+                        return true
+                    }
+                })
+                view.setOnTouchListener { _, motionEvent ->
+                    gestureDetector.onTouchEvent(motionEvent)
+                    false
+                }
+            }
+            "swipeUp" -> {
+                val gestureDetector = GestureDetector(context, object : GestureDetector.SimpleOnGestureListener() {
+                    override fun onFling(e1: MotionEvent?, e2: MotionEvent, velocityX: Float, velocityY: Float): Boolean {
+                        if (abs(velocityY) > abs(velocityX) && velocityY < 0) {
+                            val payload = mapOf("direction" to "up")
+                            handler(payload)
+                        }
+                        return true
+                    }
+                })
+                view.setOnTouchListener { _, motionEvent ->
+                    gestureDetector.onTouchEvent(motionEvent)
+                    false
+                }
+            }
+            "swipeDown" -> {
+                val gestureDetector = GestureDetector(context, object : GestureDetector.SimpleOnGestureListener() {
+                    override fun onFling(e1: MotionEvent?, e2: MotionEvent, velocityX: Float, velocityY: Float): Boolean {
+                        if (abs(velocityY) > abs(velocityX) && velocityY > 0) {
+                            val payload = mapOf("direction" to "down")
+                            handler(payload)
+                        }
+                        return true
+                    }
+                })
+                view.setOnTouchListener { _, motionEvent ->
+                    gestureDetector.onTouchEvent(motionEvent)
+                    false
+                }
+            }
+            "pinch" -> {
+                val scaleGestureDetector = ScaleGestureDetector(context, object : ScaleGestureDetector.SimpleOnScaleGestureListener() {
+                    override fun onScale(detector: ScaleGestureDetector): Boolean {
+                        val payload = mapOf(
+                            "scale" to detector.scaleFactor,
+                            "velocity" to detector.currentSpan,
+                            "state" to "changed"
+                        )
+                        handler(payload)
+                        return true
+                    }
+                })
+                view.setOnTouchListener { _, motionEvent ->
+                    scaleGestureDetector.onTouchEvent(motionEvent)
+                    false
+                }
+            }
+            "rotate" -> {
+                val rotationDetector = RotationGestureDetector { rotation ->
+                    val payload = mapOf(
+                        "rotation" to rotation,
+                        "state" to "changed"
+                    )
+                    handler(payload)
+                }
+                view.setOnTouchListener { _, motionEvent ->
+                    rotationDetector.onTouchEvent(motionEvent)
+                    false
+                }
+            }
         }
     }
 
@@ -35,6 +160,7 @@ class VViewFactory : NativeComponentFactory {
         when (event) {
             "press" -> view.setOnClickListener(null)
             "longPress" -> view.setOnLongClickListener(null)
+            else -> view.setOnTouchListener(null)
         }
     }
 
@@ -51,4 +177,55 @@ class VViewFactory : NativeComponentFactory {
     override fun removeChild(parent: View, child: View) {
         (parent as? ViewGroup)?.removeView(child)
     }
-}
+
+    /**
+     * RotationGestureDetector detectsstwo-finger rotation gestures.
+     * Calculates rotation angle between two touch points.
+     */
+    private class RotationGestureDetector(
+        private val onRotation: (Float) -> Unit
+    ) {
+        private var previousAngle: Float = 0f
+        private var isTracking = false
+
+        fun onTouchEvent(event: MotionEvent): Boolean {
+            when (event.actionMasked) {
+                MotionEvent.ACTION_POINTER_DOWN -> {
+                    if (event.pointerCount == 2) {
+                        previousAngle = calculateAngle(event)
+                        isTracking = true
+                    }
+                }
+                MotionEvent.ACTION_MOVE -> {
+                    if (isTracking && event.pointerCount == 2) {
+                        val currentAngle = calculateAngle(event)
+                        val deltaAngle = currentAngle - previousAngle
+                        
+                        // Normalize angle to -PI to PI range
+                        val normalizedDelta = when {
+                            deltaAngle > Math.PI -> deltaAngle - (2 * Math.PI).toFloat()
+                            deltaAngle < -Math.PI -> deltaAngle + (2 * Math.PI).toFloat()
+                            else -> deltaAngle
+                        }
+                        
+                        onRotation(normalizedDelta)
+                        previousAngle = currentAngle
+                    }
+                }
+                MotionEvent.ACTION_POINTER_UP, MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
+                    isTracking = false
+                }
+            }
+            return true
+        }
+
+        private fun calculateAngle(event: MotionEvent): Float {
+            if (event.pointerCount < 2) return 0f
+            
+            val dx = event.getX(1) - event.getX(0)
+            val dy = event.getY(1) - event.getY(0)
+            
+            return atan2(dy, dx)
+        }
+    }
+}

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/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Modules/GeneratedModuleRegistry.kt

@@ -0,0 +1,28 @@
+// ────────────────────────────────────────────────────────────────────────────────
+//  Auto-Generated Module Registration
+// ────────────────────────────────────────────────────────────────────────────────
+//
+//  ⚠️  WARNING: This file is auto-generated. DO NOT EDIT MANUALLY.
+//      Changes will be overwritten by the vue-native-codegen tool.
+//
+//  Generated: {{GENERATED_DATE}}
+//
+//  This file registers all native modules generated from <native> blocks
+//  in Vue SFC files.
+//
+// ────────────────────────────────────────────────────────────────────────────────
+
+package com.vuenative.core
+
+/**
+ * Register all generated native modules from <native> blocks
+ * This function is called automatically after registerDefaults()
+ */
+fun NativeModuleRegistry.registerGeneratedModules() {
+    // Generated modules will be registered here
+    // Example:
+    // register(HapticsModule())
+    // register(CameraModule())
+
+    // This function is called automatically after registerDefaults()
+}

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

@@ -58,6 +58,9 @@ class NativeModuleRegistry private constructor(private val context: Context) {
             register(m)
             m.initialize(ctx, bridge)
         }
+
+        // Register generated modules from <native> blocks
+        registerGeneratedModules()
     }
 
     fun getModule(name: String): NativeModule? = modules[name]