pythonnative 0.40.0__cp313-cp313-win_amd64.whl

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

@@ -0,0 +1,281 @@
+import UIKit
+
+/// `Switch`: `UISwitch` emitting `on_change(bool)`.
+public final class PNSwitchManager: PNComponentManager {
+    public override func makeView(props: [String: Any]) -> UIView {
+        UISwitch(frame: .zero)
+    }
+
+    public override func createView(tag: Int64, props: [String: Any]) -> UIView {
+        let view = super.createView(tag: tag, props: props)
+        if let control = view as? UISwitch {
+            PNActionTarget.attach(control, events: .valueChanged) { [weak control] in
+                guard let control = control, PNViewState.existing(for: control)?.flag("suppress") != true else { return }
+                PNEvents.emit(control, "on_change", [control.isOn])
+            }
+        }
+        return view
+    }
+
+    public override func apply(view: UIView, props: [String: Any], initial: Bool) {
+        guard let control = view as? UISwitch, let state = PNViewState.existing(for: control) else { return }
+        if PNProps.has(props, "value") {
+            let value = PNProps.bool(PNProps.value(props, "value")) ?? false
+            if control.isOn != value {
+                state.extras["suppress"] = true
+                control.setOn(value, animated: !initial)
+                state.extras["suppress"] = false
+            }
+        }
+        if let color = PNColor.parse(PNProps.value(props, "on_tint_color") ?? PNProps.value(props, "tint_color")) {
+            control.onTintColor = color
+        }
+        if let color = PNColor.parse(PNProps.value(props, "thumb_color")) {
+            control.thumbTintColor = color
+        }
+        if PNProps.has(props, "disabled") {
+            control.isEnabled = !(PNProps.bool(PNProps.value(props, "disabled")) ?? false)
+        }
+        PNViewStyler.applyAccessibility(control, props)
+    }
+
+    public override func measure(view: UIView, maxW: CGFloat, maxH: CGFloat) -> CGSize {
+        CGSize(width: 51, height: 31)
+    }
+
+    /// `UISwitch` ignores the size part of `frame`, but the base class sets
+    /// `bounds` directly, which would stretch its hit area (and accessibility
+    /// frame) across a stretched flex cross axis. Pin the box to the natural
+    /// size at the layout origin so taps land on the visible control.
+    public override func setFrame(view: UIView, x: Double, y: Double, w: Double, h: Double) {
+        let natural = view.intrinsicContentSize
+        let pw = natural.width > 0 ? min(w, Double(natural.width)) : w
+        let ph = natural.height > 0 ? min(h, Double(natural.height)) : h
+        super.setFrame(view: view, x: x, y: y, w: pw, h: ph)
+    }
+}
+
+/// `Slider`: `UISlider` emitting `on_change(float)`.
+public final class PNSliderManager: PNComponentManager {
+    public override func makeView(props: [String: Any]) -> UIView {
+        UISlider(frame: .zero)
+    }
+
+    public override func createView(tag: Int64, props: [String: Any]) -> UIView {
+        let view = super.createView(tag: tag, props: props)
+        if let slider = view as? UISlider {
+            PNActionTarget.attach(slider, events: .valueChanged) { [weak slider] in
+                guard let slider = slider, PNViewState.existing(for: slider)?.flag("suppress") != true else { return }
+                PNEvents.emit(slider, "on_change", [Double(slider.value)])
+            }
+            PNActionTarget.attach(slider, events: [.touchUpInside, .touchUpOutside, .touchCancel]) { [weak slider] in
+                guard let slider = slider else { return }
+                PNEvents.emitIfWired(slider, "on_sliding_complete", [Double(slider.value)])
+            }
+        }
+        return view
+    }
+
+    public override func apply(view: UIView, props: [String: Any], initial: Bool) {
+        guard let slider = view as? UISlider, let state = PNViewState.existing(for: slider) else { return }
+        if let min = PNProps.double(PNProps.value(props, "min_value")) { slider.minimumValue = Float(min) }
+        if let max = PNProps.double(PNProps.value(props, "max_value")) { slider.maximumValue = Float(max) }
+        if let value = PNProps.double(PNProps.value(props, "value")), abs(Double(slider.value) - value) > 1e-9 {
+            state.extras["suppress"] = true
+            slider.setValue(Float(value), animated: !initial)
+            state.extras["suppress"] = false
+        }
+        if let color = PNColor.parse(PNProps.value(props, "minimum_track_color") ?? PNProps.value(props, "tint_color")) {
+            slider.minimumTrackTintColor = color
+        }
+        if let color = PNColor.parse(PNProps.value(props, "maximum_track_color")) { slider.maximumTrackTintColor = color }
+        if let color = PNColor.parse(PNProps.value(props, "thumb_color")) { slider.thumbTintColor = color }
+        if PNProps.has(props, "disabled") { slider.isEnabled = !(PNProps.bool(PNProps.value(props, "disabled")) ?? false) }
+        PNViewStyler.applyAccessibility(slider, props)
+    }
+
+    public override func measure(view: UIView, maxW: CGFloat, maxH: CGFloat) -> CGSize {
+        let w = maxW.isFinite && maxW < 1e6 ? maxW : 200
+        return CGSize(width: max(w, 100), height: 34)
+    }
+}
+
+/// `ActivityIndicator`: `UIActivityIndicatorView`.
+public final class PNActivityIndicatorManager: PNComponentManager {
+    public override func makeView(props: [String: Any]) -> UIView {
+        let style: UIActivityIndicatorView.Style = PNProps.string(PNProps.value(props, "size")) == "large" ? .large : .medium
+        let view = UIActivityIndicatorView(style: style)
+        view.hidesWhenStopped = true
+        return view
+    }
+
+    public override func apply(view: UIView, props: [String: Any], initial: Bool) {
+        guard let indicator = view as? UIActivityIndicatorView else { return }
+        if !initial, let size = PNProps.string(PNProps.value(props, "size")) {
+            indicator.style = size == "large" ? .large : .medium
+        }
+        if let color = PNColor.parse(PNProps.value(props, "color")) { indicator.color = color }
+        if PNProps.has(props, "animating") || initial {
+            let animating = PNProps.bool(PNProps.value(props, "animating")) ?? true
+            if animating { indicator.startAnimating() } else { indicator.stopAnimating() }
+        }
+        if PNProps.has(props, "hides_when_stopped") {
+            indicator.hidesWhenStopped = PNProps.bool(PNProps.value(props, "hides_when_stopped")) ?? true
+        }
+        PNViewStyler.applyAccessibility(indicator, props)
+    }
+
+    public override func measure(view: UIView, maxW: CGFloat, maxH: CGFloat) -> CGSize {
+        let size = view.intrinsicContentSize
+        return size.width > 0 ? size : CGSize(width: 20, height: 20)
+    }
+}
+
+/// `ProgressBar`: a determinate `UIProgressView`, or a spinning
+/// `UIActivityIndicatorView` when `indeterminate` is set at creation.
+public final class PNProgressBarManager: PNComponentManager {
+    public override func makeView(props: [String: Any]) -> UIView {
+        if PNProps.bool(PNProps.value(props, "indeterminate")) == true {
+            let spinner = UIActivityIndicatorView(style: .medium)
+            spinner.startAnimating()
+            return spinner
+        }
+        return UIProgressView(progressViewStyle: .default)
+    }
+
+    public override func apply(view: UIView, props: [String: Any], initial: Bool) {
+        if let spinner = view as? UIActivityIndicatorView {
+            if let color = PNColor.parse(PNProps.value(props, "color")) { spinner.color = color }
+            spinner.startAnimating()
+        } else if let bar = view as? UIProgressView {
+            if let value = PNProps.double(PNProps.value(props, "value") ?? PNProps.value(props, "progress")) {
+                bar.setProgress(Float(max(0, min(1, value))), animated: !initial)
+            }
+            if let color = PNColor.parse(PNProps.value(props, "color")) { bar.progressTintColor = color }
+            if let color = PNColor.parse(PNProps.value(props, "track_color")) { bar.trackTintColor = color }
+        }
+        PNViewStyler.applyAccessibility(view, props)
+    }
+
+    public override func measure(view: UIView, maxW: CGFloat, maxH: CGFloat) -> CGSize {
+        if view is UIActivityIndicatorView { return CGSize(width: 20, height: 20) }
+        let w = maxW.isFinite && maxW < 1e6 ? maxW : 200
+        return CGSize(width: max(w, 40), height: 4)
+    }
+}
+
+/// `SegmentedControl`: `UISegmentedControl` emitting `on_change(index)`.
+public final class PNSegmentedControlManager: PNComponentManager {
+    public override func makeView(props: [String: Any]) -> UIView {
+        let segments = ((PNProps.value(props, "segments") as? [Any]) ?? []).map { PNProps.string($0) ?? "" }
+        return UISegmentedControl(items: segments)
+    }
+
+    public override func createView(tag: Int64, props: [String: Any]) -> UIView {
+        let view = super.createView(tag: tag, props: props)
+        if let control = view as? UISegmentedControl {
+            PNActionTarget.attach(control, events: .valueChanged) { [weak control] in
+                guard let control = control, PNViewState.existing(for: control)?.flag("suppress") != true else { return }
+                PNEvents.emit(control, "on_change", [control.selectedSegmentIndex])
+            }
+        }
+        return view
+    }
+
+    public override func apply(view: UIView, props: [String: Any], initial: Bool) {
+        guard let control = view as? UISegmentedControl, let state = PNViewState.existing(for: control) else { return }
+        let merged = state.props
+        var rebuilt = false
+        if let segments = PNProps.value(props, "segments") as? [Any] {
+            let titles = segments.map { PNProps.string($0) ?? "" }
+            if !initial, titles != (state.extras["segments"] as? [String]) {
+                state.extras["suppress"] = true
+                control.removeAllSegments()
+                for (i, title) in titles.enumerated() {
+                    control.insertSegment(withTitle: title, at: i, animated: false)
+                }
+                state.extras["suppress"] = false
+                rebuilt = true
+            }
+            state.extras["segments"] = titles
+        }
+        if rebuilt || initial || PNProps.value(props, "selected_index") != nil {
+            state.extras["suppress"] = true
+            control.selectedSegmentIndex = PNProps.int(PNProps.value(merged, "selected_index")) ?? 0
+            state.extras["suppress"] = false
+        }
+        if let color = PNColor.parse(PNProps.value(props, "tint_color")) {
+            control.selectedSegmentTintColor = color
+            control.tintColor = color
+        }
+        if PNProps.has(props, "disabled") {
+            control.isEnabled = !(PNProps.bool(PNProps.value(props, "disabled")) ?? false)
+        }
+        PNViewStyler.applyAccessibility(control, props)
+    }
+}
+
+/// `DatePicker`: compact `UIDatePicker` emitting ISO-style strings.
+public final class PNDatePickerManager: PNComponentManager {
+    static let formats = ["date": "yyyy-MM-dd", "time": "HH:mm", "datetime": "yyyy-MM-dd'T'HH:mm"]
+    static var formatters: [String: DateFormatter] = [:]
+
+    static func formatter(mode: String) -> DateFormatter {
+        let format = formats[mode] ?? formats["date"]!
+        if let cached = formatters[format] { return cached }
+        let formatter = DateFormatter()
+        formatter.dateFormat = format
+        formatter.locale = Locale(identifier: "en_US_POSIX")
+        formatters[format] = formatter
+        return formatter
+    }
+
+    public override func makeView(props: [String: Any]) -> UIView {
+        let picker = UIDatePicker(frame: .zero)
+        picker.pnApplyCompactStyle()
+        return picker
+    }
+
+    public override func createView(tag: Int64, props: [String: Any]) -> UIView {
+        let view = super.createView(tag: tag, props: props)
+        if let picker = view as? UIDatePicker {
+            PNActionTarget.attach(picker, events: .valueChanged) { [weak picker] in
+                guard let picker = picker, let state = PNViewState.existing(for: picker), !state.flag("suppress") else { return }
+                let mode = PNProps.string(PNProps.value(state.props, "mode")) ?? "date"
+                PNEvents.emit(picker, "on_change", [PNDatePickerManager.formatter(mode: mode).string(from: picker.date)])
+            }
+        }
+        return view
+    }
+
+    public override func apply(view: UIView, props: [String: Any], initial: Bool) {
+        guard let picker = view as? UIDatePicker, let state = PNViewState.existing(for: picker) else { return }
+        let mode = PNProps.string(PNProps.value(state.props, "mode")) ?? "date"
+        if PNProps.value(props, "mode") != nil {
+            switch mode {
+            case "time": picker.datePickerMode = .time
+            case "datetime": picker.datePickerMode = .dateAndTime
+            default: picker.datePickerMode = .date
+            }
+        }
+        let formatter = PNDatePickerManager.formatter(mode: mode)
+        if PNProps.has(props, "minimum") {
+            picker.minimumDate = PNProps.string(PNProps.value(props, "minimum")).flatMap { formatter.date(from: $0) }
+        }
+        if PNProps.has(props, "maximum") {
+            picker.maximumDate = PNProps.string(PNProps.value(props, "maximum")).flatMap { formatter.date(from: $0) }
+        }
+        if let value = PNProps.string(PNProps.value(props, "value")), !value.isEmpty, let date = formatter.date(from: value) {
+            state.extras["suppress"] = true
+            picker.setDate(date, animated: false)
+            state.extras["suppress"] = false
+        }
+        if PNProps.has(props, "disabled") {
+            picker.isEnabled = !(PNProps.bool(PNProps.value(props, "disabled")) ?? false)
+        }
+        if let color = PNColor.parse(PNProps.value(props, "tint_color")) {
+            picker.tintColor = color
+        }
+        PNViewStyler.applyAccessibility(picker, props)
+    }
+}

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

@@ -0,0 +1,222 @@
+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
+        if let state = PNViewState.existing(for: imageView) { PNLayout.invalidate(state.tag) }
+    }
+
+    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)")
+    }
+}