pythonnative 0.40.0__cp313-cp313-win_amd64.whl

pythonnative/native/ios/Sources/PythonNativeKit/Gestures/PNGestureCoordinator.swift

@@ -0,0 +1,260 @@
+import UIKit
+
+/// Installs `UIGestureRecognizer`s from the `gestures` prop and emits
+/// `gesture:<index>` events with the payload dict Python's
+/// `GestureEvent` expects.
+///
+/// Spec fields:
+/// - `kind`: `tap`, `long_press`, `pan`, `swipe`, `fling`, `pinch`, `rotation`
+/// - per-kind config (`n_taps`, `max_distance`, `min_duration_ms`,
+///   `min_distance`, `direction`, `n_pointers`, `min_velocity`)
+/// - `simultaneous`: indices allowed to recognize together
+/// - `wait_for`: indices that must fail before this one may begin
+public final class PNGestureCoordinator: NSObject, UIGestureRecognizerDelegate {
+    public static let shared = PNGestureCoordinator()
+
+    /// Bookkeeping for one installed recognizer.
+    final class Entry {
+        let index: Int
+        let kind: String
+        var simultaneous: Set<Int>
+        var minVelocity: CGFloat
+        var direction: String
+        var lastLocation: CGPoint = .zero
+
+        init(index: Int, kind: String, simultaneous: Set<Int>, minVelocity: CGFloat, direction: String) {
+            self.index = index
+            self.kind = kind
+            self.simultaneous = simultaneous
+            self.minVelocity = minVelocity
+            self.direction = direction
+        }
+    }
+
+    private var entries: [ObjectIdentifier: Entry] = [:]
+
+    private override init() {
+        super.init()
+    }
+
+    // MARK: - Wiring
+
+    /// Replace the recognizers on `view` with the ones described by `specs`.
+    public func wire(view: UIView, specs: Any?) {
+        unwire(view: view)
+        guard let state = PNViewState.existing(for: view) else { return }
+        let list = ((specs as? [Any]) ?? []).map { ($0 as? [String: Any]) ?? [:] }
+        guard !list.isEmpty else { return }
+        // A spec may own several recognizers (an any-direction swipe is
+        // one `UISwipeGestureRecognizer` per direction), so relationships
+        // are wired spec-to-spec across every recognizer on each side.
+        var built: [Int: [UIGestureRecognizer]] = [:]
+        for (index, spec) in list.enumerated() {
+            let recognizers = makeRecognizers(spec)
+            if recognizers.isEmpty {
+                PNLog.once(PNLog.gestures, key: "kind:\(PNProps.string(spec["kind"]) ?? "")", "unsupported gesture kind '\(PNProps.string(spec["kind"]) ?? "")'")
+                continue
+            }
+            for (recognizer, direction) in recognizers {
+                let entry = Entry(
+                    index: index,
+                    kind: PNProps.string(spec["kind"]) ?? "",
+                    simultaneous: Set(((spec["simultaneous"] as? [Any]) ?? []).compactMap { PNProps.int($0) }),
+                    minVelocity: CGFloat(PNProps.double(spec["min_velocity"]) ?? 300),
+                    direction: direction ?? PNProps.string(spec["direction"]) ?? "any"
+                )
+                entries[ObjectIdentifier(recognizer)] = entry
+                recognizer.delegate = self
+                recognizer.cancelsTouchesInView = false
+                recognizer.addTarget(self, action: #selector(handle(_:)))
+                view.addGestureRecognizer(recognizer)
+                state.gestureRecognizers.append(recognizer)
+                built[index, default: []].append(recognizer)
+            }
+        }
+        for (index, spec) in list.enumerated() {
+            guard let recognizers = built[index] else { continue }
+            for wait in ((spec["wait_for"] as? [Any]) ?? []).compactMap({ PNProps.int($0) }) {
+                guard wait != index, let others = built[wait] else { continue }
+                for recognizer in recognizers {
+                    for other in others {
+                        recognizer.require(toFail: other)
+                    }
+                }
+            }
+        }
+        view.isUserInteractionEnabled = true
+    }
+
+    /// Remove every recognizer previously installed on `view`.
+    public func unwire(view: UIView) {
+        guard let state = PNViewState.existing(for: view) else { return }
+        for recognizer in state.gestureRecognizers {
+            recognizer.removeTarget(self, action: nil)
+            view.removeGestureRecognizer(recognizer)
+            entries.removeValue(forKey: ObjectIdentifier(recognizer))
+        }
+        state.gestureRecognizers = []
+    }
+
+    // MARK: - Recognizer construction
+
+    /// Build the recognizer(s) for one spec as `(recognizer, direction)`
+    /// pairs. `direction` is set only for swipe / fling recognizers: a
+    /// `UISwipeGestureRecognizer` reports its configured mask rather than
+    /// the direction it resolved, so `direction = "any"` installs one
+    /// recognizer per direction and tags each with its own name.
+    func makeRecognizers(_ spec: [String: Any]) -> [(UIGestureRecognizer, String?)] {
+        switch PNProps.string(spec["kind"]) ?? "" {
+        case "tap":
+            let tap = UITapGestureRecognizer()
+            tap.numberOfTapsRequired = max(1, PNProps.int(spec["n_taps"]) ?? 1)
+            return [(tap, nil)]
+        case "long_press":
+            let press = UILongPressGestureRecognizer()
+            press.minimumPressDuration = max(0.01, (PNProps.double(spec["min_duration_ms"]) ?? 500) / 1000)
+            press.allowableMovement = CGFloat(PNProps.double(spec["max_distance"]) ?? 12)
+            return [(press, nil)]
+        case "pan":
+            return [(PNPanGestureRecognizer(minDistance: CGFloat(PNProps.double(spec["min_distance"]) ?? 10)), nil)]
+        case "swipe", "fling":
+            let requested = PNProps.string(spec["direction"]) ?? "any"
+            let directions = PNGestureCoordinator.swipeDirectionNames.contains(requested)
+                ? [requested]
+                : PNGestureCoordinator.swipeDirectionNames
+            let touches = max(1, PNProps.int(spec["n_pointers"]) ?? 1)
+            return directions.map { name in
+                let swipe = UISwipeGestureRecognizer()
+                swipe.direction = PNGestureCoordinator.swipeDirection(name)
+                swipe.numberOfTouchesRequired = touches
+                return (swipe, name)
+            }
+        case "pinch":
+            return [(UIPinchGestureRecognizer(), nil)]
+        case "rotation":
+            return [(UIRotationGestureRecognizer(), nil)]
+        default:
+            return []
+        }
+    }
+
+    /// The single-direction names a swipe spec may request.
+    public static let swipeDirectionNames = ["left", "right", "up", "down"]
+
+    /// Map a Python direction name to `UISwipeGestureRecognizer.Direction`.
+    public static func swipeDirection(_ name: String) -> UISwipeGestureRecognizer.Direction {
+        switch name {
+        case "left": return .left
+        case "right": return .right
+        case "up": return .up
+        case "down": return .down
+        default: return [.left, .right, .up, .down]
+        }
+    }
+
+    // MARK: - Relationship lookups (exposed for tests)
+
+    /// The spec index recorded for `recognizer`, if it was installed by the coordinator.
+    public func index(of recognizer: UIGestureRecognizer) -> Int? {
+        entries[ObjectIdentifier(recognizer)]?.index
+    }
+
+    /// Whether the two recognizers are allowed to recognize together.
+    public func allowsSimultaneous(_ a: UIGestureRecognizer, _ b: UIGestureRecognizer) -> Bool {
+        guard let ea = entries[ObjectIdentifier(a)], let eb = entries[ObjectIdentifier(b)] else {
+            // One side isn't ours (Pressable, scroll view): don't block it.
+            return true
+        }
+        if a.view !== b.view { return true }
+        return ea.simultaneous.contains(eb.index) || eb.simultaneous.contains(ea.index)
+    }
+
+    // MARK: - UIGestureRecognizerDelegate
+
+    public func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldRecognizeSimultaneouslyWith other: UIGestureRecognizer) -> Bool {
+        allowsSimultaneous(gestureRecognizer, other)
+    }
+
+    // MARK: - Emission
+
+    @objc private func handle(_ recognizer: UIGestureRecognizer) {
+        guard let view = recognizer.view, let entry = entries[ObjectIdentifier(recognizer)] else { return }
+        let location = recognizer.location(in: view)
+        var payload: [String: Any] = [
+            "kind": entry.kind,
+            "x": Double(location.x),
+            "y": Double(location.y),
+            "translation_x": 0.0,
+            "translation_y": 0.0,
+            "velocity_x": 0.0,
+            "velocity_y": 0.0,
+            "scale": 1.0,
+            "rotation": 0.0,
+            "pointer_count": recognizer.numberOfTouches,
+            "direction": NSNull(),
+        ]
+        var state = PNGestureCoordinator.stateName(recognizer.state)
+        switch recognizer {
+        case let pan as UIPanGestureRecognizer:
+            let translation = pan.translation(in: view)
+            let velocity = pan.velocity(in: view)
+            payload["translation_x"] = Double(translation.x)
+            payload["translation_y"] = Double(translation.y)
+            payload["velocity_x"] = Double(velocity.x)
+            payload["velocity_y"] = Double(velocity.y)
+        case let pinch as UIPinchGestureRecognizer:
+            payload["scale"] = Double(pinch.scale)
+            payload["velocity_x"] = Double(pinch.velocity)
+        case let rotation as UIRotationGestureRecognizer:
+            payload["rotation"] = Double(rotation.rotation)
+            payload["velocity_x"] = Double(rotation.velocity)
+        case let swipe as UISwipeGestureRecognizer:
+            // UIKit reports swipes as a single `.ended`; Python expects `ended`.
+            guard swipe.state == .ended || swipe.state == .recognized else { return }
+            state = "ended"
+            payload["direction"] = entry.direction
+            payload["pointer_count"] = max(1, swipe.numberOfTouchesRequired)
+        case is UITapGestureRecognizer:
+            guard recognizer.state == .ended || recognizer.state == .recognized else { return }
+            state = "ended"
+        default:
+            break
+        }
+        guard state != "possible" else { return }
+        payload["state"] = state
+        PNEvents.emit(view, "gesture:\(entry.index)", [payload])
+    }
+
+    static func stateName(_ state: UIGestureRecognizer.State) -> String {
+        switch state {
+        case .began: return "began"
+        case .changed: return "changed"
+        case .ended: return "ended"
+        case .cancelled: return "cancelled"
+        case .failed: return "failed"
+        default: return "possible"
+        }
+    }
+
+    /// The direction name recorded for a swipe / fling recognizer (exposed for tests).
+    public func direction(of recognizer: UIGestureRecognizer) -> String? {
+        guard let entry = entries[ObjectIdentifier(recognizer)], entry.kind == "swipe" || entry.kind == "fling" else {
+            return nil
+        }
+        return entry.direction
+    }
+}
+
+/// A pan recognizer that records the Python `min_distance` threshold.
+///
+/// UIKit applies its own ~10 pt hysteresis before a pan begins, which
+/// matches the Python default; the value is kept for diagnostics and
+/// for future tuning rather than overriding UIKit's touch pipeline.
+final class PNPanGestureRecognizer: UIPanGestureRecognizer {
+    let minDistance: CGFloat
+
+    init(minDistance: CGFloat) {
+        self.minDistance = max(0, minDistance)
+        super.init(target: nil, action: nil)
+    }
+}

