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

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

@@ -0,0 +1,221 @@
+import CryptoKit
+import UIKit
+
+/// `Image`: a `UIImageView` loading from http(s) URLs (with memory and
+/// disk caching), local file paths, bundle asset names, and base64 data URIs.
+public final class PNImageManager: PNComponentManager {
+    public override func makeView(props: [String: Any]) -> UIView {
+        let view = UIImageView(frame: .zero)
+        view.clipsToBounds = true
+        view.contentMode = .scaleAspectFit
+        return view
+    }
+
+    public override func apply(view: UIView, props: [String: Any], initial: Bool) {
+        guard let imageView = view as? UIImageView else { return }
+        if let tint = PNColor.parse(PNProps.value(props, "tint_color") ?? PNProps.value(props, "tint")) {
+            imageView.tintColor = tint
+            if let image = imageView.image {
+                imageView.image = image.withRenderingMode(.alwaysTemplate)
+            }
+        }
+        if let placeholder = PNColor.parse(PNProps.value(props, "placeholder_color")) {
+            imageView.backgroundColor = placeholder
+        }
+        if let source = PNProps.string(PNProps.value(props, "source")), !source.isEmpty {
+            load(imageView, source: source)
+        }
+        if let mode = PNProps.string(PNProps.value(props, "scale_type") ?? PNProps.value(props, "resize_mode")) {
+            imageView.contentMode = PNImageManager.contentMode(mode)
+        }
+        PNViewStyler.applyCommon(imageView, props)
+    }
+
+    public override func measure(view: UIView, maxW: CGFloat, maxH: CGFloat) -> CGSize {
+        guard let image = (view as? UIImageView)?.image else { return .zero }
+        var size = image.size
+        if maxW.isFinite, maxW > 0, size.width > maxW {
+            let scale = maxW / size.width
+            size = CGSize(width: maxW, height: size.height * scale)
+        }
+        return size
+    }
+
+    static func contentMode(_ name: String) -> UIView.ContentMode {
+        switch name {
+        case "cover": return .scaleAspectFill
+        case "stretch": return .scaleToFill
+        case "center": return .center
+        case "repeat": return .scaleAspectFill
+        default: return .scaleAspectFit
+        }
+    }
+
+    // MARK: - Loading
+
+    private func load(_ imageView: UIImageView, source: String) {
+        guard let state = PNViewState.existing(for: imageView) else { return }
+        state.extras["pending_source"] = source
+        if source.hasPrefix("data:") {
+            loadDataURI(imageView, source)
+        } else if source.hasPrefix("http://") || source.hasPrefix("https://") {
+            PNImageLoader.shared.fetch(source) { [weak imageView] result in
+                guard let imageView = imageView, PNViewState.existing(for: imageView)?.extras["pending_source"] as? String == source else { return }
+                switch result {
+                case .success(let data):
+                    if let image = PNImageManager.decode(data, targetSize: imageView.bounds.size) {
+                        self.setImage(imageView, image)
+                        PNEvents.emit(imageView, "on_load", [["width": Double(image.size.width), "height": Double(image.size.height)]])
+                    } else {
+                        PNEvents.emit(imageView, "on_error", ["decode failed"])
+                    }
+                case .failure(let error):
+                    PNEvents.emit(imageView, "on_error", [error.localizedDescription])
+                }
+            }
+        } else {
+            var image = UIImage(named: source)
+            if image == nil {
+                let path = source.hasPrefix("file://") ? (URL(string: source)?.path ?? source) : source
+                image = UIImage(contentsOfFile: path)
+            }
+            if let image = image {
+                setImage(imageView, image)
+                PNEvents.emit(imageView, "on_load", [["width": Double(image.size.width), "height": Double(image.size.height)]])
+            } else {
+                PNEvents.emit(imageView, "on_error", ["image '\(source)' not found"])
+            }
+        }
+    }
+
+    private func setImage(_ imageView: UIImageView, _ image: UIImage) {
+        let tinted = PNProps.value(mergedProps(imageView), "tint_color") ?? PNProps.value(mergedProps(imageView), "tint")
+        imageView.image = tinted != nil ? image.withRenderingMode(.alwaysTemplate) : image
+    }
+
+    private func loadDataURI(_ imageView: UIImageView, _ source: String) {
+        guard let comma = source.firstIndex(of: ","),
+              let data = Data(base64Encoded: String(source[source.index(after: comma)...]), options: [.ignoreUnknownCharacters]),
+              let image = UIImage(data: data)
+        else {
+            PNEvents.emit(imageView, "on_error", ["data URI decode failed"])
+            return
+        }
+        setImage(imageView, image)
+        PNEvents.emit(imageView, "on_load", [["width": Double(image.size.width), "height": Double(image.size.height)]])
+    }
+
+    /// Decode `data`, downsampling when the bitmap is more than 2x the target.
+    static func decode(_ data: Data, targetSize: CGSize) -> UIImage? {
+        guard let image = UIImage(data: data) else { return nil }
+        guard targetSize.width > 0, targetSize.height > 0 else { return image }
+        let size = image.size
+        if size.width <= targetSize.width * 2, size.height <= targetSize.height * 2 { return image }
+        let scale = min(targetSize.width * 2 / size.width, targetSize.height * 2 / size.height)
+        let newSize = CGSize(width: size.width * scale, height: size.height * scale)
+        let renderer = UIGraphicsImageRenderer(size: newSize)
+        return renderer.image { _ in image.draw(in: CGRect(origin: .zero, size: newSize)) }
+    }
+}
+
+/// Shared image pipeline: memory LRU + disk cache under `Caches/pn_images`,
+/// request deduplication, delivery on the main queue.
+public final class PNImageLoader {
+    public static let shared = PNImageLoader()
+
+    public enum LoadError: Error, LocalizedError {
+        case badURL
+        case http(Int)
+        case empty
+
+        public var errorDescription: String? {
+            switch self {
+            case .badURL: return "invalid image URL"
+            case .http(let code): return "HTTP \(code)"
+            case .empty: return "empty response"
+            }
+        }
+    }
+
+    private let memory = NSCache<NSString, NSData>()
+    private var inflight: [String: [(Result<Data, Error>) -> Void]] = [:]
+    private let session: URLSession
+    private let queue = DispatchQueue(label: "com.pythonnative.images", qos: .utility)
+    private lazy var directory: URL = {
+        let caches = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first ?? URL(fileURLWithPath: NSTemporaryDirectory())
+        let dir = caches.appendingPathComponent("pn_images", isDirectory: true)
+        try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+        return dir
+    }()
+
+    private init() {
+        memory.totalCostLimit = 16 * 1024 * 1024
+        let config = URLSessionConfiguration.default
+        config.requestCachePolicy = .returnCacheDataElseLoad
+        session = URLSession(configuration: config)
+    }
+
+    /// Fetch `url`, delivering the raw bytes on the main queue.
+    public func fetch(_ url: String, completion: @escaping (Result<Data, Error>) -> Void) {
+        if let cached = memory.object(forKey: url as NSString) {
+            completion(.success(cached as Data))
+            return
+        }
+        if inflight[url] != nil {
+            inflight[url]?.append(completion)
+            return
+        }
+        inflight[url] = [completion]
+        let path = cachePath(for: url)
+        queue.async {
+            if let data = try? Data(contentsOf: path), !data.isEmpty {
+                self.deliver(url, .success(data))
+                return
+            }
+            guard let remote = URL(string: url) else {
+                self.deliver(url, .failure(LoadError.badURL))
+                return
+            }
+            let task = self.session.dataTask(with: remote) { data, response, error in
+                if let error = error {
+                    self.deliver(url, .failure(error))
+                    return
+                }
+                if let http = response as? HTTPURLResponse, !(200..<300).contains(http.statusCode) {
+                    self.deliver(url, .failure(LoadError.http(http.statusCode)))
+                    return
+                }
+                guard let data = data, !data.isEmpty else {
+                    self.deliver(url, .failure(LoadError.empty))
+                    return
+                }
+                try? data.write(to: path, options: [.atomic])
+                self.deliver(url, .success(data))
+            }
+            task.resume()
+        }
+    }
+
+    /// Remove every cached image (memory and disk).
+    public func clear() {
+        memory.removeAllObjects()
+        try? FileManager.default.removeItem(at: directory)
+        try? FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+    }
+
+    private func deliver(_ url: String, _ result: Result<Data, Error>) {
+        DispatchQueue.main.async {
+            if case .success(let data) = result {
+                self.memory.setObject(data as NSData, forKey: url as NSString, cost: data.count)
+            }
+            let waiters = self.inflight.removeValue(forKey: url) ?? []
+            for waiter in waiters { waiter(result) }
+        }
+    }
+
+    private func cachePath(for url: String) -> URL {
+        let digest = SHA256.hash(data: Data(url.utf8)).map { String(format: "%02x", $0) }.joined()
+        let ext = URL(string: url)?.pathExtension ?? ""
+        return directory.appendingPathComponent(ext.isEmpty ? digest : "\(digest).\(ext)")
+    }
+}

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

