pythonnative 0.40.0__cp313-cp313-win_amd64.whl

pythonnative/native/ios/Sources/PythonNativeKit/Bridge/PNRegistry.swift

@@ -0,0 +1,142 @@
+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("Screen") { PNScreenManager() }
+        registry.registerComponent("ScreenStack") { PNScreenStackManager() }
+        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)
+    }
+}

pythonnative/native/ios/Sources/PythonNativeKit/Bridge/PNTransaction.swift

@@ -0,0 +1,166 @@
+import UIKit
+
+/// Decodes and applies reconciler transactions.
+///
+/// A transaction is a JSON array of ops:
+///
+/// - `["c", tag, "Type", {props}]` create a view
+/// - `["u", tag, {changed}]` apply changed props (`null` removes a prop)
+/// - `["i", parent, child, index]` ensure `child` is at `index` under `parent`
+/// - `["d", tag]` destroy the view
+/// - `["f", tag, x, y, w, h]` set the frame in points
+///
+/// Ops are applied strictly in order; a failing op is logged and skipped
+/// so one bad prop can't desync the rest of the tree.
+public enum PNTransaction {
+    /// A decoded op.
+    public enum Op: Equatable {
+        case create(tag: Int64, type: String, props: [String: Any])
+        case update(tag: Int64, changed: [String: Any])
+        case insert(parent: Int64, child: Int64, index: Int)
+        case destroy(tag: Int64)
+        case frame(tag: Int64, x: Double, y: Double, w: Double, h: Double)
+
+        public static func == (lhs: Op, rhs: Op) -> Bool {
+            switch (lhs, rhs) {
+            case let (.create(t1, ty1, p1), .create(t2, ty2, p2)):
+                return t1 == t2 && ty1 == ty2 && NSDictionary(dictionary: p1).isEqual(to: p2)
+            case let (.update(t1, p1), .update(t2, p2)):
+                return t1 == t2 && NSDictionary(dictionary: p1).isEqual(to: p2)
+            case let (.insert(p1, c1, i1), .insert(p2, c2, i2)):
+                return p1 == p2 && c1 == c2 && i1 == i2
+            case let (.destroy(t1), .destroy(t2)):
+                return t1 == t2
+            case let (.frame(t1, x1, y1, w1, h1), .frame(t2, x2, y2, w2, h2)):
+                return t1 == t2 && x1 == x2 && y1 == y2 && w1 == w2 && h1 == h2
+            default:
+                return false
+            }
+        }
+    }
+
+    /// Errors raised while decoding a single op.
+    public enum DecodeError: Error, Equatable {
+        case notAnArray
+        case malformedOp(index: Int)
+        case unknownOpcode(String)
+    }
+
+    // MARK: - Decoding
+
+    /// Decode a transaction document into ops. Malformed ops are skipped
+    /// (and logged) rather than failing the whole batch.
+    public static func decode(_ json: String) throws -> [Op] {
+        guard let root = PNJSON.decode(json) as? [Any] else { throw DecodeError.notAnArray }
+        var ops: [Op] = []
+        ops.reserveCapacity(root.count)
+        for (index, raw) in root.enumerated() {
+            do {
+                ops.append(try decodeOp(raw, index: index))
+            } catch {
+                PNLog.rateLimited(PNLog.bridge, key: "decode-op", "skipping malformed op #\(index): \(error)")
+            }
+        }
+        return ops
+    }
+
+    static func decodeOp(_ raw: Any, index: Int) throws -> Op {
+        guard let parts = raw as? [Any], let code = parts.first as? String else {
+            throw DecodeError.malformedOp(index: index)
+        }
+        func tag(_ i: Int) throws -> Int64 {
+            guard i < parts.count, let value = PNProps.double(parts[i]), value.isFinite else {
+                throw DecodeError.malformedOp(index: index)
+            }
+            return Int64(value)
+        }
+        func number(_ i: Int) throws -> Double {
+            guard i < parts.count, let value = PNProps.double(parts[i]) else {
+                throw DecodeError.malformedOp(index: index)
+            }
+            return value
+        }
+        switch code {
+        case "c":
+            guard parts.count >= 4, let type = parts[2] as? String else { throw DecodeError.malformedOp(index: index) }
+            let props = (PNJSON.resolveInfinity(parts[3]) as? [String: Any]) ?? [:]
+            return .create(tag: try tag(1), type: type, props: props)
+        case "u":
+            guard parts.count >= 3 else { throw DecodeError.malformedOp(index: index) }
+            let changed = (PNJSON.resolveInfinity(parts[2]) as? [String: Any]) ?? [:]
+            return .update(tag: try tag(1), changed: changed)
+        case "i":
+            guard parts.count >= 4 else { throw DecodeError.malformedOp(index: index) }
+            return .insert(parent: try tag(1), child: try tag(2), index: Int(try number(3)))
+        case "d":
+            return .destroy(tag: try tag(1))
+        case "f":
+            guard parts.count >= 6 else { throw DecodeError.malformedOp(index: index) }
+            return .frame(tag: try tag(1), x: try number(2), y: try number(3), w: try number(4), h: try number(5))
+        default:
+            throw DecodeError.unknownOpcode(code)
+        }
+    }
+
+    // MARK: - Applying
+
+    /// Decode and apply a transaction document.
+    public static func apply(_ json: String) {
+        let ops: [Op]
+        do {
+            ops = try decode(json)
+        } catch {
+            PNLog.bridge.error("transaction rejected: \(String(describing: error))")
+            return
+        }
+        apply(ops)
+    }
+
+    /// Apply already-decoded ops in order with per-op error isolation.
+    public static func apply(_ ops: [Op]) {
+        let registry = PNViewRegistry.shared
+        for op in ops {
+            switch op {
+            case let .create(tag, type, props):
+                if registry.resolve(tag) != nil {
+                    PNLog.rateLimited(PNLog.bridge, key: "dup-create", "create for tag \(tag) ignored: already exists")
+                    continue
+                }
+                let manager = PNRegistry.shared.manager(for: type)
+                let view = manager.createView(tag: tag, props: props)
+                registry.register(PNViewRecord(tag: tag, typeName: type, view: view, manager: manager))
+                manager.didCreate(view: view, tag: tag, props: props)
+
+            case let .update(tag, changed):
+                guard let record = registry.resolve(tag) else {
+                    PNLog.rateLimited(PNLog.bridge, key: "missing-update", "update for unknown tag \(tag)")
+                    continue
+                }
+                record.manager.update(view: record.view, changed: changed)
+
+            case let .insert(parent, child, index):
+                guard let parentRecord = registry.resolve(parent), let childRecord = registry.resolve(child) else {
+                    PNLog.rateLimited(PNLog.bridge, key: "missing-insert", "insert \(child) into \(parent): unknown tag")
+                    continue
+                }
+                parentRecord.manager.insertChild(parent: parentRecord.view, child: childRecord.view, index: index)
+
+            case let .destroy(tag):
+                PNAnimationGraph.forget(tag)
+                guard let record = registry.unregister(tag) else { continue }
+                if let parentTag = PNLayout.nodes[tag]?.parent, let parentRecord = registry.resolve(parentTag) {
+                    parentRecord.manager.removeChild(parent: parentRecord.view, child: record.view)
+                } else if let parent = record.view.superview,
+                          let state = PNViewState.existing(for: parent), let parentRecord = registry.resolve(state.tag) {
+                    parentRecord.manager.removeChild(parent: parent, child: record.view)
+                }
+                record.manager.destroy(view: record.view)
+                PNViewState.detach(record.view)
+
+            case let .frame(tag, x, y, w, h):
+                guard let record = registry.resolve(tag) else { continue }
+                record.manager.setFrame(view: record.view, x: x, y: y, w: w, h: h)
+            }
+        }
+    }
+}