pythonnative/native/ios/Sources/PythonNativeKit/Layout/PNLayout.swift

@@ -0,0 +1,173 @@
+import UIKit
+import YogaCore
+
+/// The layout tree stays beside UIKit, including intrinsic text measurement.
+final class PNLayoutNode {
+    let tag: Int64
+    let node: YGNodeRef
+    var props: [String: Any] = [:]
+    var children: [Int64] = []
+    var parent: Int64?
+    var frame: [Double] = []
+    init(_ tag: Int64) {
+        self.tag = tag
+        node = YGNodeNew()!
+        YGNodeSetContext(node, Unmanaged.passUnretained(self).toOpaque())
+    }
+    deinit { YGNodeFree(node) }
+}
+
+private let measureLeaf: YGMeasureFunc = { raw, width, widthMode, height, heightMode in
+    guard let raw = raw, let context = YGNodeGetContext(raw) else { return YGSize(width: 0, height: 0) }
+    let node = Unmanaged<PNLayoutNode>.fromOpaque(context).takeUnretainedValue()
+    guard let record = PNViewRegistry.shared.resolve(node.tag) else { return YGSize(width: 0, height: 0) }
+    let size = record.manager.measure(view: record.view,
+        maxW: widthMode.rawValue == 0 ? 1e6 : CGFloat(width),
+        maxH: heightMode.rawValue == 0 ? 1e6 : CGFloat(height))
+    return YGSize(width: Float(max(0, size.width)), height: Float(max(0, size.height)))
+}
+
+private let baselineLeaf: YGBaselineFunc = { raw, _, height in
+    guard let raw = raw, let context = YGNodeGetContext(raw) else { return height }
+    let node = Unmanaged<PNLayoutNode>.fromOpaque(context).takeUnretainedValue()
+    if let label = PNViewRegistry.shared.view(for: node.tag) as? UILabel {
+        return Float(label.font.ascender)
+    }
+    return height
+}
+
+enum PNLayout {
+    static var nodes: [Int64: PNLayoutNode] = [:]
+    static var viewport: [String: Any] = [:]
+    private static var scheduled = false
+
+    static func containerDidLayout() {
+        guard !scheduled else { return }
+        scheduled = true
+        DispatchQueue.main.async {
+            scheduled = false
+            let frames = compute(viewport)
+            if !frames.isEmpty { PNBridge.shared.callPython(kind: "layout", tag: 0, name: "", payload: PNJSON.encode(frames)) }
+        }
+    }
+
+    static func reset() {
+        for entry in nodes.values { YGNodeRemoveAllChildren(entry.node) }
+        nodes.removeAll()
+        viewport = [:]
+    }
+
+    static func observe(_ ops: [PNTransaction.Op]) {
+        for op in ops {
+            switch op {
+            case let .create(tag, _, props):
+                let entry = PNLayoutNode(tag)
+                nodes[tag] = entry
+                update(entry, props)
+            case let .update(tag, changed):
+                if let entry = nodes[tag] { update(entry, changed) }
+            case let .insert(parent, child, index):
+                guard let p = nodes[parent], let c = nodes[child] else { continue }
+                if let old = c.parent, let previous = nodes[old] {
+                    previous.children.removeAll { $0 == child }
+                    YGNodeRemoveChild(previous.node, c.node)
+                }
+                p.children.insert(child, at: min(index, p.children.count))
+                c.parent = parent
+                // Detached surfaces keep logical ownership but supply their own viewport.
+                let type = PNViewRegistry.shared.resolve(parent)?.typeName ?? ""
+                if !["VirtualList", "Modal", "ScreenStack"].contains(type) {
+                    YGNodeSetMeasureFunc(p.node, nil)
+                    YGNodeInsertChild(p.node, c.node, min(index, Int(YGNodeGetChildCount(p.node))))
+                }
+            case let .destroy(tag):
+                if let entry = nodes.removeValue(forKey: tag), let parent = entry.parent, let p = nodes[parent] {
+                    p.children.removeAll { $0 == tag }
+                    YGNodeRemoveChild(p.node, entry.node)
+                }
+            case .frame: break
+            }
+        }
+    }
+
+    private static func update(_ entry: PNLayoutNode, _ changed: [String: Any]) {
+        for (key, value) in changed {
+            if value is NSNull { entry.props.removeValue(forKey: key) }
+            else { entry.props[key] = value }
+        }
+        let fresh = YGNodeNew()!
+        for (key, value) in entry.props {
+            if let edges = value as? [String: Any], key == "margin" || key == "padding" {
+                for (edge, amount) in edges {
+                    let name = edge == "all" ? key : "\(key)_\(edge)"
+                    _ = PNYogaSetStyle(fresh, name, String(describing: amount))
+                }
+            } else { _ = PNYogaSetStyle(fresh, key, String(describing: value)) }
+        }
+        let type = PNViewRegistry.shared.resolve(entry.tag)?.typeName ?? ""
+        if ["ScrollView", "VirtualList", "ScreenStack"].contains(type) {
+            YGNodeStyleSetOverflow(fresh, YGOverflow(rawValue: 1)!)
+            YGNodeStyleSetFlexShrink(fresh, 1)
+        }
+        YGNodeCopyStyle(entry.node, fresh)
+        YGNodeFree(fresh)
+        if YGNodeGetChildCount(entry.node) == 0 && !["View", "Column", "Row", "ScrollView", "Modal", "Portal", "ScreenStack"].contains(type) {
+            YGNodeSetMeasureFunc(entry.node, measureLeaf)
+            YGNodeSetBaselineFunc(entry.node, baselineLeaf)
+            YGNodeMarkDirty(entry.node)
+        }
+    }
+
+    static func compute(_ request: [String: Any]) -> [[Double]] {
+        viewport = request
+        let width = (request["width"] as? NSNumber)?.floatValue ?? 0
+        let height = (request["height"] as? NSNumber)?.floatValue ?? 0
+        guard width > 0, height > 0 else { return [] }
+        let roots = request["roots"] as? [Int64] ?? []
+        for tag in roots {
+            if let entry = nodes[tag] { YGNodeCalculateLayout(entry.node, width, height, YGDirection(rawValue: 1)!) }
+        }
+        // A portal is absent from the screen tree, but remains a Yoga parent
+        // so absolute insets and sibling layout resolve against its viewport.
+        for entry in nodes.values {
+            guard let record = PNViewRegistry.shared.resolve(entry.tag), record.typeName == "Portal" else { continue }
+            let size = record.view.bounds.size
+            let portalWidth = size.width > 0 ? Float(size.width) : width
+            let portalHeight = size.height > 0 ? Float(size.height) : height
+            YGNodeStyleSetWidth(entry.node, portalWidth)
+            YGNodeStyleSetHeight(entry.node, portalHeight)
+            YGNodeCalculateLayout(entry.node, portalWidth, portalHeight, YGDirection(rawValue: 1)!)
+        }
+        // Every detached root is laid out in its native container's available space.
+        for entry in nodes.values where entry.parent != nil && YGNodeGetOwner(entry.node) == nil {
+            let parent = entry.parent.flatMap { PNViewRegistry.shared.resolve($0) }
+            let screen = PNViewRegistry.shared.resolve(entry.tag)
+            let size = (screen?.typeName == "Screen" ? screen?.view.bounds.size : parent?.view.bounds.size)
+                ?? CGSize(width: CGFloat(width), height: CGFloat(height))
+            let isList = parent?.typeName == "VirtualList"
+            let horizontal = parent.flatMap { PNViewState.existing(for: $0.view)?.props["horizontal"] as? Bool } ?? false
+            YGNodeCalculateLayout(entry.node, isList && horizontal ? Float.nan : Float(size.width > 0 ? size.width : CGFloat(width)),
+                                  isList && !horizontal ? Float.nan : Float(size.height > 0 ? size.height : CGFloat(height)), YGDirection(rawValue: 1)!)
+        }
+        var frames: [[Double]] = []
+        for entry in nodes.values {
+            let frame = [Double(YGNodeLayoutGetLeft(entry.node)), Double(YGNodeLayoutGetTop(entry.node)),
+                         Double(YGNodeLayoutGetWidth(entry.node)), Double(YGNodeLayoutGetHeight(entry.node))]
+            if frame == entry.frame { continue }
+            entry.frame = frame
+            if !roots.contains(entry.tag), let record = PNViewRegistry.shared.resolve(entry.tag) {
+                record.manager.setFrame(view: record.view, x: frame[0], y: frame[1], w: frame[2], h: frame[3])
+            }
+            PNVirtualListManager.measured(entry.tag, CGSize(width: frame[2], height: frame[3]))
+            frames.append([Double(entry.tag)] + frame)
+        }
+        return frames
+    }
+
+    static func invalidate(_ tag: Int64) {
+        guard let node = nodes[tag], YGNodeHasMeasureFunc(node.node) else { return }
+        YGNodeMarkDirty(node.node)
+        let frames = compute(viewport)
+        if !frames.isEmpty { PNBridge.shared.callPython(kind: "layout", tag: 0, name: "", payload: PNJSON.encode(frames)) }
+    }
+}