@@ -0,0 +1,243 @@
+import UIKit
+
+/// `Modal`: a hidden on-tree placeholder whose children mount into a
+/// presented `UIViewController` while `visible` is true.
+public final class PNModalManager: PNComponentManager {
+    final class Presentation {
+        let controller: UIViewController
+        let content: UIView
+        init(controller: UIViewController, content: UIView) {
+            self.controller = controller
+            self.content = content
+        }
+    }
+
+    public override func makeView(props: [String: Any]) -> UIView {
+        let placeholder = UIView(frame: .zero)
+        placeholder.isHidden = true
+        return placeholder
+    }
+
+    public override func apply(view: UIView, props: [String: Any], initial: Bool) {
+        guard let state = PNViewState.existing(for: view) else { return }
+        let visible = PNProps.bool(PNProps.value(state.props, "visible")) ?? false
+        let presented = state.extras["modal"] is Presentation
+        if visible, !presented {
+            present(view, state)
+        } else if !visible, presented {
+            dismiss(view, state, emit: true)
+        }
+    }
+
+    public override func teardown(view: UIView) {
+        if let state = PNViewState.existing(for: view), state.extras["modal"] is Presentation {
+            dismiss(view, state, emit: false)
+        }
+    }
+
+    public override func childContainer(for view: UIView) -> UIView {
+        guard let state = PNViewState.existing(for: view), let modal = state.extras["modal"] as? Presentation else {
+            return view
+        }
+        return modal.content
+    }
+
+    public override func insertChild(parent: UIView, child: UIView, index: Int) {
+        if let state = PNViewState.existing(for: parent), !(state.extras["modal"] is Presentation) {
+            var pending = (state.extras["pending_children"] as? [UIView]) ?? []
+            pending.removeAll { $0 === child }
+            pending.insert(child, at: max(0, min(index, pending.count)))
+            state.extras["pending_children"] = pending
+            return
+        }
+        super.insertChild(parent: parent, child: child, index: index)
+    }
+
+    public override func removeChild(parent: UIView, child: UIView) {
+        super.removeChild(parent: parent, child: child)
+        if let state = PNViewState.existing(for: parent), var pending = state.extras["pending_children"] as? [UIView] {
+            pending.removeAll { $0 === child }
+            state.extras["pending_children"] = pending
+        }
+    }
+
+    public override func setFrame(view: UIView, x: Double, y: Double, w: Double, h: Double) {}
+
+    public override func measure(view: UIView, maxW: CGFloat, maxH: CGFloat) -> CGSize { .zero }
+
+    private func present(_ placeholder: UIView, _ state: PNViewState) {
+        let props = state.props
+        let controller = PNModalViewController()
+        controller.onDismissed = { [weak placeholder] in
+            guard let placeholder = placeholder, let state = PNViewState.existing(for: placeholder),
+                  state.extras["modal"] is Presentation
+            else { return }
+            state.extras.removeValue(forKey: "modal")
+            PNEvents.emit(placeholder, "on_dismiss")
+            PNEvents.emitIfWired(placeholder, "on_request_close")
+        }
+        let style = PNProps.string(PNProps.value(props, "presentation_style")) ?? "page_sheet"
+        let isOverlay = style == "overlay" || PNProps.bool(PNProps.value(props, "transparent")) == true
+        let content = UIView(frame: controller.view.bounds)
+        content.backgroundColor = isOverlay ? .clear : PNColor.parse(PNProps.value(props, "background_color")) ?? .systemBackground
+        content.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        controller.view.addSubview(content)
+        controller.view.backgroundColor = isOverlay ? UIColor.black.withAlphaComponent(0.4) : content.backgroundColor
+        switch isOverlay ? "overlay" : style {
+        case "full_screen": controller.modalPresentationStyle = .fullScreen
+        case "form_sheet": controller.modalPresentationStyle = .formSheet
+        case "overlay": controller.modalPresentationStyle = .overCurrentContext
+        default: controller.modalPresentationStyle = .pageSheet
+        }
+        switch PNProps.string(PNProps.value(props, "animation_type")) ?? PNProps.string(PNProps.value(props, "animation")) {
+        case "fade": controller.modalTransitionStyle = .crossDissolve
+        case "flip": controller.modalTransitionStyle = .flipHorizontal
+        default: controller.modalTransitionStyle = .coverVertical
+        }
+        if !isOverlay, PNProps.bool(PNProps.value(props, "dismiss_on_backdrop")) == false {
+            controller.isModalInPresentation = true
+        }
+        let presentation = Presentation(controller: controller, content: content)
+        state.extras["modal"] = presentation
+        for child in (state.extras.removeValue(forKey: "pending_children") as? [UIView]) ?? [] {
+            child.translatesAutoresizingMaskIntoConstraints = true
+            content.addSubview(child)
+        }
+        let animated = PNProps.string(PNProps.value(props, "animation_type")) != "none"
+        guard let top = PNWindow.topViewController() else {
+            state.extras.removeValue(forKey: "modal")
+            return
+        }
+        top.present(controller, animated: animated) { [weak placeholder] in
+            if let placeholder = placeholder { PNEvents.emit(placeholder, "on_show") }
+        }
+    }
+
+    private func dismiss(_ placeholder: UIView, _ state: PNViewState, emit: Bool) {
+        guard let modal = state.extras.removeValue(forKey: "modal") as? Presentation else { return }
+        (modal.controller as? PNModalViewController)?.onDismissed = nil
+        let animated = PNProps.string(PNProps.value(state.props, "animation_type")) != "none"
+        modal.controller.dismiss(animated: animated)
+        if emit { PNEvents.emit(placeholder, "on_dismiss") }
+    }
+}
+
+/// Reports interactive dismissal (sheet swipe) back to the manager.
+final class PNModalViewController: UIViewController {
+    var onDismissed: (() -> Void)?
+
+    override func viewDidDisappear(_ animated: Bool) {
+        super.viewDidDisappear(animated)
+        if isBeingDismissed || presentingViewController == nil {
+            onDismissed?()
+        }
+    }
+}
+
+/// Overlay view that only claims touches landing on one of its subviews.
+final class PNPortalView: UIView {
+    override func point(inside point: CGPoint, with event: UIEvent?) -> Bool {
+        for sub in subviews where !sub.isHidden && sub.alpha > 0.01 && sub.isUserInteractionEnabled {
+            if sub.frame.contains(point) { return true }
+        }
+        return false
+    }
+}
+
+/// `Portal`: floats children over the screen in a top-level overlay that
+/// mirrors the screen host's root frame.
+public final class PNPortalManager: PNComponentManager {
+    public override func makeView(props: [String: Any]) -> UIView {
+        let overlay = PNPortalView(frame: .zero)
+        overlay.backgroundColor = .clear
+        return overlay
+    }
+
+    public override func apply(view: UIView, props: [String: Any], initial: Bool) {
+        PNViewStyler.applyCommon(view, props)
+        if !initial { ensureAttached(view) }
+    }
+
+    public override func insertChild(parent: UIView, child: UIView, index: Int) {
+        ensureAttached(parent)
+        super.insertChild(parent: parent, child: child, index: index)
+    }
+
+    public override func setFrame(view: UIView, x: Double, y: Double, w: Double, h: Double) {}
+
+    public override func measure(view: UIView, maxW: CGFloat, maxH: CGFloat) -> CGSize { .zero }
+
+    private func ensureAttached(_ overlay: UIView) {
+        guard let host = PNWindow.topViewController()?.view else { return }
+        if overlay.superview === host {
+            if host.subviews.last !== overlay {
+                host.bringSubviewToFront(overlay)
+            }
+            syncFrame(overlay, host: host)
+            return
+        }
+        overlay.removeFromSuperview()
+        host.addSubview(overlay)
+        syncFrame(overlay, host: host)
+    }
+
+    static func rootFrame(in host: UIView) -> CGRect {
+        let bounds = host.bounds
+        let insets = host.safeAreaInsets
+        let w = max(0, bounds.width - insets.left - insets.right)
+        let h = max(0, bounds.height - insets.top)
+        return CGRect(x: insets.left, y: insets.top, width: w, height: h)
+    }
+
+    private func syncFrame(_ overlay: UIView, host: UIView) {
+        overlay.frame = PNPortalManager.rootFrame(in: host)
+        overlay.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+    }
+}
+
+/// Process-wide status bar state consulted by `PNViewController`.
+public enum PNStatusBarState {
+    public static var hidden = false
+    public static var style: UIStatusBarStyle = .default
+    public static var animation: UIStatusBarAnimation = .fade
+
+    static func refresh() {
+        var controller = PNWindow.keyWindow()?.rootViewController
+        if let nav = controller as? UINavigationController { controller = nav.topViewController }
+        controller?.setNeedsStatusBarAppearanceUpdate()
+    }
+}
+
+/// `StatusBar`: a global side effect (hidden / style), no on-screen view.
+public final class PNStatusBarManager: PNComponentManager {
+    public override func makeView(props: [String: Any]) -> UIView {
+        let placeholder = UIView(frame: .zero)
+        placeholder.isHidden = true
+        return placeholder
+    }
+
+    public override func apply(view: UIView, props: [String: Any], initial: Bool) {
+        if let hidden = PNProps.bool(PNProps.value(props, "hidden")) {
+            PNStatusBarState.hidden = hidden
+        }
+        if let style = PNProps.string(PNProps.value(props, "bar_style")) {
+            switch style {
+            case "light", "light_content": PNStatusBarState.style = .lightContent
+            case "dark", "dark_content": PNStatusBarState.style = .darkContent
+            default: PNStatusBarState.style = .default
+            }
+        }
+        if let animation = PNProps.string(PNProps.value(props, "animation")) {
+            switch animation {
+            case "slide": PNStatusBarState.animation = .slide
+            case "none": PNStatusBarState.animation = .none
+            default: PNStatusBarState.animation = .fade
+            }
+        }
+        PNStatusBarState.refresh()
+    }
+
+    public override func setFrame(view: UIView, x: Double, y: Double, w: Double, h: Double) {}
+
+    public override func measure(view: UIView, maxW: CGFloat, maxH: CGFloat) -> CGSize { .zero }
+}

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

