@thelacanians/vue-native-cli 0.4.14 → 0.6.0

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

@@ -0,0 +1,80 @@
+#if canImport(UIKit)
+import Foundation
+import QuartzCore
+
+/// 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

@@ -61,6 +61,23 @@ public final class NativeBridge {
     /// Reference to the JS runtime.
     private let runtime = JSRuntime.shared
 
+    // MARK: - Teleport Support
+
+    /// Maps teleport marker IDs (start, end) for cleanup
+    private var teleportMarkers: [Int: (start: Int, end: Int)] = [:]
+
+    /// Maps parent node IDs to their teleport containers
+    private var teleportContainers: [Int: UIView] = [:]
+
+    /// Modal container for teleporting modals
+    private lazy var modalContainer: UIView = {
+        let container = UIView()
+        container.backgroundColor = .clear
+        container.isUserInteractionEnabled = true
+        container.translatesAutoresizingMaskIntoConstraints = false
+        return container
+    }()
+
     // MARK: - Initialization
 
     private init() {}
@@ -69,6 +86,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 +153,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 +169,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 +215,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 {
@@ -203,6 +256,12 @@ public final class NativeBridge {
                 handleRemoveEventListener(args: args)
             case "setRootView":
                 handleSetRootView(args: args)
+            case "createTeleport":
+                handleCreateTeleport(args: args)
+            case "removeTeleport":
+                handleRemoveTeleport(args: args)
+            case "teleportTo":
+                handleTeleportTo(args: args)
             case "invokeNativeModule":
                 handleInvokeNativeModule(args: args)
             case "invokeNativeModuleSync":
@@ -212,8 +271,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 +447,9 @@ 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)
+            container.flex.markDirty()
+            container.setNeedsLayout()
         } else {
             container.flex.addItem(childView)
         }
@@ -559,6 +619,124 @@ public final class NativeBridge {
         vc.view.addSubview(traitObserver)
         // Retain the observer for the lifetime of the root view controller's view
         objc_setAssociatedObject(vc.view as UIView, &NativeBridge.traitObserverKey, traitObserver as AnyObject, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+
+        // Add modal container to root view for teleport
+        if rootView != nil {
+            rootView?.addSubview(modalContainer)
+            modalContainer.topAnchor.constraint(equalTo: rootView!.topAnchor).isActive = true
+            modalContainer.leadingAnchor.constraint(equalTo: rootView!.leadingAnchor).isActive = true
+            modalContainer.trailingAnchor.constraint(equalTo: rootView!.trailingAnchor).isActive = true
+            modalContainer.bottomAnchor.constraint(equalTo: rootView!.bottomAnchor).isActive = true
+        }
+    }
+
+    // MARK: - Teleport Handlers
+
+    /// createTeleport: [parentId: Int, startId: Int, endId: Int]
+    private func handleCreateTeleport(args: [Any]) {
+        guard args.count >= 3,
+              let parentId = asInt(args[0]),
+              let startId = asInt(args[1]),
+              let endId = asInt(args[2]) else {
+            NSLog("[VueNative Bridge] Error: Invalid createTeleport args: \(args)")
+            return
+        }
+
+        guard let parentView = viewRegistry[parentId] else {
+            NSLog("[VueNative Bridge] Error: Parent view not found for teleport (id: \(parentId))")
+            return
+        }
+
+        // Store teleport marker IDs
+        teleportMarkers[parentId] = (start: startId, end: endId)
+
+        // Create container for teleported content
+        let container = UIView()
+        container.tag = -parentId  // Negative tag to identify as teleport container
+        container.backgroundColor = .clear
+        container.isUserInteractionEnabled = true
+        container.translatesAutoresizingMaskIntoConstraints = false
+
+        parentView.addSubview(container)
+        teleportContainers[parentId] = container
+
+        #if DEBUG
+        NSLog("[VueNative Bridge] Created teleport container for parent \(parentId)")
+        #endif
+    }
+
+    /// removeTeleport: [parentId: Int, startId: Int, endId: Int]
+    private func handleRemoveTeleport(args: [Any]) {
+        guard args.count >= 1,
+              let parentId = asInt(args[0]) else {
+            NSLog("[VueNative Bridge] Error: Invalid removeTeleport args: \(args)")
+            return
+        }
+
+        // Remove teleport container
+        if let container = teleportContainers.removeValue(forKey: parentId) {
+            container.removeFromSuperview()
+        }
+
+        // Clean up markers
+        teleportMarkers.removeValue(forKey: parentId)
+
+        #if DEBUG
+        NSLog("[VueNative Bridge] Removed teleport container for parent \(parentId)")
+        #endif
+    }
+
+    /// teleportTo: [target: String, nodeId: Int]
+    private func handleTeleportTo(args: [Any]) {
+        guard args.count >= 2,
+              let target = args[0] as? String,
+              let nodeId = asInt(args[1]) else {
+            NSLog("[VueNative Bridge] Error: Invalid teleportTo args: \(args)")
+            return
+        }
+
+        guard let targetView = getTeleportTarget(target) else {
+            NSLog("[VueNative Bridge] Warning: Teleport target '\(target)' not found")
+            return
+        }
+
+        guard let childView = viewRegistry[nodeId] else {
+            NSLog("[VueNative Bridge] Warning: Node view not found for teleport (id: \(nodeId))")
+            return
+        }
+
+        // Move view to teleport target
+        childView.removeFromSuperview()
+        targetView.addSubview(childView)
+
+        // Set up full-size constraints
+        childView.translatesAutoresizingMaskIntoConstraints = false
+        NSLayoutConstraint.activate([
+            childView.topAnchor.constraint(equalTo: targetView.topAnchor),
+            childView.leadingAnchor.constraint(equalTo: targetView.leadingAnchor),
+            childView.trailingAnchor.constraint(equalTo: targetView.trailingAnchor),
+            childView.bottomAnchor.constraint(equalTo: targetView.bottomAnchor),
+        ])
+
+        #if DEBUG
+        NSLog("[VueNative Bridge] Teleported node \(nodeId) to target '\(target)'")
+        #endif
+    }
+
+    /// Get teleport target view by name
+    private func getTeleportTarget(_ target: String) -> UIView? {
+        switch target {
+        case "root":
+            return rootView
+        case "modal":
+            // Ensure modal container is added to root if not already
+            if modalContainer.superview == nil && rootView != nil {
+                rootView?.addSubview(modalContainer)
+            }
+            return modalContainer
+        default:
+            return nil
+        }
     }
 
     // MARK: - Native Module Handlers
@@ -781,55 +959,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")
         }

package/native/ios/VueNativeCore/Sources/VueNativeCore/Components/Factories/VListFactory.swift

@@ -37,6 +37,7 @@ final class VListFactory: NativeComponentFactory {
         switch event {
         case "scroll":
             container.onScroll = handler
+            container.scrollThrottle = EventThrottle(interval: 0.016, handler: handler)
         case "endReached":
             container.onEndReached = handler
         default:
@@ -47,7 +48,9 @@ final class VListFactory: NativeComponentFactory {
     func removeEventListener(view: UIView, event: String) {
         guard let container = view as? VListContainerView else { return }
         switch event {
-        case "scroll": container.onScroll = nil
+        case "scroll":
+            container.onScroll = nil
+            container.scrollThrottle = nil
         case "endReached": container.onEndReached = nil
         default: break
         }
@@ -106,6 +109,7 @@ final class VListContainerView: UIView {
     var itemViews: [UIView] = []
     var estimatedItemHeight: CGFloat = 44
     var onScroll: ((Any?) -> Void)?
+    var scrollThrottle: EventThrottle?
     var onEndReached: ((Any?) -> Void)?
     fileprivate var firedEndReached = false
     private lazy var internalDelegate = VListInternalDelegate(container: self)
@@ -195,7 +199,20 @@ private final class VListInternalDelegate: NSObject,
     func scrollViewDidScroll(_ scrollView: UIScrollView) {
         guard let container = container else { return }
         let offset = scrollView.contentOffset
-        container.onScroll?(["x": Double(offset.x), "y": Double(offset.y)])
+        let payload: [String: Any] = [
+            "x": Double(offset.x),
+            "y": Double(offset.y),
+            "contentWidth": Double(scrollView.contentSize.width),
+            "contentHeight": Double(scrollView.contentSize.height),
+            "layoutWidth": Double(scrollView.frame.width),
+            "layoutHeight": Double(scrollView.frame.height),
+        ]
+        // Use throttle if available, otherwise fire directly
+        if let throttle = container.scrollThrottle {
+            throttle.fire(payload)
+        } else {
+            container.onScroll?(payload)
+        }
 
         // endReached detection (threshold = 20% from bottom)
         let contentH = scrollView.contentSize.height

package/native/ios/VueNativeCore/Sources/VueNativeCore/Components/Factories/VScrollViewFactory.swift

@@ -221,20 +221,25 @@ private final class RefreshTarget: NSObject {
 // MARK: - ScrollDelegateProxy
 
 /// UIScrollViewDelegate proxy that forwards scroll events to a JS handler.
+/// Uses EventThrottle to limit bridge round-trips to ~60/s during fast scrolling.
 private final class ScrollDelegateProxy: NSObject, UIScrollViewDelegate {
-    private let handler: (Any?) -> Void
+    private let throttle: EventThrottle
 
     init(handler: @escaping (Any?) -> Void) {
-        self.handler = handler
+        self.throttle = EventThrottle(interval: 0.016, handler: handler)
         super.init()
     }
 
     func scrollViewDidScroll(_ scrollView: UIScrollView) {
         let payload: [String: Any] = [
             "x": scrollView.contentOffset.x,
-            "y": scrollView.contentOffset.y
+            "y": scrollView.contentOffset.y,
+            "contentWidth": scrollView.contentSize.width,
+            "contentHeight": scrollView.contentSize.height,
+            "layoutWidth": scrollView.frame.width,
+            "layoutHeight": scrollView.frame.height,
         ]
-        handler(payload)
+        throttle.fire(payload)
     }
 }
 #endif

package/native/ios/VueNativeCore/Sources/VueNativeCore/Components/Factories/VSliderFactory.swift

@@ -53,11 +53,16 @@ final class VSliderFactory: NativeComponentFactory {
     }
 }
 
+/// Throttled target for UISlider .valueChanged events.
+/// Limits bridge round-trips to ~60/s during continuous slider dragging.
 private final class SliderTarget: NSObject {
-    let handler: (Any?) -> Void
-    init(handler: @escaping (Any?) -> Void) { self.handler = handler }
+    private let throttle: EventThrottle
+    init(handler: @escaping (Any?) -> Void) {
+        self.throttle = EventThrottle(interval: 0.016, handler: handler)
+        super.init()
+    }
     @objc func handleValueChanged(_ slider: UISlider) {
-        handler(Double(slider.value))
+        throttle.fire(["value": Double(slider.value)])
     }
 }
 #endif

package/native/ios/VueNativeCore/Sources/VueNativeCore/Components/Factories/VTextFactory.swift

@@ -40,6 +40,7 @@ final class VTextFactory: NativeComponentFactory {
     private static var fontSizeKey: UInt8 = 0
     private static var fontWeightKey: UInt8 = 0
     private static var fontFamilyKey: UInt8 = 0
+    private static var textChildrenKey: UInt8 = 0
 
     // MARK: - NativeComponentFactory
 
@@ -57,6 +58,7 @@ final class VTextFactory: NativeComponentFactory {
 
         switch key {
         case "text":
+            storeTextChildren([], on: label)
             if let text = value as? String {
                 label.text = text
             } else {
@@ -235,6 +237,31 @@ final class VTextFactory: NativeComponentFactory {
         }
     }
 
+    func insertChild(_ child: UIView, into parent: UIView, before anchor: UIView?) {
+        guard let label = parent as? UILabel else {
+            child.removeFromSuperview()
+            return
+        }
+
+        var children = storedTextChildren(on: label)
+        if let anchor = anchor, let index = children.firstIndex(where: { $0 === anchor }) {
+            children.insert(child, at: index)
+        } else {
+            children.append(child)
+        }
+
+        storeTextChildren(children, on: label)
+        rebuildText(from: children, on: label)
+    }
+
+    func removeChild(_ child: UIView, from parent: UIView) {
+        guard let label = parent as? UILabel else { return }
+        var children = storedTextChildren(on: label)
+        children.removeAll { $0 === child }
+        storeTextChildren(children, on: label)
+        rebuildText(from: children, on: label)
+    }
+
     // MARK: - Font rebuilding
 
     /// Rebuild the UIFont from stored fontSize, fontWeight, and fontFamily.
@@ -286,5 +313,21 @@ final class VTextFactory: NativeComponentFactory {
     private func storedFontFamily(on view: UIView) -> String? {
         return objc_getAssociatedObject(view, &VTextFactory.fontFamilyKey) as? String
     }
+
+    private func storeTextChildren(_ children: [UIView], on view: UIView) {
+        objc_setAssociatedObject(view, &VTextFactory.textChildrenKey, children, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    }
+
+    private func storedTextChildren(on view: UIView) -> [UIView] {
+        return objc_getAssociatedObject(view, &VTextFactory.textChildrenKey) as? [UIView] ?? []
+    }
+
+    private func rebuildText(from children: [UIView], on label: UILabel) {
+        let text = children.compactMap { child -> String? in
+            (child as? UILabel)?.text
+        }.joined()
+        label.text = text.isEmpty ? nil : text
+        label.flex.markDirty()
+    }
 }
 #endif