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

pythonnative/templates/ios_template/PythonNativeKit/Sources/PythonNativeKit/Components/PNViewStyler.swift

@@ -0,0 +1,340 @@
+import UIKit
+
+/// Applies the visual props every element type shares.
+///
+/// `applyCommon` is the full container set (background, overflow,
+/// display, opacity, z-index, pointer events, borders, shadows,
+/// transform, accessibility). `applyDecoration` is the subset leaf
+/// controls use (borders, shadow, transform, accessibility, opacity),
+/// mirroring the per-handler behavior of the original iOS backend.
+public enum PNViewStyler {
+    static let cornerRadiusKeys = [
+        "border_top_left_radius", "border_top_right_radius",
+        "border_bottom_left_radius", "border_bottom_right_radius",
+    ]
+    static let sideWidthKeys = ["border_left_width", "border_top_width", "border_right_width", "border_bottom_width"]
+    static let sideColorKeys = ["border_left_color", "border_top_color", "border_right_color", "border_bottom_color"]
+    static let shadowKeys = ["shadow_color", "shadow_offset", "shadow_opacity", "shadow_radius", "elevation"]
+    static let maskedCornerBits: [CACornerMask] = [
+        .layerMinXMinYCorner, .layerMaxXMinYCorner, .layerMinXMaxYCorner, .layerMaxXMaxYCorner,
+    ]
+    static let allCorners: CACornerMask = [
+        .layerMinXMinYCorner, .layerMaxXMinYCorner, .layerMinXMaxYCorner, .layerMaxXMaxYCorner,
+    ]
+
+    // MARK: - Entry points
+
+    /// Apply every shared visual prop present in `props`.
+    public static func applyCommon(_ view: UIView, _ props: [String: Any]) {
+        if let color = PNColor.parse(PNProps.value(props, "background_color")) {
+            view.backgroundColor = color
+        }
+        if PNProps.has(props, "overflow") {
+            view.clipsToBounds = PNProps.string(PNProps.value(props, "overflow")) == "hidden"
+        }
+        if PNProps.has(props, "display") {
+            view.isHidden = PNProps.string(PNProps.value(props, "display")) == "none"
+        }
+        if let opacity = PNProps.double(PNProps.value(props, "opacity")) {
+            view.alpha = CGFloat(opacity)
+        }
+        if PNProps.has(props, "z_index") {
+            view.layer.zPosition = CGFloat(PNProps.double(PNProps.value(props, "z_index")) ?? 0)
+        }
+        if PNProps.has(props, "pointer_events") || PNProps.has(props, "hit_slop") {
+            applyInteraction(view, props)
+        }
+        applyBorder(view, props)
+        applySideBorders(view, props)
+        let merged = PNViewState.existing(for: view)?.props ?? props
+        let cornerKeysActive = cornerRadiusKeys.contains { PNProps.value(merged, $0) != nil }
+        if cornerRadiusKeys.contains(where: { PNProps.has(props, $0) }) || (PNProps.has(props, "border_radius") && cornerKeysActive) {
+            applyCornerRadii(view, merged)
+        }
+        applyShadow(view, props)
+        if PNProps.has(props, "transform") {
+            PNTransform.apply(view, spec: PNProps.value(props, "transform"))
+        }
+        applyAccessibility(view, props)
+    }
+
+    /// The leaf-control subset: border, shadow, transform, accessibility, opacity.
+    public static func applyDecoration(_ view: UIView, _ props: [String: Any]) {
+        applyBorder(view, props)
+        applyShadow(view, props)
+        if PNProps.has(props, "transform") {
+            PNTransform.apply(view, spec: PNProps.value(props, "transform"))
+        }
+        applyAccessibility(view, props)
+        if let opacity = PNProps.double(PNProps.value(props, "opacity")) {
+            view.alpha = CGFloat(opacity)
+        }
+    }
+
+    /// Re-run the bounds-dependent parts of styling after a frame change.
+    public static func syncFrameDependentStyles(_ view: UIView, size: CGSize) {
+        guard let state = PNViewState.existing(for: view) else { return }
+        let maxRadius = max(0, min(size.width, size.height) / 2)
+        if let requested = state.requestedCornerRadius, maxRadius > 0 {
+            view.layer.cornerRadius = min(requested, maxRadius)
+        } else if state.requestedCornerRadius == nil, view.layer.cornerRadius > 0, maxRadius > 0 {
+            view.layer.cornerRadius = min(view.layer.cornerRadius, maxRadius)
+        }
+        updateCornerMask(view, state: state, size: size)
+        updateSideBorderLayers(view, state: state, size: size)
+    }
+
+    // MARK: - Borders
+
+    static func applyBorder(_ view: UIView, _ props: [String: Any]) {
+        let layer = view.layer
+        if let radius = PNProps.double(PNProps.value(props, "border_radius")) {
+            let requested = CGFloat(max(0, radius))
+            PNViewState.existing(for: view)?.requestedCornerRadius = requested
+            let size = view.bounds.size
+            var value = requested
+            if size.width > 0, size.height > 0 {
+                value = min(requested, min(size.width, size.height) / 2)
+            }
+            layer.cornerRadius = value
+            // Rounded corners clip implicitly (the React Native default).
+            layer.masksToBounds = true
+        } else if PNProps.has(props, "border_radius") {
+            PNViewState.existing(for: view)?.requestedCornerRadius = nil
+            layer.cornerRadius = 0
+        }
+        if let width = PNProps.double(PNProps.value(props, "border_width")) {
+            layer.borderWidth = CGFloat(width)
+        } else if PNProps.has(props, "border_width") {
+            layer.borderWidth = 0
+        }
+        if let color = PNColor.parse(PNProps.value(props, "border_color")) {
+            layer.borderColor = color.cgColor
+        }
+    }
+
+    static func applySideBorders(_ view: UIView, _ props: [String: Any]) {
+        guard sideWidthKeys.contains(where: { PNProps.value(props, $0) != nil }),
+              let state = PNViewState.existing(for: view)
+        else { return }
+        let merged = state.props
+        let baseWidth = CGFloat(PNProps.double(PNProps.value(merged, "border_width")) ?? 0)
+        let baseColor = PNColor.parse(PNProps.value(merged, "border_color")) ?? .black
+        state.sideBorderWidths = sideWidthKeys.map { key in
+            CGFloat(PNProps.double(PNProps.value(merged, key)) ?? Double(baseWidth))
+        }
+        state.sideBorderColors = sideColorKeys.map { key in
+            PNColor.parse(PNProps.value(merged, key)) ?? baseColor
+        }
+        view.layer.borderWidth = 0
+        let size = view.bounds.size
+        if size.width > 0, size.height > 0 {
+            updateSideBorderLayers(view, state: state, size: size)
+        }
+    }
+
+    static func updateSideBorderLayers(_ view: UIView, state: PNViewState, size: CGSize) {
+        guard let widths = state.sideBorderWidths, let colors = state.sideBorderColors else { return }
+        let frames = [
+            CGRect(x: 0, y: 0, width: widths[0], height: size.height),
+            CGRect(x: 0, y: 0, width: size.width, height: widths[1]),
+            CGRect(x: size.width - widths[2], y: 0, width: widths[2], height: size.height),
+            CGRect(x: 0, y: size.height - widths[3], width: size.width, height: widths[3]),
+        ]
+        for i in 0..<4 {
+            if widths[i] <= 0 {
+                state.sideBorderLayers[i]?.removeFromSuperlayer()
+                state.sideBorderLayers[i] = nil
+                continue
+            }
+            let layer = state.sideBorderLayers[i] ?? {
+                let created = CALayer()
+                view.layer.addSublayer(created)
+                state.sideBorderLayers[i] = created
+                return created
+            }()
+            layer.backgroundColor = colors[i].cgColor
+            layer.frame = frames[i]
+        }
+    }
+
+    // MARK: - Per-corner radii
+
+    static func applyCornerRadii(_ view: UIView, _ merged: [String: Any]) {
+        guard let state = PNViewState.existing(for: view) else { return }
+        let anyCorner = cornerRadiusKeys.contains { PNProps.value(merged, $0) != nil }
+        if !anyCorner {
+            if state.cornerRadii != nil {
+                state.cornerRadii = nil
+                view.layer.mask = nil
+                view.layer.maskedCorners = allCorners
+                applyBorder(view, merged)
+            }
+            return
+        }
+        let base = CGFloat(max(0, PNProps.double(PNProps.value(merged, "border_radius")) ?? 0))
+        let radii: [CGFloat] = cornerRadiusKeys.map { key in
+            guard let value = PNProps.double(PNProps.value(merged, key)), value.isFinite else { return base }
+            return CGFloat(max(0, value))
+        }
+        let distinct = Set(radii.filter { $0 > 0 })
+        if distinct.count <= 1 {
+            state.cornerRadii = nil
+            let value = distinct.first ?? 0
+            var mask: CACornerMask = []
+            for (bit, r) in zip(maskedCornerBits, radii) where r > 0 {
+                mask.insert(bit)
+            }
+            view.layer.mask = nil
+            view.layer.cornerRadius = value
+            view.layer.maskedCorners = mask.isEmpty ? allCorners : mask
+            view.layer.masksToBounds = true
+            state.requestedCornerRadius = value
+            return
+        }
+        state.requestedCornerRadius = nil
+        state.cornerRadii = radii
+        view.layer.cornerRadius = 0
+        view.layer.maskedCorners = allCorners
+        let size = view.bounds.size
+        if size.width > 0, size.height > 0 {
+            updateCornerMask(view, state: state, size: size)
+        }
+    }
+
+    static func updateCornerMask(_ view: UIView, state: PNViewState, size: CGSize) {
+        guard let radii = state.cornerRadii, size.width > 0, size.height > 0 else { return }
+        var scale: CGFloat = 1
+        let (tl0, tr0, bl0, br0) = (radii[0], radii[1], radii[2], radii[3])
+        for (sum, extent) in [(tl0 + tr0, size.width), (bl0 + br0, size.width), (tl0 + bl0, size.height), (tr0 + br0, size.height)]
+        where sum > extent && extent > 0 {
+            scale = min(scale, extent / sum)
+        }
+        let (tl, tr, bl, br) = (tl0 * scale, tr0 * scale, bl0 * scale, br0 * scale)
+        let w = size.width, h = size.height
+        let path = UIBezierPath()
+        let halfPi = CGFloat.pi / 2
+        path.move(to: CGPoint(x: tl, y: 0))
+        path.addLine(to: CGPoint(x: w - tr, y: 0))
+        if tr > 0 { path.addArc(withCenter: CGPoint(x: w - tr, y: tr), radius: tr, startAngle: -halfPi, endAngle: 0, clockwise: true) }
+        path.addLine(to: CGPoint(x: w, y: h - br))
+        if br > 0 { path.addArc(withCenter: CGPoint(x: w - br, y: h - br), radius: br, startAngle: 0, endAngle: halfPi, clockwise: true) }
+        path.addLine(to: CGPoint(x: bl, y: h))
+        if bl > 0 { path.addArc(withCenter: CGPoint(x: bl, y: h - bl), radius: bl, startAngle: halfPi, endAngle: .pi, clockwise: true) }
+        path.addLine(to: CGPoint(x: 0, y: tl))
+        if tl > 0 { path.addArc(withCenter: CGPoint(x: tl, y: tl), radius: tl, startAngle: .pi, endAngle: .pi + halfPi, clockwise: true) }
+        path.close()
+        let shape = CAShapeLayer()
+        shape.frame = CGRect(origin: .zero, size: size)
+        shape.path = path.cgPath
+        view.layer.mask = shape
+    }
+
+    // MARK: - Shadow
+
+    static func applyShadow(_ view: UIView, _ props: [String: Any]) {
+        let layer = view.layer
+        let hasShadow = shadowKeys.contains { PNProps.value(props, $0) != nil }
+        if hasShadow, PNProps.string(PNProps.value(props, "overflow")) != "hidden" {
+            layer.masksToBounds = false
+            view.clipsToBounds = false
+        }
+        if let color = PNColor.parse(PNProps.value(props, "shadow_color")) {
+            layer.shadowColor = color.cgColor
+        }
+        if let opacity = PNProps.double(PNProps.value(props, "shadow_opacity")) {
+            layer.shadowOpacity = Float(opacity)
+        }
+        if let radius = PNProps.double(PNProps.value(props, "shadow_radius")) {
+            layer.shadowRadius = CGFloat(radius)
+        }
+        if let offset = PNProps.value(props, "shadow_offset") {
+            let (dx, dy) = shadowOffset(offset)
+            layer.shadowOffset = CGSize(width: dx, height: dy)
+        }
+    }
+
+    /// Coerce a `shadow_offset` / `text_shadow_offset` value to `(dx, dy)`.
+    public static func shadowOffset(_ value: Any?) -> (CGFloat, CGFloat) {
+        if let dict = value as? [String: Any] {
+            return (CGFloat(PNProps.double(dict["width"]) ?? 0), CGFloat(PNProps.double(dict["height"]) ?? 0))
+        }
+        if let list = value as? [Any], list.count >= 2 {
+            return (CGFloat(PNProps.double(list[0]) ?? 0), CGFloat(PNProps.double(list[1]) ?? 0))
+        }
+        return (0, 0)
+    }
+
+    // MARK: - Interaction
+
+    static func applyInteraction(_ view: UIView, _ props: [String: Any]) {
+        guard let container = view as? PNContainerView else {
+            PNLog.once(PNLog.components, key: "interaction:\(PNViewState.existing(for: view)?.tag ?? 0)",
+                       "pointer_events / hit_slop only work on container elements; ignored")
+            return
+        }
+        if PNProps.has(props, "pointer_events") {
+            let mode = PNProps.string(PNProps.value(props, "pointer_events"))
+            container.pointerEvents = ["none", "box_none", "box_only"].contains(mode ?? "") ? mode : nil
+        }
+        if PNProps.has(props, "hit_slop") {
+            container.hitSlop = hitSlop(PNProps.value(props, "hit_slop"))
+        }
+    }
+
+    /// Normalize a `hit_slop` prop into edge insets.
+    public static func hitSlop(_ value: Any?) -> UIEdgeInsets {
+        if let dict = value as? [String: Any] {
+            return UIEdgeInsets(
+                top: CGFloat(PNProps.double(dict["top"]) ?? 0), left: CGFloat(PNProps.double(dict["left"]) ?? 0),
+                bottom: CGFloat(PNProps.double(dict["bottom"]) ?? 0), right: CGFloat(PNProps.double(dict["right"]) ?? 0)
+            )
+        }
+        if let uniform = PNProps.double(value) {
+            let v = CGFloat(uniform)
+            return UIEdgeInsets(top: v, left: v, bottom: v, right: v)
+        }
+        return .zero
+    }
+
+    // MARK: - Accessibility
+
+    static let traitByRole: [String: UIAccessibilityTraits] = [
+        "button": .button, "link": .link, "image": .image, "search": .searchField,
+        "keyboard_key": .keyboardKey, "static_text": .staticText, "summary_element": .summaryElement,
+        "adjustable": .adjustable, "header": .header, "selected": .selected, "checkbox": .button, "none": [],
+    ]
+
+    static func applyAccessibility(_ view: UIView, _ props: [String: Any]) {
+        if PNProps.has(props, "accessible") {
+            view.isAccessibilityElement = PNProps.bool(PNProps.value(props, "accessible")) ?? false
+        }
+        if PNProps.has(props, "accessibility_label") {
+            view.accessibilityLabel = PNProps.string(PNProps.value(props, "accessibility_label")) ?? ""
+        }
+        if PNProps.has(props, "accessibility_hint") {
+            view.accessibilityHint = PNProps.string(PNProps.value(props, "accessibility_hint")) ?? ""
+        }
+        if PNProps.has(props, "test_id") {
+            view.accessibilityIdentifier = PNProps.string(PNProps.value(props, "test_id"))
+        }
+        let role = PNProps.string(PNProps.value(props, "accessibility_role"))
+        let state = PNProps.dict(PNProps.value(props, "accessibility_state"))
+        if role == nil, state == nil { return }
+        var traits: UIAccessibilityTraits = []
+        if let role = role {
+            traits.formUnion(traitByRole[role.lowercased()] ?? [])
+        }
+        if let state = state {
+            if PNProps.bool(state["selected"]) == true || PNProps.bool(state["checked"]) == true {
+                traits.insert(.selected)
+            }
+            if PNProps.bool(state["disabled"]) == true { traits.insert(.notEnabled) }
+            if PNProps.bool(state["busy"]) == true { traits.insert(.updatesFrequently) }
+            if let expanded = PNProps.bool(state["expanded"]) {
+                view.accessibilityValue = expanded ? "expanded" : "collapsed"
+            }
+        }
+        view.accessibilityTraits = traits
+    }
+}