pythonnative/native/ios/Sources/PythonNativeKit/Modules/AlertModule.swift

@@ -0,0 +1,92 @@
+import UIKit
+
+/// Presents `UIAlertController`s from the top view controller.
+public enum PNAlertPresenter {
+    /// Show an alert or action sheet. `buttons` are
+    /// `{"label", "style": "default"|"cancel"|"destructive"}` dicts;
+    /// `completion` receives the tapped index, or `-1` on dismissal.
+    public static func present(
+        title: String?, message: String?, buttons: [[String: Any]], style: String,
+        completion: @escaping (Int) -> Void
+    ) {
+        guard let top = PNWindow.topViewController() else {
+            completion(-1)
+            return
+        }
+        let preferred: UIAlertController.Style = style == "action_sheet" ? .actionSheet : .alert
+        let alert = UIAlertController(title: title, message: message, preferredStyle: preferred)
+        var settled = false
+        let finish: (Int) -> Void = { index in
+            if settled { return }
+            settled = true
+            completion(index)
+        }
+        let list = buttons.isEmpty ? [["label": "OK"]] : buttons
+        for (index, button) in list.enumerated() {
+            let label = PNProps.string(button["label"]) ?? PNProps.string(button["title"]) ?? "OK"
+            let actionStyle: UIAlertAction.Style
+            switch PNProps.string(button["style"]) {
+            case "cancel": actionStyle = .cancel
+            case "destructive": actionStyle = .destructive
+            default: actionStyle = .default
+            }
+            alert.addAction(UIAlertAction(title: label, style: actionStyle) { _ in finish(index) })
+        }
+        if preferred == .actionSheet, let popover = alert.popoverPresentationController {
+            popover.sourceView = top.view
+            popover.sourceRect = CGRect(x: top.view.bounds.midX, y: top.view.bounds.maxY - 1, width: 1, height: 1)
+            popover.permittedArrowDirections = []
+        }
+        top.present(alert, animated: true)
+        // A sheet dismissed by tapping outside (iPad popover) never runs
+        // an action; report -1 once it disappears.
+        PNAlertDismissWatcher.watch(alert) { finish(-1) }
+    }
+}
+
+/// Observes an alert's disappearance to report an outside-tap dismissal.
+final class PNAlertDismissWatcher: NSObject, UIPopoverPresentationControllerDelegate {
+    private let onDismiss: () -> Void
+    private static var watchers: [ObjectIdentifier: PNAlertDismissWatcher] = [:]
+
+    private init(onDismiss: @escaping () -> Void) {
+        self.onDismiss = onDismiss
+    }
+
+    static func watch(_ alert: UIAlertController, onDismiss: @escaping () -> Void) {
+        let watcher = PNAlertDismissWatcher(onDismiss: onDismiss)
+        watchers[ObjectIdentifier(alert)] = watcher
+        alert.popoverPresentationController?.delegate = watcher
+    }
+
+    func presentationControllerDidDismiss(_ presentationController: UIPresentationController) {
+        onDismiss()
+        PNAlertDismissWatcher.watchers.removeValue(forKey: ObjectIdentifier(presentationController.presentedViewController))
+    }
+}
+
+/// `Alert`: `present` (async, resolves the tapped index) and `show` (fire-and-forget).
+public final class AlertModule: PNNativeModule {
+    public static let name = "Alert"
+
+    public init() {}
+
+    public func call(_ method: String, args: [String: Any], promise: PNPromise) {
+        switch method {
+        case "present", "show":
+            let buttons = ((args["buttons"] as? [Any]) ?? []).compactMap { $0 as? [String: Any] }
+            let fireAndForget = method == "show"
+            if fireAndForget { promise.resolve(nil) }
+            PNAlertPresenter.present(
+                title: PNProps.string(args["title"]),
+                message: PNProps.string(args["message"]),
+                buttons: buttons,
+                style: PNProps.string(args["style"]) ?? "alert"
+            ) { index in
+                if !fireAndForget { promise.resolve(index) }
+            }
+        default:
+            promise.reject("Alert has no method '\(method)'", code: "unknown_method")
+        }
+    }
+}

