@thelacanians/vue-native-cli 0.4.2 → 0.4.4

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

@@ -0,0 +1,207 @@
+package com.vuenative.core
+
+import android.content.Context
+import android.os.Handler
+import android.os.HandlerThread
+import android.os.Looper
+import android.util.Log
+import com.eclipsesource.v8.V8
+import com.eclipsesource.v8.JavaVoidCallback
+
+/**
+ * Core JavaScript runtime. Wraps J2V8's V8 engine on a dedicated HandlerThread.
+ *
+ * Thread safety contract:
+ * - All V8 access happens exclusively on jsThread via jsHandler
+ * - Never pass J2V8 objects (V8Array, V8Object) across threads
+ * - All View operations happen on main thread via mainHandler
+ */
+class JSRuntime(private val context: Context) {
+
+    companion object {
+        private const val TAG = "VueNative-JSRuntime"
+    }
+
+    /** Dedicated JS thread. All V8 operations run here. */
+    private val jsThread = HandlerThread("VueNative-JS").apply { start() }
+
+    /** Handler for posting work to the JS thread. */
+    val jsHandler = Handler(jsThread.looper)
+
+    /** Handler for posting work to the main (UI) thread. */
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    /** V8 runtime instance. Only access from jsThread. */
+    private var v8: V8? = null
+
+    /** Whether the runtime has been initialized. */
+    private var isInitialized = false
+
+    /** The NativeBridge instance — manages view registry and operations. */
+    val bridge = NativeBridge(context)
+
+    /** Startup time in milliseconds for performance.now(). */
+    val startTimeMs: Long = System.currentTimeMillis()
+
+    init {
+        // Wire bridge callbacks
+        bridge.onFireEvent = { nodeId, eventName, payloadJson ->
+            // Called on main thread — dispatch to JS
+            jsHandler.post {
+                try {
+                    if (nodeId == -1 && eventName == "__callback__") {
+                        // Native module async callback — route to __VN_resolveCallback
+                        v8?.executeVoidScript(
+                            "if(typeof __VN_resolveCallback==='function'){" +
+                            "var _d=$payloadJson;" +
+                            "__VN_resolveCallback(_d.callbackId,_d.result,_d.error);}"
+                        )
+                    } else {
+                        v8?.executeVoidScript(
+                            "if(typeof __VN_handleEvent==='function')" +
+                            "__VN_handleEvent($nodeId,${encodeJs(eventName)},$payloadJson)"
+                        )
+                    }
+                } catch (e: Exception) {
+                    Log.e(TAG, "Error dispatching event $eventName to JS", e)
+                }
+            }
+        }
+        bridge.onDispatchGlobalEvent = { eventName, payloadJson ->
+            jsHandler.post {
+                try {
+                    v8?.executeVoidScript(
+                        "if(typeof __VN_handleGlobalEvent==='function')" +
+                        "__VN_handleGlobalEvent(${encodeJs(eventName)},${encodeJs(payloadJson)})"
+                    )
+                } catch (e: Exception) {
+                    Log.e(TAG, "Error dispatching global event $eventName", e)
+                }
+            }
+        }
+    }
+
+    /** Initialize the V8 runtime on the JS thread. Calls completion when ready. */
+    fun initialize(completion: (() -> Unit)? = null) {
+        jsHandler.post {
+            if (isInitialized) {
+                mainHandler.post { completion?.invoke() }
+                return@post
+            }
+            try {
+                v8 = V8.createV8Runtime()
+                JSPolyfills.register(this)
+                // Register __VN_flushOperations — JS calls this to send batched ops to native
+                v8?.registerJavaMethod(JavaVoidCallback { _, params ->
+                    try {
+                        val json = if (params.length() > 0) params.getString(0) else "[]"
+                        bridge.processOperations(json)
+                    } finally {
+                        params.close()
+                    }
+                }, "__VN_flushOperations")
+
+                // Register __VN_handleError — JS calls this to report errors to native
+                v8?.registerJavaMethod(JavaVoidCallback { _, params ->
+                    try {
+                        val errorJson = if (params.length() > 0) params.getString(0) else "{}"
+                        Log.e(TAG, "[VueNative Error] $errorJson")
+                    } finally {
+                        params.close()
+                    }
+                }, "__VN_handleError")
+
+                isInitialized = true
+                Log.d(TAG, "V8 runtime initialized")
+                mainHandler.post { completion?.invoke() }
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to initialize V8 runtime", e)
+            }
+        }
+    }
+
+    /** Load and execute a JavaScript bundle. Must be called after initialize().
+     *  @param onComplete Optional callback invoked on main thread: (success, errorMessage). */
+    fun loadBundle(bundleCode: String, onComplete: ((Boolean, String?) -> Unit)? = null) {
+        jsHandler.post {
+            try {
+                v8?.executeVoidScript(bundleCode)
+                Log.d(TAG, "Bundle loaded successfully")
+                mainHandler.post { onComplete?.invoke(true, null) }
+            } catch (e: Exception) {
+                Log.e(TAG, "Error loading bundle", e)
+                val msg = e.message ?: "Unknown error"
+                mainHandler.post {
+                    ErrorOverlayView.show(context, msg)
+                    onComplete?.invoke(false, msg)
+                }
+            }
+        }
+    }
+
+    /** Post work to the JS thread. */
+    fun runOnJsThread(block: () -> Unit) {
+        jsHandler.post(block)
+    }
+
+    /** Post work to the main (UI) thread. */
+    fun runOnMainThread(block: () -> Unit) {
+        mainHandler.post(block)
+    }
+
+    /** Execute a void script on the JS thread. Safe to call from any thread. */
+    fun executeVoidScript(script: String) {
+        jsHandler.post {
+            try {
+                v8?.executeVoidScript(script)
+            } catch (e: Exception) {
+                Log.e(TAG, "Script error: ${e.message}")
+            }
+        }
+    }
+
+    /** Register a void Java method as a global JS function. Call from JS thread only. */
+    fun registerVoidCallback(name: String, callback: (Array<Any?>) -> Unit) {
+        jsHandler.post {
+            v8?.registerJavaMethod(JavaVoidCallback { _, params ->
+                try {
+                    val args = Array<Any?>(params.length()) { i ->
+                        when {
+                            params.getType(i) == 1 -> params.getInteger(i)  // INT
+                            params.getType(i) == 2 -> params.getDouble(i)   // DOUBLE
+                            params.getType(i) == 3 -> params.getBoolean(i)  // BOOLEAN
+                            params.getType(i) == 4 -> params.getString(i)   // STRING
+                            else -> null
+                        }
+                    }
+                    callback(args)
+                } finally {
+                    params.close()
+                }
+            }, name)
+        }
+    }
+
+    /** Access raw V8 instance — only call from JS thread! */
+    fun withV8(block: (V8) -> Unit) {
+        jsHandler.post {
+            v8?.let(block)
+        }
+    }
+
+    /** Get raw V8 — ONLY call from JS thread. Returns null if not initialized. */
+    fun v8(): V8? = v8
+
+    /** Release the V8 runtime. */
+    fun release() {
+        jsHandler.post {
+            v8?.release(true)
+            v8 = null
+            isInitialized = false
+        }
+        jsThread.quitSafely()
+    }
+
+    private fun encodeJs(value: String): String =
+        "\"${value.replace("\\", "\\\\").replace("\"", "\\\"").replace("\n", "\\n").replace("\r", "\\r")}\""
+}

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