@@ -0,0 +1,114 @@
+import UIKit
+
+/// `Pressable`: a touchable container with press feedback.
+///
+/// A zero-duration long-press recognizer tracks the raw touch for
+/// `on_press_in` / `on_press_out` and the pressed-opacity feedback; a tap
+/// recognizer fires `on_press` and a standard long press fires
+/// `on_long_press`. Hit slop and pointer events come from
+/// `PNContainerView`, so hit testing is entirely UIKit's.
+public final class PNPressableManager: PNComponentManager {
+    public override func makeView(props: [String: Any]) -> UIView {
+        let view = PNContainerView(frame: .zero)
+        view.isUserInteractionEnabled = true
+        return view
+    }
+
+    public override func createView(tag: Int64, props: [String: Any]) -> UIView {
+        let view = super.createView(tag: tag, props: props)
+        let handler = PNPressHandler(view: view)
+        PNViewState.existing(for: view)?.retained.append(handler)
+        handler.install()
+        return view
+    }
+
+    public override func apply(view: UIView, props: [String: Any], initial: Bool) {
+        PNViewStyler.applyCommon(view, props)
+        if PNProps.has(props, "enabled") {
+            view.isUserInteractionEnabled = PNProps.bool(PNProps.value(props, "enabled")) ?? true
+        }
+        if PNProps.has(props, "disabled") {
+            view.isUserInteractionEnabled = !(PNProps.bool(PNProps.value(props, "disabled")) ?? false)
+        }
+        if let delay = PNProps.double(PNProps.value(props, "delay_long_press")),
+           let handler = PNViewState.existing(for: view)?.retained.compactMap({ $0 as? PNPressHandler }).first
+        {
+            handler.longPress.minimumPressDuration = max(0.05, delay / 1000)
+        }
+    }
+}
+
+/// Owns the three press recognizers of one Pressable.
+final class PNPressHandler: NSObject, UIGestureRecognizerDelegate {
+    private weak var view: UIView?
+    let tap = UITapGestureRecognizer()
+    let longPress = UILongPressGestureRecognizer()
+    let touch = UILongPressGestureRecognizer()
+
+    init(view: UIView) {
+        self.view = view
+        super.init()
+    }
+
+    func install() {
+        guard let view = view else { return }
+        touch.minimumPressDuration = 0
+        tap.addTarget(self, action: #selector(onTap(_:)))
+        longPress.addTarget(self, action: #selector(onLongPress(_:)))
+        touch.addTarget(self, action: #selector(onTouch(_:)))
+        for recognizer in [tap, longPress, touch] {
+            recognizer.cancelsTouchesInView = false
+            recognizer.delegate = self
+            view.addGestureRecognizer(recognizer)
+        }
+    }
+
+    private var merged: [String: Any] {
+        view.flatMap { PNViewState.existing(for: $0)?.props } ?? [:]
+    }
+
+    @objc private func onTap(_ recognizer: UITapGestureRecognizer) {
+        guard let view = view, recognizer.state == .ended else { return }
+        PNEvents.emit(view, "on_press")
+    }
+
+    @objc private func onLongPress(_ recognizer: UILongPressGestureRecognizer) {
+        guard let view = view, recognizer.state == .began else { return }
+        PNEvents.emit(view, "on_long_press")
+    }
+
+    @objc private func onTouch(_ recognizer: UILongPressGestureRecognizer) {
+        guard let view = view else { return }
+        switch recognizer.state {
+        case .began:
+            feedback(pressed: true)
+            PNEvents.emit(view, "on_press_in")
+        case .ended, .cancelled, .failed:
+            feedback(pressed: false)
+            PNEvents.emit(view, "on_press_out")
+        default:
+            break
+        }
+    }
+
+    private func feedback(pressed: Bool) {
+        guard let view = view else { return }
+        let props = merged
+        let target: CGFloat
+        let duration: TimeInterval
+        if pressed {
+            target = CGFloat(PNProps.double(PNProps.value(props, "pressed_opacity")) ?? 0.6)
+            duration = 0.05
+        } else {
+            target = CGFloat(PNProps.double(PNProps.value(props, "opacity")) ?? 1)
+            duration = 0.1
+        }
+        UIView.animate(withDuration: duration) { view.alpha = target }
+    }
+
+    // Press recognizers recognize alongside everything, including the
+    // declarative `gestures` recognizers and a parent scroll view's pan.
+    func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldRecognizeSimultaneouslyWith other: UIGestureRecognizer) -> Bool {
+        true
+    }
+}