pythonnative/native/ios/Sources/PythonNativeKit/Bridge/PNViewRegistry.swift

@@ -0,0 +1,53 @@
+import UIKit
+
+/// One live native view addressed by its reconciler tag.
+public final class PNViewRecord {
+    public let tag: Int64
+    public let typeName: String
+    public let view: UIView
+    public let manager: PNComponentManager
+
+    init(tag: Int64, typeName: String, view: UIView, manager: PNComponentManager) {
+        self.tag = tag
+        self.typeName = typeName
+        self.view = view
+        self.manager = manager
+    }
+}
+
+/// Tag -> view table. Every view created through a transaction is
+/// registered here until its `d` op arrives.
+public final class PNViewRegistry {
+    public static let shared = PNViewRegistry()
+
+    private var records: [Int64: PNViewRecord] = [:]
+
+    private init() {}
+
+    /// The record for `tag`, or `nil` when no such view exists.
+    public func resolve(_ tag: Int64) -> PNViewRecord? {
+        records[tag]
+    }
+
+    /// The registered view for `tag`.
+    public func view(for tag: Int64) -> UIView? {
+        records[tag]?.view
+    }
+
+    /// Number of live records (used by tests and diagnostics).
+    public var count: Int { records.count }
+
+    func register(_ record: PNViewRecord) {
+        records[record.tag] = record
+    }
+
+    @discardableResult
+    func unregister(_ tag: Int64) -> PNViewRecord? {
+        records.removeValue(forKey: tag)
+    }
+
+    /// Drop every record. Intended for tests.
+    public func removeAll() {
+        records.removeAll()
+    }
+}