pythonnative/templates/ios_template/PythonNativeKit/Sources/PythonNativeKit/Components/PNVirtualListManager.swift

@@ -0,0 +1,257 @@
+import UIKit
+
+/// `VirtualList`: a `UITableView` whose rows host PythonNative subtrees.
+///
+/// Rows are requested synchronously from Python: `on_bind_row` with
+/// `[{"container": key, "index": i, "width": w, "height": h}]` returns
+/// `{"root": tag}`, and the view with that tag is added to the cell's
+/// content view. Recycled containers emit `on_unbind_row` with
+/// `[{"container": key}]`.
+public final class PNVirtualListManager: PNComponentManager {
+    public override func makeView(props: [String: Any]) -> UIView {
+        let table = UITableView(frame: .zero, style: .plain)
+        table.separatorStyle = .none
+        table.contentInsetAdjustmentBehavior = .never
+        table.register(PNVirtualListCell.self, forCellReuseIdentifier: PNVirtualListCell.reuseIdentifier)
+        table.rowHeight = 44
+        table.estimatedRowHeight = 0
+        table.estimatedSectionHeaderHeight = 0
+        table.estimatedSectionFooterHeight = 0
+        if #available(iOS 15.0, *) {
+            table.sectionHeaderTopPadding = 0
+        }
+        return table
+    }
+
+    public override func createView(tag: Int64, props: [String: Any]) -> UIView {
+        let view = super.createView(tag: tag, props: props)
+        if let table = view as? UITableView {
+            let source = PNVirtualListSource(table: table)
+            table.dataSource = source
+            table.delegate = source
+            PNViewState.existing(for: table)?.retained.append(source)
+        }
+        return view
+    }
+
+    public override func teardown(view: UIView) {
+        guard let table = view as? UITableView else { return }
+        // The list's `d` op tells Python to unmount every subtree, so the
+        // cells only need to drop their hosted views.
+        for cell in table.visibleCells {
+            (cell as? PNVirtualListCell)?.unhost()
+        }
+        table.dataSource = nil
+        table.delegate = nil
+    }
+
+    public override func apply(view: UIView, props: [String: Any], initial: Bool) {
+        guard let table = view as? UITableView, let state = PNViewState.existing(for: table) else { return }
+        PNViewStyler.applyCommon(table, props)
+        var needsReload = false
+        if PNProps.has(props, "count") || PNProps.has(props, "row_height") || PNProps.has(props, "row_heights") {
+            needsReload = true
+        }
+        if PNProps.has(props, "row_height") {
+            table.rowHeight = CGFloat(PNProps.double(PNProps.value(props, "row_height")) ?? 44)
+        }
+        if PNProps.has(props, "shows_scroll_indicator") {
+            table.showsVerticalScrollIndicator = PNProps.bool(PNProps.value(props, "shows_scroll_indicator")) ?? true
+        }
+        if PNProps.has(props, "scroll_enabled") {
+            table.isScrollEnabled = PNProps.bool(PNProps.value(props, "scroll_enabled")) ?? true
+        }
+        if PNProps.has(props, "bounces") {
+            table.bounces = PNProps.bool(PNProps.value(props, "bounces")) ?? true
+        }
+        if PNProps.has(props, "separator") {
+            table.separatorStyle = PNProps.bool(PNProps.value(props, "separator")) == true ? .singleLine : .none
+        }
+        if PNProps.has(props, "content_inset") {
+            let inset = PNProps.dict(PNProps.value(props, "content_inset")) ?? [:]
+            table.contentInset = UIEdgeInsets(
+                top: CGFloat(PNProps.double(inset["top"]) ?? 0), left: CGFloat(PNProps.double(inset["left"]) ?? 0),
+                bottom: CGFloat(PNProps.double(inset["bottom"]) ?? 0), right: CGFloat(PNProps.double(inset["right"]) ?? 0)
+            )
+        }
+        if let mode = PNProps.string(PNProps.value(props, "keyboard_dismiss_mode")) {
+            switch mode {
+            case "on_drag": table.keyboardDismissMode = .onDrag
+            case "interactive": table.keyboardDismissMode = .interactive
+            default: table.keyboardDismissMode = .none
+            }
+        }
+        if PNProps.has(props, "generation") || PNProps.has(props, "data_version") {
+            needsReload = true
+        }
+        if needsReload, !initial {
+            state.extras["reload_pending"] = true
+            table.reloadData()
+            state.extras["reload_pending"] = false
+        }
+    }
+
+    public override func setFrame(view: UIView, x: Double, y: Double, w: Double, h: Double) {
+        let before = view.bounds.size
+        super.setFrame(view: view, x: x, y: y, w: w, h: h)
+        if let table = view as? UITableView, before.width != table.bounds.width, before.width > 0 {
+            table.reloadData()
+        }
+    }
+
+    public override func insertChild(parent: UIView, child: UIView, index: Int) {
+        // Row subtrees are attached by the data source, never by the
+        // reconciler; static children are not supported.
+        PNLog.once(PNLog.components, key: "virtuallist-child", "VirtualList ignores direct children; rows come from on_bind_row")
+    }
+
+    public override func command(view: UIView, name: String, args: [String: Any]) -> Any? {
+        guard let table = view as? UITableView else { return nil }
+        let animated = PNProps.bool(args["animated"]) ?? true
+        switch name {
+        case "scroll_to_offset":
+            let y = CGFloat(PNProps.finite(args["y"] ?? args["offset"]))
+            let x = CGFloat(PNProps.finite(args["x"]))
+            table.setContentOffset(CGPoint(x: x, y: y), animated: animated)
+        case "scroll_to_index":
+            let count = table.numberOfRows(inSection: 0)
+            guard count > 0, let index = PNProps.int(args["index"]) else { return nil }
+            let row = max(0, min(index, count - 1))
+            let position: UITableView.ScrollPosition
+            switch PNProps.string(args["position"]) {
+            case "middle", "center": position = .middle
+            case "bottom", "end": position = .bottom
+            case "top", "start": position = .top
+            default: position = .none
+            }
+            table.scrollToRow(at: IndexPath(row: row, section: 0), at: position, animated: animated)
+        case "scroll_to_end":
+            let count = table.numberOfRows(inSection: 0)
+            if count > 0 {
+                table.scrollToRow(at: IndexPath(row: count - 1, section: 0), at: .bottom, animated: animated)
+            }
+        case "get_scroll_offset":
+            return ["x": Double(table.contentOffset.x), "y": Double(table.contentOffset.y)]
+        case "reload":
+            table.reloadData()
+        case "flash_scroll_indicators":
+            table.flashScrollIndicators()
+        default:
+            break
+        }
+        return nil
+    }
+}
+
+/// A recycled row container. `containerKey` is stable for the cell's lifetime.
+final class PNVirtualListCell: UITableViewCell {
+    static let reuseIdentifier = "PNVirtualListCell"
+    private static var nextKey: Int64 = 1
+
+    let containerKey: Int64
+    private(set) var hosted: UIView?
+
+    override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {
+        containerKey = PNVirtualListCell.nextKey
+        PNVirtualListCell.nextKey += 1
+        super.init(style: style, reuseIdentifier: reuseIdentifier)
+        selectionStyle = .none
+        backgroundColor = .clear
+        contentView.clipsToBounds = true
+    }
+
+    required init?(coder: NSCoder) {
+        containerKey = PNVirtualListCell.nextKey
+        PNVirtualListCell.nextKey += 1
+        super.init(coder: coder)
+    }
+
+    func host(_ view: UIView) {
+        if hosted === view { return }
+        hosted?.removeFromSuperview()
+        hosted = view
+        view.translatesAutoresizingMaskIntoConstraints = true
+        contentView.addSubview(view)
+    }
+
+    func unhost() {
+        hosted?.removeFromSuperview()
+        hosted = nil
+    }
+}
+
+/// Data source and delegate for one list.
+final class PNVirtualListSource: NSObject, UITableViewDataSource, UITableViewDelegate {
+    private weak var table: UITableView?
+    private var bound: Set<Int64> = []
+
+    init(table: UITableView) {
+        self.table = table
+        super.init()
+    }
+
+    private var props: [String: Any] {
+        table.flatMap { PNViewState.existing(for: $0)?.props } ?? [:]
+    }
+
+    // MARK: UITableViewDataSource
+
+    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
+        max(0, PNProps.int(PNProps.value(props, "count")) ?? 0)
+    }
+
+    func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
+        let props = self.props
+        if let heights = PNProps.value(props, "row_heights") as? [Any], indexPath.row < heights.count,
+           let height = PNProps.double(heights[indexPath.row])
+        {
+            return CGFloat(height)
+        }
+        return CGFloat(PNProps.double(PNProps.value(props, "row_height")) ?? Double(tableView.rowHeight))
+    }
+
+    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
+        let dequeued = tableView.dequeueReusableCell(withIdentifier: PNVirtualListCell.reuseIdentifier, for: indexPath)
+        guard let cell = dequeued as? PNVirtualListCell else { return dequeued }
+        let width = tableView.bounds.width
+        let height = self.tableView(tableView, heightForRowAt: indexPath)
+        bind(cell, index: indexPath.row, width: width, height: height)
+        return cell
+    }
+
+    private func bind(_ cell: PNVirtualListCell, index: Int, width: CGFloat, height: CGFloat) {
+        guard let table = table else { return }
+        let payload: [String: Any] = [
+            "container": cell.containerKey, "index": index, "width": Double(width), "height": Double(height),
+        ]
+        bound.insert(cell.containerKey)
+        guard let reply = PNEvents.emit(table, "on_bind_row", [payload]) else {
+            cell.unhost()
+            return
+        }
+        let root = PNProps.dict(PNJSON.decode(reply))?["root"]
+        guard let tag = PNProps.int(root), let view = PNViewRegistry.shared.view(for: Int64(tag)) else {
+            cell.unhost()
+            return
+        }
+        cell.host(view)
+    }
+
+    func tableView(_ tableView: UITableView, didEndDisplaying cell: UITableViewCell, forRowAt indexPath: IndexPath) {
+        guard let cell = cell as? PNVirtualListCell, let table = table else { return }
+        cell.unhost()
+        if bound.remove(cell.containerKey) != nil {
+            PNEvents.emit(table, "on_unbind_row", [["container": cell.containerKey]])
+        }
+    }
+
+    // MARK: UIScrollViewDelegate
+
+    func scrollViewDidScroll(_ scrollView: UIScrollView) {
+        PNEvents.emitIfWired(scrollView, "on_scroll", [PNScrollPayload.make(scrollView)])
+    }
+
+    func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
+        PNEvents.emitIfWired(scrollView, "on_momentum_scroll_end", [PNScrollPayload.make(scrollView)])
+    }
+}