@@ -0,0 +1,417 @@
+package com.vuenative.core
+
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import android.view.View
+import android.view.ViewGroup
+import org.json.JSONArray
+import org.json.JSONObject
+
+/**
+ * Receives batched JS operations, dispatches them to the native view system,
+ * and provides event firing back to JS.
+ */
+class NativeBridge(private val context: Context) {
+
+    companion object {
+        private const val TAG = "VueNative-Bridge"
+
+        /** Operations that mutate the view tree and require a layout pass. */
+        private val treeMutationOps = setOf(
+            "create", "createText", "appendChild", "insertBefore", "removeChild",
+            "setRootView", "setText", "setElementText"
+        )
+    }
+
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    // -- View registry --
+    /** Maps node IDs to native Views. Accessed only on main thread. */
+    val nodeViews = mutableMapOf<Int, View>()
+
+    /** Maps node IDs to component type strings. Accessed only on main thread. */
+    val nodeTypes = mutableMapOf<Int, String>()
+
+    /** Maps "nodeId:eventName" to handler. Accessed only on main thread. */
+    val eventHandlers = mutableMapOf<String, (Any?) -> Unit>()
+
+    /** Reverse index: maps nodeId to the set of event keys registered for that node.
+     *  Enables O(k) cleanup where k = handlers per node, instead of O(n) full scan. */
+    private val eventKeysPerNode = mutableMapOf<Int, MutableSet<String>>()
+
+    /** Maps child nodeId to parent nodeId. Accessed only on main thread. */
+    val nodeParents = mutableMapOf<Int, Int>()
+
+    /** Reverse index: maps parent nodeId to ordered list of child nodeIds. O(1) children lookup. */
+    val nodeChildren = mutableMapOf<Int, MutableList<Int>>()
+
+    /** The root view of the tree — set when __ROOT__ node is made the root view. */
+    var rootView: View? = null
+
+    /** The container view from the host Activity — where the root view is attached. */
+    var hostContainer: ViewGroup? = null
+
+    /** Called when native fires an event to JS (nodeId, eventName, payloadJson). */
+    var onFireEvent: ((nodeId: Int, eventName: String, payloadJson: String) -> Unit)? = null
+
+    /** Called when a module dispatches a global event to JS (eventName, payloadJson). */
+    var onDispatchGlobalEvent: ((eventName: String, payloadJson: String) -> Unit)? = null
+
+    private val componentRegistry: ComponentRegistry by lazy { ComponentRegistry.getInstance(context) }
+
+    // -------------------------------------------------------------------------
+    // Operation processing — called from JS thread
+    // -------------------------------------------------------------------------
+
+    /** Called from JS thread via __VN_flushOperations. Parses JSON and dispatches to main. */
+    fun processOperations(json: String) {
+        val operations: JSONArray = try {
+            JSONArray(json)
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to parse operations JSON: ${e.message}")
+            return
+        }
+
+        // Collect ops before dispatching to main thread
+        val ops = ArrayList<JSONObject>(operations.length())
+        for (i in 0 until operations.length()) {
+            ops.add(operations.getJSONObject(i))
+        }
+
+        mainHandler.post {
+            var hasMutations = false
+            for (op in ops) {
+                try {
+                    val opName = op.optString("op")
+                    if (!hasMutations && opName in treeMutationOps) {
+                        hasMutations = true
+                    }
+                    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) {
+                triggerLayout()
+            }
+        }
+    }
+
+    private fun handleOperation(op: JSONObject) {
+        val opName = op.getString("op")
+        val args = op.optJSONArray("args") ?: JSONArray()
+
+        when (opName) {
+            "create"               -> handleCreate(args)
+            "createText"           -> handleCreateText(args)
+            "setText"              -> handleSetText(args)
+            "setElementText"       -> handleSetElementText(args)
+            "updateProp"           -> handleUpdateProp(args)
+            "updateStyle"          -> handleUpdateStyle(args)
+            "appendChild"          -> handleAppendChild(args)
+            "insertBefore"         -> handleInsertBefore(args)
+            "removeChild"          -> handleRemoveChild(args)
+            "setRootView"          -> handleSetRootView(args)
+            "addEventListener"     -> handleAddEventListener(args)
+            "removeEventListener"  -> handleRemoveEventListener(args)
+            "invokeNativeModule"   -> handleInvokeNativeModule(args)
+            "invokeNativeModuleSync" -> handleInvokeNativeModuleSync(args)
+            else -> Log.w(TAG, "Unknown operation: $opName")
+        }
+    }
+
+    private fun handleCreate(args: JSONArray) {
+        val nodeId = args.getInt(0)
+        val type = args.getString(1)
+        val view = componentRegistry.createView(type) ?: return
+        nodeViews[nodeId] = view
+        nodeTypes[nodeId] = type
+    }
+
+    private fun handleCreateText(args: JSONArray) {
+        // Text nodes — create a special "text node" view
+        val nodeId = args.getInt(0)
+        val text = args.getString(1)
+        val textView = VTextNodeView(context).apply { setText(text) }
+        nodeViews[nodeId] = textView
+        nodeTypes[nodeId] = "__TEXT__"
+    }
+
+    private fun handleSetText(args: JSONArray) {
+        val nodeId = args.getInt(0)
+        val text = args.getString(1)
+        val view = nodeViews[nodeId] ?: return
+        (view as? VTextNodeView)?.setText(text)
+    }
+
+    private fun handleSetElementText(args: JSONArray) {
+        val nodeId = args.getInt(0)
+        val text = args.getString(1)
+        val view = nodeViews[nodeId] ?: return
+        // Delegate to the factory
+        val factory = componentRegistry.factoryForType(nodeTypes[nodeId] ?: return) ?: return
+        factory.updateProp(view, "text", text)
+    }
+
+    private fun handleUpdateProp(args: JSONArray) {
+        val nodeId = args.getInt(0)
+        val key = args.getString(1)
+        val value = if (args.isNull(2)) null else args.get(2)
+        val view = nodeViews[nodeId] ?: return
+        val factory = componentRegistry.factoryForView(view) ?: return
+        factory.updateProp(view, key, value)
+    }
+
+    private fun handleUpdateStyle(args: JSONArray) {
+        val nodeId = args.getInt(0)
+        val styleObj = args.optJSONObject(1) ?: return
+        val view = nodeViews[nodeId] ?: return
+        val factory = componentRegistry.factoryForView(view) ?: return
+        val iter = styleObj.keys()
+        while (iter.hasNext()) {
+            val key = iter.next()
+            val value = if (styleObj.isNull(key)) null else styleObj.get(key)
+            factory.updateProp(view, key, value)
+        }
+    }
+
+    private fun handleAppendChild(args: JSONArray) {
+        val parentId = args.getInt(0)
+        val childId = args.getInt(1)
+        val parent = nodeViews[parentId] ?: return
+        val child = nodeViews[childId] ?: return
+        nodeParents[childId] = parentId
+        nodeChildren.getOrPut(parentId) { mutableListOf() }.add(childId)
+
+        val factory = componentRegistry.factoryForView(parent)
+        if (factory != null) {
+            val idx = (parent as? ViewGroup)?.childCount ?: 0
+            factory.insertChild(parent, child, idx)
+        } else {
+            (parent as? ViewGroup)?.addView(child)
+        }
+    }
+
+    private fun handleInsertBefore(args: JSONArray) {
+        val parentId = args.getInt(0)
+        val childId = args.getInt(1)
+        val anchorId = args.getInt(2)
+        val parent = nodeViews[parentId] ?: return
+        val child = nodeViews[childId] ?: return
+        val anchor = nodeViews[anchorId] ?: return
+        nodeParents[childId] = parentId
+        // Insert into nodeChildren at the correct position (before anchorId)
+        val siblings = nodeChildren.getOrPut(parentId) { mutableListOf() }
+        val anchorIndex = siblings.indexOf(anchorId)
+        if (anchorIndex >= 0) {
+            siblings.add(anchorIndex, childId)
+        } else {
+            siblings.add(childId)
+        }
+
+        val vg = parent as? ViewGroup ?: return
+        val anchorIdx = vg.indexOfChild(anchor)
+        val insertIdx = if (anchorIdx < 0) vg.childCount else anchorIdx
+
+        val factory = componentRegistry.factoryForView(parent)
+        if (factory != null) {
+            factory.insertChild(parent, child, insertIdx)
+        } else {
+            vg.addView(child, insertIdx)
+        }
+    }
+
+    private fun handleRemoveChild(args: JSONArray) {
+        val childId = args.getInt(0)
+        val child = nodeViews[childId] ?: return
+        val parentId = nodeParents[childId]
+        val parent = parentId?.let { nodeViews[it] }
+
+        if (parent != null) {
+            val factory = componentRegistry.factoryForView(parent)
+            if (factory != null) {
+                factory.removeChild(parent, child)
+            } else {
+                (parent as? ViewGroup)?.removeView(child)
+            }
+        } else {
+            (child.parent as? ViewGroup)?.removeView(child)
+        }
+
+        // Remove child from parent's nodeChildren list
+        if (parentId != null) {
+            nodeChildren[parentId]?.remove(childId)
+        }
+
+        // Recursively clean up descendants
+        cleanupNode(childId)
+    }
+
+    private fun cleanupNode(nodeId: Int) {
+        // Recursively clean up children using the reverse index (O(subtree) not O(n))
+        nodeChildren[nodeId]?.toList()?.forEach { cleanupNode(it) }
+        nodeParents.remove(nodeId)
+        // O(k) event cleanup via reverse index instead of O(n) full scan
+        eventKeysPerNode.remove(nodeId)?.forEach { key ->
+            eventHandlers.remove(key)
+        }
+        // Call destroyView on the factory to clean up factory-level state (e.g. VListFactory maps)
+        val view = nodeViews[nodeId]
+        if (view != null) {
+            val factory = componentRegistry.factoryForView(view)
+            factory?.destroyView(view)
+        }
+        nodeViews.remove(nodeId)
+        nodeTypes.remove(nodeId)
+        nodeChildren.remove(nodeId)
+    }
+
+    private fun handleSetRootView(args: JSONArray) {
+        val nodeId = args.getInt(0)
+        val view = nodeViews[nodeId] ?: return
+        rootView = view
+
+        val container = hostContainer ?: return
+        container.removeAllViews()
+        container.addView(
+            view,
+            ViewGroup.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.MATCH_PARENT
+            )
+        )
+    }
+
+    private fun handleAddEventListener(args: JSONArray) {
+        val nodeId = args.getInt(0)
+        val eventName = args.getString(1)
+        val view = nodeViews[nodeId] ?: return
+        val factory = componentRegistry.factoryForView(view) ?: return
+
+        val key = "$nodeId:$eventName"
+
+        // Remove old handler first to prevent duplicate event firing (e.g. recycled node IDs)
+        if (eventHandlers.containsKey(key)) {
+            factory.removeEventListener(view, eventName)
+            eventHandlers.remove(key)
+        }
+
+        val handler: (Any?) -> Unit = { payload ->
+            val payloadJson = when (payload) {
+                null -> "null"
+                is Map<*, *> -> JSONObject(payload).toString()
+                is String -> JSONObject.quote(payload)
+                else -> payload.toString()
+            }
+            onFireEvent?.invoke(nodeId, eventName, payloadJson)
+        }
+
+        factory.addEventListener(view, eventName, handler)
+        eventHandlers[key] = handler
+        eventKeysPerNode.getOrPut(nodeId) { mutableSetOf() }.add(key)
+    }
+
+    private fun handleRemoveEventListener(args: JSONArray) {
+        val nodeId = args.getInt(0)
+        val eventName = args.getString(1)
+        val view = nodeViews[nodeId] ?: return
+        val factory = componentRegistry.factoryForView(view) ?: return
+        factory.removeEventListener(view, eventName)
+
+        val key = "$nodeId:$eventName"
+        eventHandlers.remove(key)
+        eventKeysPerNode[nodeId]?.remove(key)
+    }
+
+    private fun handleInvokeNativeModule(args: JSONArray) {
+        val moduleName = args.getString(0)
+        val methodName = args.getString(1)
+        val moduleArgs = buildArgsList(args.optJSONArray(2))
+        val callbackId = args.optInt(3, -1)
+
+        NativeModuleRegistry.getInstance(context).invoke(
+            moduleName, methodName, moduleArgs, this
+        ) { result, error ->
+            if (callbackId >= 0) {
+                val resultJson = when (result) {
+                    null -> "null"
+                    is Map<*, *> -> JSONObject(result).toString()
+                    is List<*> -> JSONArray(result).toString()
+                    is String -> JSONObject.quote(result)
+                    is Boolean -> result.toString()
+                    is Number -> result.toString()
+                    else -> result.toString()
+                }
+                val errorJson = if (error != null) JSONObject.quote(error) else "null"
+                resolveCallbackInJs(callbackId, resultJson, errorJson)
+            }
+        }
+    }
+
+    private fun handleInvokeNativeModuleSync(args: JSONArray) {
+        val moduleName = args.getString(0)
+        val methodName = args.getString(1)
+        val moduleArgs = buildArgsList(args.optJSONArray(2))
+        try {
+            NativeModuleRegistry.getInstance(context).invokeSync(moduleName, methodName, moduleArgs, this)
+        } catch (e: Exception) {
+            Log.e(TAG, "Error in sync module invoke $moduleName.$methodName: ${e.message}")
+        }
+    }
+
+    private fun resolveCallbackInJs(callbackId: Int, resultJson: String, errorJson: String) {
+        onFireEvent?.invoke(-1, "__callback__",
+            "{\"callbackId\":$callbackId,\"result\":$resultJson,\"error\":$errorJson}")
+    }
+
+    private fun buildArgsList(arr: JSONArray?): List<Any?> {
+        arr ?: return emptyList()
+        return (0 until arr.length()).map { i ->
+            if (arr.isNull(i)) null else arr.get(i)
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // Registry management
+    // -------------------------------------------------------------------------
+
+    /** Clear all registries. Called during hot reload after JS teardown. Must run on main thread. */
+    fun clearAllRegistries() {
+        nodeViews.clear()
+        nodeTypes.clear()
+        eventHandlers.clear()
+        eventKeysPerNode.clear()
+        nodeParents.clear()
+        nodeChildren.clear()
+        rootView = null
+    }
+
+    // -------------------------------------------------------------------------
+    // Layout
+    // -------------------------------------------------------------------------
+
+    fun triggerLayout() {
+        rootView?.let { root ->
+            root.requestLayout()
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // Events: Native to JS
+    // -------------------------------------------------------------------------
+
+    /** Fire an event from a native view to the JS side. */
+    fun fireEvent(nodeId: Int, eventName: String, payload: Map<String, Any?>? = null) {
+        val payloadJson = if (payload != null) JSONObject(payload).toString() else "null"
+        onFireEvent?.invoke(nodeId, eventName, payloadJson)
+    }
+
+    /** Dispatch a global push event to JS. Called from modules. */
+    fun dispatchGlobalEvent(eventName: String, payload: Map<String, Any> = emptyMap()) {
+        val payloadJson = JSONObject(payload).toString()
+        onDispatchGlobalEvent?.invoke(eventName, payloadJson)
+    }
+}

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

@@ -0,0 +1,76 @@
+package com.vuenative.core
+
+import android.content.Context
+import android.view.View
+
+/**
+ * Singleton registry mapping component type strings to factories.
+ * Also maps views to the factory that created them (via view tag).
+ */
+class ComponentRegistry private constructor(private val context: Context) {
+
+    companion object {
+        @Volatile private var instance: ComponentRegistry? = null
+
+        fun getInstance(context: Context): ComponentRegistry {
+            return instance ?: synchronized(this) {
+                instance ?: ComponentRegistry(context.applicationContext).also {
+                    instance = it
+                    it.registerDefaults()
+                }
+            }
+        }
+    }
+
+    private val factories = mutableMapOf<String, NativeComponentFactory>()
+
+    private fun registerDefaults() {
+        register("VView",              VViewFactory())
+        register("VText",              VTextFactory())
+        register("VButton",            VButtonFactory())
+        register("VInput",             VInputFactory())
+        register("VSwitch",            VSwitchFactory())
+        register("VActivityIndicator", VActivityIndicatorFactory())
+        register("VScrollView",        VScrollViewFactory())
+        register("VImage",             VImageFactory())
+        register("VKeyboardAvoiding",  VKeyboardAvoidingFactory())
+        register("VSafeArea",          VSafeAreaFactory())
+        register("VSlider",            VSliderFactory())
+        register("VList",              VListFactory())
+        register("VModal",             VModalFactory())
+        register("VAlertDialog",       VAlertDialogFactory())
+        register("VStatusBar",         VStatusBarFactory())
+        register("VWebView",           VWebViewFactory())
+        register("VProgressBar",       VProgressBarFactory())
+        register("VPicker",            VPickerFactory())
+        register("VSegmentedControl",  VSegmentedControlFactory())
+        register("VActionSheet",       VActionSheetFactory())
+        register("VRefreshControl",    VRefreshControlFactory())
+        register("VPressable",         VPressableFactory())
+        register("VSectionList",       VSectionListFactory())
+        register("VCheckbox",          VCheckboxFactory())
+        register("VRadio",             VRadioFactory())
+        register("VDropdown",          VDropdownFactory())
+        register("VVideo",            VVideoFactory())
+        register("__ROOT__",           VRootFactory())
+    }
+
+    fun register(type: String, factory: NativeComponentFactory) {
+        factories[type] = factory
+    }
+
+    fun createView(type: String): View? {
+        val factory = factories[type] ?: run {
+            android.util.Log.w("VueNative", "No factory for type: $type")
+            return null
+        }
+        val view = factory.createView(context)
+        view.setTag(TAG_FACTORY, factory)
+        return view
+    }
+
+    fun factoryForType(type: String): NativeComponentFactory? = factories[type]
+
+    fun factoryForView(view: View): NativeComponentFactory? =
+        view.getTag(TAG_FACTORY) as? NativeComponentFactory
+}