pythonnative/native/ios/Sources/PythonNativeKit/Modules/HostModule.swift

@@ -0,0 +1,80 @@
+import UIKit
+
+/// `Host`: screen root attachment, stack navigation, viewport queries,
+/// and the main-queue pump.
+public final class HostModule: PNNativeModule {
+    public static let name = "Host"
+
+    public init() {}
+
+    public func call(_ method: String, args: [String: Any], promise: PNPromise) {
+        switch method {
+        case "cache_state":
+            guard let controller = screen(args, promise) else { return }
+            controller.cachedStateJSON = args["state"] as? String
+            promise.resolve(nil)
+        case "attach_root":
+            guard let controller = screen(args, promise) else { return }
+            guard let tag = PNProps.int(args["tag"]), let view = PNViewRegistry.shared.view(for: Int64(tag)) else {
+                promise.reject("attach_root: unknown view tag", code: "unknown_tag")
+                return
+            }
+            controller.attachRoot(view)
+            promise.resolve(controller.viewport())
+        case "detach_root":
+            guard let controller = screen(args, promise) else { return }
+            if let tag = PNProps.int(args["tag"]), let view = PNViewRegistry.shared.view(for: Int64(tag)) {
+                controller.detachRoot(view)
+            }
+            promise.resolve(nil)
+        case "viewport":
+            guard let controller = screen(args, promise) else { return }
+            promise.resolve(controller.viewport())
+        case "set_options":
+            guard let controller = screen(args, promise) else { return }
+            HostModule.applyOptions(PNProps.dict(args["options"]) ?? [:], to: controller)
+            promise.resolve(nil)
+        case "finish":
+            promise.resolve(nil)
+        default:
+            promise.reject("Host has no method '\(method)'", code: "unknown_method")
+        }
+    }
+
+    // MARK: - Helpers
+
+    private func screen(_ args: [String: Any], _ promise: PNPromise) -> PNViewController? {
+        guard let id = PNProps.int(args["screen"]) else {
+            promise.reject("missing 'screen' id", code: "bad_args")
+            return nil
+        }
+        guard let controller = PNScreenRegistry.shared.controller(for: Int64(id)) else {
+            promise.reject("no screen with id \(id)", code: "unknown_screen")
+            return nil
+        }
+        return controller
+    }
+
+    static func applyOptions(_ options: [String: Any], to controller: UIViewController) {
+        if let title = PNProps.string(options["title"]) {
+            controller.title = title
+        }
+        if let hidden = PNProps.bool(options["header_shown"]) {
+            controller.navigationController?.setNavigationBarHidden(!hidden, animated: false)
+        }
+        if let hidesBack = PNProps.bool(options["hide_back_button"]) {
+            controller.navigationItem.hidesBackButton = hidesBack
+        }
+        if let color = PNColor.parse(options["header_tint_color"]) {
+            controller.navigationController?.navigationBar.tintColor = color
+        }
+        if let color = PNColor.parse(options["header_background_color"]) {
+            let appearance = UINavigationBarAppearance()
+            appearance.configureWithOpaqueBackground()
+            appearance.backgroundColor = color
+            controller.navigationItem.standardAppearance = appearance
+            controller.navigationItem.scrollEdgeAppearance = appearance
+        }
+    }
+
+}