pythonnative 0.35.0__py3-none-any.whl → 0.37.0__py3-none-any.whl

pythonnative/templates/ios_template/PythonNativeKit/Sources/PythonNativeKit/Animation/PNAnimator.swift

@@ -0,0 +1,301 @@
+import UIKit
+
+/// Drives the `animate(tag, request)` protocol for animatable props
+/// (`opacity`, `background_color`, `color`, `translate_x`, `translate_y`,
+/// `scale`, `scale_x`, `scale_y`, `rotate`).
+///
+/// - `set` applies one Python-driven frame immediately.
+/// - `start` runs `timing` / `spring` with `UIViewPropertyAnimator` and
+///   `decay` with a display-link integrator; completion posts
+///   `callback("animation", 0, "", {"id": n, "finished": bool})`.
+/// - `cancel` stops the animation and returns the presentation value.
+public final class PNAnimator {
+    public static let shared = PNAnimator()
+
+    /// Prop names accepted by `set` and `start`.
+    public static let animatableProps: Set<String> = [
+        "opacity", "background_color", "color", "translate_x", "translate_y", "scale", "scale_x", "scale_y", "rotate",
+    ]
+
+    final class Running {
+        weak var view: UIView?
+        let prop: String
+        var animator: UIViewPropertyAnimator?
+        var decay: PNDecayDriver?
+        init(view: UIView, prop: String) {
+            self.view = view
+            self.prop = prop
+        }
+    }
+
+    private var running: [Int64: Running] = [:]
+
+    private init() {}
+
+    // MARK: - Request routing
+
+    /// Handle one decoded `animate` request for the view with `tag`.
+    public func handle(tag: Int64, request: [String: Any]) -> Any? {
+        let op = PNProps.string(request["op"]) ?? ""
+        switch op {
+        case "set":
+            guard let record = PNViewRegistry.shared.resolve(tag), let prop = PNProps.string(request["prop"]) else { return nil }
+            record.manager.setAnimatedProperty(view: record.view, prop: prop, value: request["value"])
+            return nil
+        case "start":
+            guard let record = PNViewRegistry.shared.resolve(tag), let prop = PNProps.string(request["prop"]),
+                  let id = PNProps.int(request["id"])
+            else { return ["ok": false] }
+            let spec = PNProps.dict(request["spec"]) ?? [:]
+            let ok = record.manager.startAnimation(view: record.view, id: Int64(id), prop: prop, spec: spec)
+            return ["ok": ok]
+        case "cancel":
+            guard let id = PNProps.int(request["id"]) else { return nil }
+            let value: Any?
+            if let record = PNViewRegistry.shared.resolve(tag) {
+                value = record.manager.cancelAnimation(view: record.view, id: Int64(id))
+            } else {
+                value = cancel(id: Int64(id))
+            }
+            guard let value = value else { return nil }
+            return ["value": value]
+        default:
+            PNLog.rateLimited(PNLog.animation, key: "op:\(op)", "unknown animate op '\(op)'")
+            return nil
+        }
+    }
+
+    // MARK: - Frame application
+
+    /// Apply one value of `prop` to `view` immediately.
+    public func applyValue(view: UIView, prop: String, value: Any?) {
+        switch prop {
+        case "opacity":
+            if let v = PNProps.double(value) { view.alpha = CGFloat(v) }
+        case "background_color":
+            if let color = PNColor.parse(value) { view.backgroundColor = color }
+        case "color":
+            guard let color = PNColor.parse(value) else { return }
+            if let label = view as? UILabel {
+                label.textColor = color
+            } else if let field = view as? UITextField {
+                field.textColor = color
+            } else if let textView = view as? UITextView {
+                textView.textColor = color
+            } else if let button = view as? UIButton {
+                button.setTitleColor(color, for: .normal)
+            }
+        case "translate_x", "translate_y", "scale", "scale_x", "scale_y", "rotate":
+            guard let v = PNProps.double(value), v.isFinite else { return }
+            PNTransform.apply(view, spec: [[prop: v]])
+        default:
+            PNLog.once(PNLog.animation, key: "prop:\(prop)", "ignoring unknown animated prop '\(prop)'")
+        }
+    }
+
+    /// Read the value of `prop` currently on screen (presentation layer when animating).
+    public func presentationValue(view: UIView, prop: String) -> Any? {
+        let layer = view.layer.presentation() ?? view.layer
+        switch prop {
+        case "opacity":
+            return Double(layer.opacity)
+        case "background_color":
+            return layer.backgroundColor.map { PNColor.hexString(UIColor(cgColor: $0)) }
+        case "translate_x", "translate_y", "scale", "scale_x", "scale_y", "rotate":
+            let t = layer.affineTransform()
+            let parts = PNTransform.decompose(t)
+            switch prop {
+            case "translate_x": return Double(parts.translateX)
+            case "translate_y": return Double(parts.translateY)
+            case "scale", "scale_x": return Double(parts.scaleX)
+            case "scale_y": return Double(parts.scaleY)
+            default: return Double(parts.rotateDegrees)
+            }
+        default:
+            return nil
+        }
+    }
+
+    // MARK: - Start / cancel
+
+    /// Start a native animation. Returns `false` when the spec must be
+    /// ticked by Python instead.
+    public func start(view: UIView, id: Int64, prop: String, spec: [String: Any]) -> Bool {
+        guard PNAnimator.animatableProps.contains(prop), Thread.isMainThread else { return false }
+        let kind = PNProps.string(spec["kind"]) ?? ""
+        let entry = Running(view: view, prop: prop)
+        switch kind {
+        case "timing", "spring":
+            guard spec["to"] != nil else { return false }
+            if let from = spec["from"] { applyValue(view: view, prop: prop, value: from) }
+            let timing = PNAnimator.timingParameters(kind: kind, spec: spec)
+            let animator = UIViewPropertyAnimator(duration: timing.duration, timingParameters: timing.parameters)
+            animator.isUserInteractionEnabled = true
+            animator.addAnimations { [weak self, weak view] in
+                guard let self = self, let view = view else { return }
+                self.applyValue(view: view, prop: prop, value: spec["to"])
+            }
+            animator.addCompletion { [weak self] position in
+                guard let self = self, self.running[id] != nil else { return }
+                self.running.removeValue(forKey: id)
+                PNAnimator.reportCompletion(id: id, finished: position == .end)
+            }
+            entry.animator = animator
+            running[id] = entry
+            let delay = max(0, (PNProps.double(spec["delay_ms"]) ?? 0) / 1000)
+            animator.startAnimation(afterDelay: delay)
+            return true
+        case "decay":
+            guard let from = PNProps.double(spec["from"]), let velocity = PNProps.double(spec["velocity"]) else { return false }
+            let deceleration = max(1e-6, PNProps.double(spec["deceleration"]) ?? 0.997)
+            let driver = PNDecayDriver(from: from, velocity: velocity, deceleration: deceleration) { [weak self, weak view] value in
+                guard let self = self, let view = view else { return }
+                self.applyValue(view: view, prop: prop, value: value)
+            } completion: { [weak self] in
+                guard let self = self, self.running[id] != nil else { return }
+                self.running.removeValue(forKey: id)
+                PNAnimator.reportCompletion(id: id, finished: true)
+            }
+            entry.decay = driver
+            running[id] = entry
+            driver.start()
+            return true
+        default:
+            return false
+        }
+    }
+
+    /// Stop animation `id`, leaving the view at its presentation value.
+    /// Returns that value (or `nil` when the animation isn't running).
+    public func cancel(id: Int64) -> Any? {
+        guard let entry = running.removeValue(forKey: id) else { return nil }
+        var value: Any?
+        if let view = entry.view {
+            value = presentationValue(view: view, prop: entry.prop)
+        }
+        if let animator = entry.animator {
+            animator.stopAnimation(true)
+        }
+        if let decay = entry.decay {
+            value = decay.currentValue
+            decay.stop()
+        }
+        if let view = entry.view, let value = value {
+            view.layer.removeAllAnimations()
+            applyValue(view: view, prop: entry.prop, value: value)
+        }
+        return value
+    }
+
+    /// Drop bookkeeping for animations targeting `view` (on destroy).
+    public func forget(view: UIView) {
+        for (id, entry) in running where entry.view === view || entry.view == nil {
+            entry.animator?.stopAnimation(true)
+            entry.decay?.stop()
+            running.removeValue(forKey: id)
+        }
+    }
+
+    // MARK: - Helpers
+
+    static func reportCompletion(id: Int64, finished: Bool) {
+        PNBridge.shared.callPython(kind: "animation", tag: 0, name: "", payload: PNJSON.encode(["id": id, "finished": finished]))
+    }
+
+    /// Resolve `timing` / `spring` specs to UIKit timing parameters.
+    static func timingParameters(kind: String, spec: [String: Any]) -> (duration: TimeInterval, parameters: UITimingCurveProvider) {
+        if kind == "spring" {
+            let stiffness = max(1e-3, PNProps.double(spec["stiffness"]) ?? 100)
+            let damping = max(1e-3, PNProps.double(spec["damping"]) ?? 10)
+            let mass = max(1e-3, PNProps.double(spec["mass"]) ?? 1)
+            let omega0 = sqrt(stiffness / mass)
+            let zeta = damping / (2 * sqrt(stiffness * mass))
+            let duration = zeta < 1 ? min(10, max(0.15, 4 / max(0.05, zeta * omega0))) : min(10, max(0.15, 4 / omega0))
+            let distance = abs((PNProps.double(spec["to"]) ?? 0) - (PNProps.double(spec["from"]) ?? 0))
+            let v0 = PNProps.double(spec["initial_velocity"]) ?? 0
+            let normalized = distance > 1e-9 ? v0 / distance : 0
+            let parameters = UISpringTimingParameters(
+                mass: CGFloat(mass), stiffness: CGFloat(stiffness), damping: CGFloat(damping),
+                initialVelocity: CGVector(dx: normalized, dy: normalized)
+            )
+            return (duration, parameters)
+        }
+        let duration = max(0, (PNProps.double(spec["duration_ms"]) ?? 300) / 1000)
+        return (duration, curve(for: spec["easing"]))
+    }
+
+    /// Map an easing name (or `[x1, y1, x2, y2]` control points) to a timing curve.
+    static func curve(for easing: Any?) -> UITimingCurveProvider {
+        if let points = easing as? [Any], points.count == 4 {
+            let values = points.compactMap { PNProps.double($0) }
+            if values.count == 4 {
+                return UICubicTimingParameters(
+                    controlPoint1: CGPoint(x: values[0], y: values[1]), controlPoint2: CGPoint(x: values[2], y: values[3])
+                )
+            }
+        }
+        switch PNProps.string(easing) ?? "ease_in_out" {
+        case "linear": return UICubicTimingParameters(animationCurve: .linear)
+        case "ease_in", "ease_in_quad": return UICubicTimingParameters(animationCurve: .easeIn)
+        case "ease_out", "ease_out_quad": return UICubicTimingParameters(animationCurve: .easeOut)
+        case "ease", "ease_in_out": return UICubicTimingParameters(animationCurve: .easeInOut)
+        case "bounce":
+            // No CoreAnimation equivalent; approximate with an overshoot curve.
+            return UICubicTimingParameters(controlPoint1: CGPoint(x: 0.34, y: 1.56), controlPoint2: CGPoint(x: 0.64, y: 1))
+        default: return UICubicTimingParameters(animationCurve: .easeInOut)
+        }
+    }
+}
+
+/// Integrates the `decay` model on a `CADisplayLink`, mirroring the
+/// Python ticker: `v(t) = v0 * e^(-k * 1000 * t)` with `t` in seconds and
+/// `v0` in units per second, so the closed-form position is
+/// `from + v0 / (k * 1000) * (1 - e^(-k * 1000 * t))`.
+final class PNDecayDriver {
+    private(set) var currentValue: Double
+    private let from: Double
+    private let velocity0: Double
+    private let k: Double
+    private let frame: (Double) -> Void
+    private let completion: () -> Void
+    private var link: CADisplayLink?
+    private var startTime: CFTimeInterval = 0
+    private let restVelocity = 0.001
+
+    init(from: Double, velocity: Double, deceleration: Double, frame: @escaping (Double) -> Void, completion: @escaping () -> Void) {
+        self.from = from
+        currentValue = from
+        velocity0 = velocity
+        k = deceleration
+        self.frame = frame
+        self.completion = completion
+    }
+
+    func start() {
+        startTime = CACurrentMediaTime()
+        if abs(velocity0) < restVelocity {
+            completion()
+            return
+        }
+        let link = CADisplayLink(target: self, selector: #selector(tick(_:)))
+        link.add(to: .main, forMode: .common)
+        self.link = link
+    }
+
+    func stop() {
+        link?.invalidate()
+        link = nil
+    }
+
+    @objc private func tick(_ link: CADisplayLink) {
+        let elapsed = max(0, link.targetTimestamp - startTime)
+        let decayFactor = exp(-k * 1000 * elapsed)
+        let velocity = velocity0 * decayFactor
+        currentValue = from + velocity0 / (k * 1000) * (1 - decayFactor)
+        frame(currentValue)
+        if abs(velocity) < restVelocity {
+            stop()
+            completion()
+        }
+    }
+}

pythonnative/templates/ios_template/PythonNativeKit/Sources/PythonNativeKit/Bridge/PNBridge.swift

@@ -0,0 +1,191 @@
+import Foundation
+import UIKit
+
+/// The version of the wire protocol compiled into this library. Python
+/// refuses to start when `pythonnative.bridge.PROTOCOL_VERSION` differs.
+public let PNProtocolVersion: Int32 = 1
+
+/// The C signature Python registers through `pn_bridge_set_callback`.
+///
+/// `(kind, tag, name, payload_json) -> optional JSON string owned by
+/// Python and valid until the next callback returns`.
+public typealias PNCallbackFn = @convention(c) (
+    UnsafePointer<CChar>?, Int64, UnsafePointer<CChar>?, UnsafePointer<CChar>?
+) -> UnsafePointer<CChar>?
+
+/// Swift-side entry point for the reverse direction (native -> Python) and
+/// the owner of the registered C callback.
+public final class PNBridge {
+    public static let shared = PNBridge()
+
+    private var callback: PNCallbackFn?
+    private var registrationWaiters: [() -> Void] = []
+
+    private init() {
+        // Reference every exported entry point so the linker never
+        // dead-strips them out of the host executable; Python resolves
+        // them through `dlsym` at runtime.
+        _ = PNBridge.exportedSymbols
+    }
+
+    /// Whether Python has registered its callback yet.
+    public var hasCallback: Bool { callback != nil }
+
+    /// Install (or clear) the Python callback. Runs any pending
+    /// `whenCallbackRegistered` blocks when a callback becomes available.
+    public func setCallback(_ fn: PNCallbackFn?) {
+        callback = fn
+        guard fn != nil else { return }
+        let waiters = registrationWaiters
+        registrationWaiters = []
+        for waiter in waiters { waiter() }
+    }
+
+    /// Run `block` immediately if the callback is registered, otherwise
+    /// once it is. Used to buffer deep links and other early events.
+    public func whenCallbackRegistered(_ block: @escaping () -> Void) {
+        if callback != nil {
+            block()
+        } else {
+            registrationWaiters.append(block)
+        }
+    }
+
+    /// Invoke the Python callback. Returns the JSON string Python returned
+    /// (copied immediately), or `nil` when Python returned NULL or no
+    /// callback is registered.
+    @discardableResult
+    public func callPython(kind: String, tag: Int64, name: String, payload: String) -> String? {
+        PNBridge.ensureMainThread("callPython(\(kind))")
+        guard let callback = callback else {
+            PNLog.rateLimited(PNLog.bridge, key: "no-callback", "callPython(\(kind), \(name)) dropped: no Python callback registered")
+            return nil
+        }
+        let result: UnsafePointer<CChar>? = kind.withCString { kindPtr in
+            name.withCString { namePtr in
+                payload.withCString { payloadPtr in
+                    callback(kindPtr, tag, namePtr, payloadPtr)
+                }
+            }
+        }
+        guard let result = result else { return nil }
+        return String(cString: result)
+    }
+
+    /// Emit a view event: `callback("event", tag, name, args_array_json)`.
+    @discardableResult
+    public func emitEvent(tag: Int64, name: String, args: [Any?]) -> String? {
+        callPython(kind: "event", tag: tag, name: name, payload: PNJSON.encode(args))
+    }
+
+    /// Log when an entry point is reached off the main thread. Python
+    /// always calls from the main thread, so this only guards misuse.
+    static func ensureMainThread(_ context: String) {
+        if !Thread.isMainThread {
+            PNLog.rateLimited(PNLog.bridge, key: "off-main:\(context)", "\(context) called off the main thread; running inline")
+        }
+    }
+
+    /// Copy a Swift string into a `strdup`'d buffer Python frees via `pn_bridge_free`.
+    static func duplicate(_ string: String?) -> UnsafeMutablePointer<CChar>? {
+        guard let string = string else { return nil }
+        return strdup(string)
+    }
+
+    private static let exportedSymbols: [Any] = [
+        pn_bridge_apply as Any,
+        pn_bridge_measure as Any,
+        pn_bridge_command as Any,
+        pn_bridge_animate as Any,
+        pn_bridge_call as Any,
+        pn_bridge_free as Any,
+        pn_bridge_set_callback as Any,
+        pn_bridge_protocol_version as Any,
+    ]
+}
+
+// MARK: - C exports
+
+/// Apply one serialized transaction (a JSON array of ops).
+@_cdecl("pn_bridge_apply")
+public func pn_bridge_apply(_ transactionJSON: UnsafePointer<CChar>?) {
+    PNBridge.ensureMainThread("pn_bridge_apply")
+    guard let transactionJSON = transactionJSON else { return }
+    PNTransaction.apply(String(cString: transactionJSON))
+}
+
+/// Measure the view with `tag` under the given constraints (`1e6` means unconstrained).
+@_cdecl("pn_bridge_measure")
+public func pn_bridge_measure(
+    _ tag: Int64, _ maxW: Double, _ maxH: Double,
+    _ outW: UnsafeMutablePointer<Double>?, _ outH: UnsafeMutablePointer<Double>?
+) {
+    PNBridge.ensureMainThread("pn_bridge_measure")
+    var size = CGSize.zero
+    if let record = PNViewRegistry.shared.resolve(tag) {
+        size = record.manager.measure(view: record.view, maxW: CGFloat(maxW), maxH: CGFloat(maxH))
+    }
+    outW?.pointee = size.width.isFinite ? Double(size.width) : 0
+    outH?.pointee = size.height.isFinite ? Double(size.height) : 0
+}
+
+/// Run an imperative command on one view; returns an optional JSON result.
+@_cdecl("pn_bridge_command")
+public func pn_bridge_command(
+    _ tag: Int64, _ name: UnsafePointer<CChar>?, _ argsJSON: UnsafePointer<CChar>?
+) -> UnsafeMutablePointer<CChar>? {
+    PNBridge.ensureMainThread("pn_bridge_command")
+    guard let name = name, let record = PNViewRegistry.shared.resolve(tag) else { return nil }
+    let args = PNJSON.decodeObject(argsJSON.map { String(cString: $0) })
+    let result = record.manager.command(view: record.view, name: String(cString: name), args: args)
+    guard let result = result else { return nil }
+    return PNBridge.duplicate(PNJSON.encode(result))
+}
+
+/// Drive a view's animatable properties (`set` / `start` / `cancel`).
+@_cdecl("pn_bridge_animate")
+public func pn_bridge_animate(
+    _ tag: Int64, _ requestJSON: UnsafePointer<CChar>?
+) -> UnsafeMutablePointer<CChar>? {
+    PNBridge.ensureMainThread("pn_bridge_animate")
+    let request = PNJSON.decodeObject(requestJSON.map { String(cString: $0) })
+    let result = PNAnimator.shared.handle(tag: tag, request: request)
+    guard let result = result else { return nil }
+    return PNBridge.duplicate(PNJSON.encode(result))
+}
+
+/// Call a native module method. The result is `{"ok":..}`, `{"pending":true}`, or an error envelope.
+@_cdecl("pn_bridge_call")
+public func pn_bridge_call(
+    _ module: UnsafePointer<CChar>?, _ method: UnsafePointer<CChar>?, _ argsJSON: UnsafePointer<CChar>?
+) -> UnsafeMutablePointer<CChar>? {
+    PNBridge.ensureMainThread("pn_bridge_call")
+    guard let module = module, let method = method else {
+        return PNBridge.duplicate(PNJSON.encode(["ok": false, "error": "missing module or method"]))
+    }
+    let envelope = PNJSON.decodeObject(argsJSON.map { String(cString: $0) })
+    let result = PNModuleDispatcher.shared.call(
+        module: String(cString: module), method: String(cString: method), envelope: envelope
+    )
+    return PNBridge.duplicate(PNJSON.encode(result))
+}
+
+/// Free a string previously returned by a `pn_bridge_*` function.
+@_cdecl("pn_bridge_free")
+public func pn_bridge_free(_ ptr: UnsafeMutablePointer<CChar>?) {
+    free(ptr)
+}
+
+/// Register the Python callback used for every native -> Python message.
+@_cdecl("pn_bridge_set_callback")
+public func pn_bridge_set_callback(_ fn: PNCallbackFn?) {
+    PNBridge.ensureMainThread("pn_bridge_set_callback")
+    PNRegistry.shared.ensureBuiltins()
+    PNBridge.shared.setCallback(fn)
+}
+
+/// The protocol version this library speaks.
+@_cdecl("pn_bridge_protocol_version")
+public func pn_bridge_protocol_version() -> Int32 {
+    PNProtocolVersion
+}

pythonnative/templates/ios_template/PythonNativeKit/Sources/PythonNativeKit/Bridge/PNRegistry.swift

@@ -0,0 +1,140 @@
+import UIKit
+
+/// A native plugin bundled into the app by `pn build`. The generated
+/// `PNGeneratedPlugins.registerAll(into:)` calls each entry's `register`.
+public protocol PNPlugin {
+    /// Register component managers and native modules.
+    static func register(into registry: PNRegistry)
+}
+
+/// Component-manager and native-module registry.
+///
+/// Built-ins register lazily on first use; plugins register through
+/// `PNPlugin.register(into:)`. Component factories are invoked once per
+/// element type and the resulting manager is shared by every view of
+/// that type (managers are stateless; per-view state lives in
+/// `PNViewState`).
+public final class PNRegistry {
+    public static let shared = PNRegistry()
+
+    private var componentFactories: [String: () -> PNComponentManager] = [:]
+    private var componentManagers: [String: PNComponentManager] = [:]
+    private var moduleTypes: [String: PNNativeModule.Type] = [:]
+    private var moduleInstances: [String: PNNativeModule] = [:]
+    private var builtinsRegistered = false
+    private let placeholder = PNPlaceholderManager()
+
+    private init() {}
+
+    // MARK: - Registration
+
+    /// Register (or replace) the manager factory for element type `name`.
+    public func registerComponent(_ name: String, factory: @escaping () -> PNComponentManager) {
+        componentFactories[name] = factory
+        componentManagers.removeValue(forKey: name)
+    }
+
+    /// Register (or replace) a native module by its `name`.
+    public func registerModule(_ type: PNNativeModule.Type) {
+        moduleTypes[type.name] = type
+        moduleInstances.removeValue(forKey: type.name)
+    }
+
+    /// Element type names currently registered.
+    public var componentNames: [String] {
+        ensureBuiltins()
+        return Array(componentFactories.keys).sorted()
+    }
+
+    /// Module names currently registered.
+    public var moduleNames: [String] {
+        ensureBuiltins()
+        return Array(moduleTypes.keys).sorted()
+    }
+
+    // MARK: - Lookup
+
+    /// The shared manager for `type`, or a placeholder manager for unknown types.
+    public func manager(for type: String) -> PNComponentManager {
+        ensureBuiltins()
+        if let existing = componentManagers[type] { return existing }
+        if let factory = componentFactories[type] {
+            let manager = factory()
+            componentManagers[type] = manager
+            return manager
+        }
+        PNLog.once(PNLog.components, key: "unknown-type:\(type)", "unknown element type '\(type)'; using a placeholder UIView")
+        return placeholder
+    }
+
+    /// The module instance registered under `name`, created on first use.
+    public func module(named name: String) -> PNNativeModule? {
+        ensureBuiltins()
+        if let existing = moduleInstances[name] { return existing }
+        guard let type = moduleTypes[name] else { return nil }
+        let instance = type.init()
+        moduleInstances[name] = instance
+        return instance
+    }
+
+    // MARK: - Built-ins
+
+    /// Register every built-in manager and module, then the generated plugins.
+    public func ensureBuiltins() {
+        if builtinsRegistered { return }
+        builtinsRegistered = true
+        PNBuiltins.register(into: self)
+        PNGeneratedPlugins.registerAll(into: self)
+    }
+}
+
+/// Registration of the components and modules that ship with PythonNativeKit.
+enum PNBuiltins {
+    static func register(into registry: PNRegistry) {
+        let flex: () -> PNComponentManager = { PNViewManager() }
+        registry.registerComponent("View", factory: flex)
+        registry.registerComponent("Column", factory: flex)
+        registry.registerComponent("Row", factory: flex)
+        registry.registerComponent("Text") { PNTextManager() }
+        registry.registerComponent("Button") { PNButtonManager() }
+        registry.registerComponent("TextInput") { PNTextInputManager() }
+        registry.registerComponent("Image") { PNImageManager() }
+        registry.registerComponent("Switch") { PNSwitchManager() }
+        registry.registerComponent("ProgressBar") { PNProgressBarManager() }
+        registry.registerComponent("ActivityIndicator") { PNActivityIndicatorManager() }
+        registry.registerComponent("WebView") { PNWebViewManager() }
+        registry.registerComponent("Spacer") { PNSpacerManager() }
+        registry.registerComponent("ScrollView") { PNScrollViewManager() }
+        registry.registerComponent("SafeAreaView") { PNSafeAreaViewManager() }
+        registry.registerComponent("Modal") { PNModalManager() }
+        registry.registerComponent("Portal") { PNPortalManager() }
+        registry.registerComponent("Slider") { PNSliderManager() }
+        registry.registerComponent("TabBar") { PNTabBarManager() }
+        registry.registerComponent("Pressable") { PNPressableManager() }
+        registry.registerComponent("StatusBar") { PNStatusBarManager() }
+        registry.registerComponent("KeyboardAvoidingView") { PNKeyboardAvoidingViewManager() }
+        registry.registerComponent("Picker") { PNPickerManager() }
+        registry.registerComponent("Checkbox") { PNCheckboxManager() }
+        registry.registerComponent("SegmentedControl") { PNSegmentedControlManager() }
+        registry.registerComponent("DatePicker") { PNDatePickerManager() }
+        registry.registerComponent("VirtualList") { PNVirtualListManager() }
+
+        registry.registerModule(HostModule.self)
+        registry.registerModule(DeviceModule.self)
+        registry.registerModule(AlertModule.self)
+        registry.registerModule(StorageModule.self)
+        registry.registerModule(SecureStoreModule.self)
+        registry.registerModule(ClipboardModule.self)
+        registry.registerModule(ShareModule.self)
+        registry.registerModule(LinkingModule.self)
+        registry.registerModule(HapticsModule.self)
+        registry.registerModule(BatteryModule.self)
+        registry.registerModule(NetInfoModule.self)
+        registry.registerModule(AppStateModule.self)
+        registry.registerModule(PermissionsModule.self)
+        registry.registerModule(NotificationsModule.self)
+        registry.registerModule(CameraModule.self)
+        registry.registerModule(LocationModule.self)
+        registry.registerModule(BiometricsModule.self)
+    }
+}