pythonnative/native/ios/Sources/PythonNativeKit/Components/PNButtonManagers.swift

@@ -0,0 +1,207 @@
+import UIKit
+
+/// A closure-backed `UIControl` target with the duplicate-send filter the
+/// simulator's event injection needs (one `UIEvent`, two action sends).
+public final class PNActionTarget: NSObject {
+    private let handler: () -> Void
+    private var lastTimestamp: TimeInterval?
+
+    public init(_ handler: @escaping () -> Void) {
+        self.handler = handler
+    }
+
+    /// Attach `handler` to `control` for `events`, retained by the view's state.
+    @discardableResult
+    public static func attach(_ control: UIControl, events: UIControl.Event, _ handler: @escaping () -> Void) -> PNActionTarget {
+        let target = PNActionTarget(handler)
+        control.addTarget(target, action: #selector(fire(_:forEvent:)), for: events)
+        PNViewState.existing(for: control)?.retained.append(target)
+        return target
+    }
+
+    @objc func fire(_ sender: Any?, forEvent event: UIEvent?) {
+        if let timestamp = event?.timestamp {
+            if lastTimestamp == timestamp {
+                PNLog.once(PNLog.components, key: "control-dedupe", "dropped a duplicated control action (one UIEvent, two sends)")
+                return
+            }
+            lastTimestamp = timestamp
+        }
+        handler()
+    }
+}
+
+/// `Button`: a system `UIButton` emitting `on_press`.
+public final class PNButtonManager: PNComponentManager {
+    public override func makeView(props: [String: Any]) -> UIView {
+        UIButton(type: .system)
+    }
+
+    public override func createView(tag: Int64, props: [String: Any]) -> UIView {
+        let view = super.createView(tag: tag, props: props)
+        if let button = view as? UIButton {
+            PNActionTarget.attach(button, events: .touchUpInside) { [weak button] in
+                guard let button = button else { return }
+                PNEvents.emit(button, "on_press")
+            }
+        }
+        return view
+    }
+
+    public override func apply(view: UIView, props: [String: Any], initial: Bool) {
+        guard let button = view as? UIButton else { return }
+        if PNProps.has(props, "title") {
+            button.setTitle(PNProps.string(PNProps.value(props, "title")) ?? "", for: .normal)
+        }
+        if let size = PNProps.double(PNProps.value(props, "font_size")) {
+            button.titleLabel?.font = UIFont.systemFont(ofSize: CGFloat(size))
+        }
+        if let color = PNColor.parse(PNProps.value(props, "background_color")) {
+            button.backgroundColor = color
+            if !PNProps.has(props, "color") {
+                button.setTitleColor(.white, for: .normal)
+            }
+        }
+        if let color = PNColor.parse(PNProps.value(props, "color")) {
+            button.setTitleColor(color, for: .normal)
+        }
+        if PNProps.has(props, "disabled") {
+            button.isEnabled = !(PNProps.bool(PNProps.value(props, "disabled")) ?? false)
+        }
+        PNViewStyler.applyDecoration(button, props)
+    }
+
+    public override func measure(view: UIView, maxW: CGFloat, maxH: CGFloat) -> CGSize {
+        let intrinsic = view.intrinsicContentSize
+        var w = intrinsic.width + 24
+        var h = intrinsic.height + 12
+        if maxW.isFinite { w = min(w, maxW) }
+        if maxH.isFinite { h = min(h, maxH) }
+        return CGSize(width: max(w, 44), height: max(h, 32))
+    }
+}
+
+/// `Checkbox`: an SF Symbol button toggling checked / unchecked.
+public final class PNCheckboxManager: PNComponentManager {
+    public override func makeView(props: [String: Any]) -> UIView {
+        UIButton(type: .custom)
+    }
+
+    public override func createView(tag: Int64, props: [String: Any]) -> UIView {
+        let view = super.createView(tag: tag, props: props)
+        if let button = view as? UIButton {
+            PNActionTarget.attach(button, events: .touchUpInside) { [weak self, weak button] in
+                guard let self = self, let button = button else { return }
+                self.toggle(button)
+            }
+        }
+        return view
+    }
+
+    public override func apply(view: UIView, props: [String: Any], initial: Bool) {
+        guard let button = view as? UIButton, let state = PNViewState.existing(for: button) else { return }
+        if initial {
+            let ink = PNColor.parse("#111111") ?? .label
+            button.setTitleColor(ink, for: .normal)
+            button.tintColor = ink
+        }
+        if PNProps.has(props, "value") {
+            state.extras["value"] = PNProps.bool(PNProps.value(props, "value")) ?? false
+        }
+        if PNProps.has(props, "label") {
+            let label = PNProps.string(PNProps.value(props, "label")) ?? ""
+            button.setTitle(label, for: .normal)
+            button.accessibilityLabel = label
+        }
+        if PNProps.has(props, "disabled") {
+            button.isEnabled = !(PNProps.bool(PNProps.value(props, "disabled")) ?? false)
+        }
+        updateImage(button)
+        PNViewStyler.applyAccessibility(button, props)
+    }
+
+    private func toggle(_ button: UIButton) {
+        guard let state = PNViewState.existing(for: button) else { return }
+        if PNProps.bool(PNProps.value(state.props, "disabled")) == true { return }
+        let newValue = !state.flag("value")
+        // Optimistic flip so the box feels instant; the `value` prop re-syncs it.
+        state.extras["value"] = newValue
+        updateImage(button)
+        PNEvents.emit(button, "on_change", [newValue])
+    }
+
+    private func updateImage(_ button: UIButton) {
+        guard let state = PNViewState.existing(for: button) else { return }
+        let checked = state.flag("value")
+        guard var image = UIImage(systemName: checked ? "checkmark.square.fill" : "square") else { return }
+        if checked, let color = PNColor.parse(PNProps.value(state.props, "color")) {
+            image = image.withTintColor(color, renderingMode: .alwaysOriginal)
+        }
+        button.setImage(image, for: .normal)
+    }
+
+    public override func measure(view: UIView, maxW: CGFloat, maxH: CGFloat) -> CGSize {
+        let size = view.sizeThatFits(CGSize(width: PNComponentManager.clampConstraint(maxW), height: PNComponentManager.clampConstraint(maxH)))
+        var w = max(size.width + 8, 28)
+        if maxW.isFinite { w = min(w, maxW) }
+        return CGSize(width: w, height: max(size.height, 28))
+    }
+}
+
+/// `Picker`: a button that presents an action sheet listing the options.
+public final class PNPickerManager: PNComponentManager {
+    public override func makeView(props: [String: Any]) -> UIView {
+        UIButton(type: .system)
+    }
+
+    public override func createView(tag: Int64, props: [String: Any]) -> UIView {
+        let view = super.createView(tag: tag, props: props)
+        if let button = view as? UIButton {
+            PNActionTarget.attach(button, events: .touchUpInside) { [weak self, weak button] in
+                guard let self = self, let button = button else { return }
+                self.presentSheet(button)
+            }
+        }
+        return view
+    }
+
+    public override func apply(view: UIView, props: [String: Any], initial: Bool) {
+        guard let button = view as? UIButton else { return }
+        button.setTitle(PNPickerManager.title(for: mergedProps(button)), for: .normal)
+        if PNProps.has(props, "disabled") { button.isEnabled = !(PNProps.bool(PNProps.value(props, "disabled")) ?? false) }
+        PNViewStyler.applyAccessibility(button, props)
+    }
+
+    static func items(_ props: [String: Any]) -> [[String: Any]] {
+        ((PNProps.value(props, "items") as? [Any]) ?? []).compactMap { $0 as? [String: Any] }
+    }
+
+    static func title(for props: [String: Any]) -> String {
+        let selected = PNProps.value(props, "value")
+        for item in items(props) {
+            if let value = PNProps.value(item, "value"), PNJSON.encode(value) == PNJSON.encode(selected) {
+                return PNProps.string(item["label"]) ?? PNProps.string(item["value"]) ?? ""
+            }
+        }
+        return PNProps.string(PNProps.value(props, "placeholder")) ?? "Select…"
+    }
+
+    private func presentSheet(_ button: UIButton) {
+        let merged = mergedProps(button)
+        let items = PNPickerManager.items(merged)
+        var buttons: [[String: Any]] = items.map { ["label": PNProps.string($0["label"]) ?? PNProps.string($0["value"]) ?? ""] }
+        buttons.append(["label": "Cancel", "style": "cancel"])
+        PNAlertPresenter.present(
+            title: PNProps.string(PNProps.value(merged, "placeholder")) ?? "Select…",
+            message: nil, buttons: buttons, style: "action_sheet"
+        ) { index in
+            guard index >= 0, index < items.count else { return }
+            PNEvents.emit(button, "on_change", [PNProps.value(items[index], "value")])
+        }
+    }
+
+    public override func measure(view: UIView, maxW: CGFloat, maxH: CGFloat) -> CGSize {
+        let size = view.sizeThatFits(CGSize(width: PNComponentManager.clampConstraint(maxW), height: PNComponentManager.clampConstraint(maxH)))
+        return CGSize(width: size.width + 16, height: size.height + 8)
+    }
+}