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

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

@@ -0,0 +1,230 @@
+import UIKit
+
+/// `Text`: a `UILabel` with rich spans, text transforms, shadows, and the
+/// full font prop set.
+public final class PNTextManager: PNComponentManager {
+    static let textShadowKeys = ["text_shadow_color", "text_shadow_offset", "text_shadow_radius"]
+    static let attributedKeys = ["letter_spacing", "line_height", "text_decoration"] + textShadowKeys
+    static let fontKeys = ["font_size", "font_weight", "font_family", "italic", "bold", "font_style"]
+    static let spanRebuildKeys = ["spans", "text", "text_transform", "color"] + fontKeys + attributedKeys
+
+    public override func makeView(props: [String: Any]) -> UIView {
+        let label = UILabel(frame: .zero)
+        label.numberOfLines = 0
+        label.translatesAutoresizingMaskIntoConstraints = true
+        return label
+    }
+
+    public override func apply(view: UIView, props: [String: Any], initial: Bool) {
+        guard let label = view as? UILabel else { return }
+        let merged = mergedProps(label)
+        let hasSpans = !((PNProps.value(merged, "spans") as? [Any]) ?? []).isEmpty
+        let textChanged = PNProps.has(props, "text") || PNProps.has(props, "text_transform")
+        if textChanged, !hasSpans {
+            label.text = PNTextManager.transform(PNProps.string(PNProps.value(merged, "text")), mode: PNProps.string(PNProps.value(merged, "text_transform")))
+        }
+        if PNTextManager.fontKeys.contains(where: { PNProps.has(props, $0) }) {
+            label.font = PNTextManager.font(from: merged, base: label.font)
+        }
+        if let color = PNColor.parse(PNProps.value(props, "color")) {
+            label.textColor = color
+        }
+        if let color = PNColor.parse(PNProps.value(props, "background_color")) {
+            label.backgroundColor = color
+        }
+        if PNProps.has(props, "max_lines") || PNProps.has(props, "number_of_lines") {
+            let lines = PNProps.int(PNProps.value(props, "max_lines")) ?? PNProps.int(PNProps.value(props, "number_of_lines")) ?? 0
+            label.numberOfLines = max(0, lines)
+        }
+        if PNProps.has(props, "text_align") {
+            label.textAlignment = PNTextManager.alignment(PNProps.string(PNProps.value(props, "text_align")))
+        }
+        if PNProps.has(props, "selectable") {
+            label.isUserInteractionEnabled = PNProps.bool(PNProps.value(props, "selectable")) ?? false
+        }
+        if hasSpans {
+            if PNTextManager.spanRebuildKeys.contains(where: { PNProps.has(props, $0) }) {
+                applySpans(label, merged)
+            }
+        } else if PNProps.has(props, "spans") {
+            label.text = PNTextManager.transform(PNProps.string(PNProps.value(merged, "text")), mode: PNProps.string(PNProps.value(merged, "text_transform")))
+        } else if PNTextManager.attributedKeys.contains(where: { PNProps.has(props, $0) })
+            || (textChanged && PNTextManager.attributedKeys.contains { PNProps.value(merged, $0) != nil })
+        {
+            applyAttributed(label, merged)
+        }
+        PNViewStyler.applyDecoration(label, props)
+    }
+
+    // MARK: - Fonts
+
+    /// Resolve a `UIFont` from the element's font props.
+    static func font(from props: [String: Any], base: UIFont?) -> UIFont {
+        let currentSize = base?.pointSize ?? 17
+        let size = CGFloat(PNProps.double(PNProps.value(props, "font_size")) ?? Double(currentSize))
+        var weight: Any? = PNProps.value(props, "font_weight")
+        if weight == nil, PNProps.bool(PNProps.value(props, "bold")) == true { weight = "bold" }
+        let italic = PNProps.bool(PNProps.value(props, "italic")) == true
+            || PNProps.string(PNProps.value(props, "font_style")) == "italic"
+        return font(size: size, weight: weight, family: PNProps.string(PNProps.value(props, "font_family")), italic: italic)
+    }
+
+    static func font(size: CGFloat, weight: Any?, family: String?, italic: Bool) -> UIFont {
+        if let family = family, !family.isEmpty, let named = UIFont(name: family, size: size) {
+            return italic ? italicized(named, size: size) : named
+        }
+        let font = UIFont.systemFont(ofSize: size, weight: fontWeight(weight))
+        return italic ? italicized(font, size: size) : font
+    }
+
+    static func italicized(_ font: UIFont, size: CGFloat) -> UIFont {
+        var traits = font.fontDescriptor.symbolicTraits
+        traits.insert(.traitItalic)
+        guard let descriptor = font.fontDescriptor.withSymbolicTraits(traits) else { return font }
+        return UIFont(descriptor: descriptor, size: size)
+    }
+
+    static func fontWeight(_ value: Any?) -> UIFont.Weight {
+        if let name = value as? String {
+            switch name.lowercased() {
+            case "ultralight": return .ultraLight
+            case "thin": return .thin
+            case "light": return .light
+            case "medium": return .medium
+            case "semibold": return .semibold
+            case "bold": return .bold
+            case "heavy": return .heavy
+            case "black": return .black
+            default:
+                if let numeric = Double(name) { return fontWeight(numeric) }
+                return .regular
+            }
+        }
+        guard let numeric = PNProps.double(value) else { return .regular }
+        let n = max(100, min(900, numeric))
+        switch n {
+        case ...100: return .ultraLight
+        case ...200: return .thin
+        case ...300: return .light
+        case ...400: return .regular
+        case ...500: return .medium
+        case ...600: return .semibold
+        case ...700: return .bold
+        case ...800: return .heavy
+        default: return .black
+        }
+    }
+
+    static func alignment(_ value: String?) -> NSTextAlignment {
+        switch value {
+        case "center": return .center
+        case "right": return .right
+        case "justify": return .justified
+        case "natural": return .natural
+        default: return .left
+        }
+    }
+
+    // MARK: - Transforms
+
+    /// Apply a `text_transform` mode (`uppercase`, `lowercase`, `capitalize`).
+    public static func transform(_ text: String?, mode: String?) -> String {
+        let s = text ?? ""
+        switch mode {
+        case "uppercase": return s.uppercased()
+        case "lowercase": return s.lowercased()
+        case "capitalize":
+            var out = ""
+            var atWordStart = true
+            for ch in s {
+                if ch.isWhitespace {
+                    atWordStart = true
+                    out.append(ch)
+                } else if atWordStart {
+                    out.append(contentsOf: String(ch).uppercased())
+                    atWordStart = false
+                } else {
+                    out.append(ch)
+                }
+            }
+            return out
+        default: return s
+        }
+    }
+
+    // MARK: - Attributed rendering
+
+    static func baseAttributes(_ props: [String: Any], font: UIFont?) -> [NSAttributedString.Key: Any] {
+        var attrs: [NSAttributedString.Key: Any] = [:]
+        if let font = font { attrs[.font] = font }
+        if let kern = PNProps.double(PNProps.value(props, "letter_spacing")) { attrs[.kern] = kern }
+        if let lineHeight = PNProps.double(PNProps.value(props, "line_height")) {
+            let style = NSMutableParagraphStyle()
+            style.minimumLineHeight = CGFloat(lineHeight)
+            style.maximumLineHeight = CGFloat(lineHeight)
+            attrs[.paragraphStyle] = style
+        }
+        switch PNProps.string(PNProps.value(props, "text_decoration")) {
+        case "underline": attrs[.underlineStyle] = NSUnderlineStyle.single.rawValue
+        case "line_through": attrs[.strikethroughStyle] = NSUnderlineStyle.single.rawValue
+        default: break
+        }
+        if let shadow = textShadow(props) { attrs[.shadow] = shadow }
+        return attrs
+    }
+
+    static func textShadow(_ props: [String: Any]) -> NSShadow? {
+        guard textShadowKeys.contains(where: { PNProps.value(props, $0) != nil }) else { return nil }
+        let shadow = NSShadow()
+        shadow.shadowColor = PNColor.parse(PNProps.value(props, "text_shadow_color")) ?? UIColor.black
+        let (dx, dy) = PNViewStyler.shadowOffset(PNProps.value(props, "text_shadow_offset"))
+        shadow.shadowOffset = CGSize(width: dx, height: dy)
+        shadow.shadowBlurRadius = CGFloat(PNProps.double(PNProps.value(props, "text_shadow_radius")) ?? 0)
+        return shadow
+    }
+
+    func applyAttributed(_ label: UILabel, _ props: [String: Any]) {
+        guard let text = label.text, !text.isEmpty else { return }
+        label.attributedText = NSAttributedString(string: text, attributes: PNTextManager.baseAttributes(props, font: label.font))
+    }
+
+    func applySpans(_ label: UILabel, _ merged: [String: Any]) {
+        let mode = PNProps.string(PNProps.value(merged, "text_transform"))
+        let spans = ((PNProps.value(merged, "spans") as? [Any]) ?? []).compactMap { $0 as? [String: Any] }
+        let texts = spans.map { PNTextManager.transform(PNProps.string($0["text"]), mode: mode) }
+        let full = NSMutableAttributedString(string: texts.joined(), attributes: PNTextManager.baseAttributes(merged, font: label.font))
+        let baseSize = label.font?.pointSize ?? 17
+        var location = 0
+        for (span, text) in zip(spans, texts) {
+            let length = (text as NSString).length
+            let range = NSRange(location: location, length: length)
+            location += length
+            if length == 0 { continue }
+            if PNTextManager.fontKeys.contains(where: { PNProps.value(span, $0) != nil }) {
+                let size = CGFloat(PNProps.double(PNProps.value(span, "font_size")) ?? Double(baseSize))
+                var weight: Any? = PNProps.value(span, "font_weight")
+                if weight == nil, PNProps.bool(PNProps.value(span, "bold")) == true { weight = "bold" }
+                let font = PNTextManager.font(
+                    size: size, weight: weight, family: PNProps.string(PNProps.value(span, "font_family")),
+                    italic: PNProps.bool(PNProps.value(span, "italic")) == true
+                )
+                full.addAttribute(.font, value: font, range: range)
+            }
+            if let color = PNColor.parse(PNProps.value(span, "color")) {
+                full.addAttribute(.foregroundColor, value: color, range: range)
+            }
+            if let color = PNColor.parse(PNProps.value(span, "background_color")) {
+                full.addAttribute(.backgroundColor, value: color, range: range)
+            }
+            if let kern = PNProps.double(PNProps.value(span, "letter_spacing")) {
+                full.addAttribute(.kern, value: kern, range: range)
+            }
+            switch PNProps.string(PNProps.value(span, "text_decoration")) {
+            case "underline": full.addAttribute(.underlineStyle, value: NSUnderlineStyle.single.rawValue, range: range)
+            case "line_through": full.addAttribute(.strikethroughStyle, value: NSUnderlineStyle.single.rawValue, range: range)
+            default: break
+            }
+        }
+        label.attributedText = full
+    }
+}

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

@@ -0,0 +1,82 @@
+import UIKit
+
+/// Builds `CGAffineTransform`s from the `transform` style prop.
+///
+/// The prop is a list of single-key dicts: `rotate` (degrees, or a
+/// `"45deg"` / `"0.5rad"` string), `scale`, `scale_x`, `scale_y`,
+/// `translate_x`, `translate_y`, `skew_x`, `skew_y` (degrees).
+public enum PNTransform {
+    /// Build a transform from a spec list (or single dict). `nil` is identity.
+    public static func make(_ spec: Any?) -> CGAffineTransform {
+        var transform = CGAffineTransform.identity
+        guard let spec = spec, !(spec is NSNull) else { return transform }
+        let entries: [Any] = (spec as? [Any]) ?? [spec]
+        for entry in entries {
+            guard let dict = entry as? [String: Any] else { continue }
+            if let rotate = dict["rotate"] {
+                transform = transform.rotated(by: angle(rotate))
+            }
+            if let scale = PNProps.double(dict["scale"]) {
+                transform = transform.scaledBy(x: CGFloat(scale), y: CGFloat(scale))
+            }
+            if let sx = PNProps.double(dict["scale_x"]) {
+                transform = transform.scaledBy(x: CGFloat(sx), y: 1)
+            }
+            if let sy = PNProps.double(dict["scale_y"]) {
+                transform = transform.scaledBy(x: 1, y: CGFloat(sy))
+            }
+            if dict["translate_x"] != nil || dict["translate_y"] != nil {
+                let tx = PNProps.double(dict["translate_x"]) ?? 0
+                let ty = PNProps.double(dict["translate_y"]) ?? 0
+                transform = transform.translatedBy(x: CGFloat(tx), y: CGFloat(ty))
+            }
+            if dict["skew_x"] != nil || dict["skew_y"] != nil {
+                let skew = CGAffineTransform(
+                    a: 1, b: tan(angle(dict["skew_y"] ?? 0)),
+                    c: tan(angle(dict["skew_x"] ?? 0)), d: 1,
+                    tx: 0, ty: 0
+                )
+                transform = skew.concatenating(transform)
+            }
+        }
+        return transform
+    }
+
+    /// Whether every component of `t` is finite.
+    public static func isFinite(_ t: CGAffineTransform) -> Bool {
+        t.a.isFinite && t.b.isFinite && t.c.isFinite && t.d.isFinite && t.tx.isFinite && t.ty.isFinite
+    }
+
+    /// Apply the `transform` prop to `view` (identity when `null`).
+    public static func apply(_ view: UIView, spec: Any?) {
+        let transform = make(spec)
+        guard isFinite(transform) else {
+            PNLog.rateLimited(PNLog.components, key: "set_transform:nan", "[set_transform:nan] spec=\(String(describing: spec))")
+            view.transform = .identity
+            return
+        }
+        view.transform = transform
+    }
+
+    /// Parse a rotation value into radians (`"90deg"`, `"1.5rad"`, or numeric degrees).
+    public static func angle(_ value: Any) -> CGFloat {
+        if let text = value as? String {
+            let lower = text.lowercased()
+            if lower.hasSuffix("deg"), let degrees = Double(lower.dropLast(3)) {
+                return CGFloat(degrees * .pi / 180)
+            }
+            if lower.hasSuffix("rad"), let radians = Double(lower.dropLast(3)) {
+                return CGFloat(radians)
+            }
+        }
+        return CGFloat((PNProps.double(value) ?? 0) * .pi / 180)
+    }
+
+    /// Decompose an affine transform into the animatable channels.
+    public static func decompose(_ t: CGAffineTransform) -> (translateX: CGFloat, translateY: CGFloat, scaleX: CGFloat, scaleY: CGFloat, rotateDegrees: CGFloat) {
+        let scaleX = sqrt(t.a * t.a + t.b * t.b)
+        let scaleY = sqrt(t.c * t.c + t.d * t.d)
+        let rotation = atan2(t.b, t.a)
+        return (t.tx, t.ty, scaleX, scaleY, rotation * 180 / .pi)
+    }
+}

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

@@ -0,0 +1,86 @@
+import UIKit
+
+/// `View`, `Row`, and `Column`: a hit-test-aware flex container. All
+/// layout semantics live in the Python layout engine; the manager only
+/// applies visual props and frames.
+public final class PNViewManager: PNComponentManager {
+    public override func makeView(props: [String: Any]) -> UIView {
+        PNContainerView(frame: .zero)
+    }
+}
+
+/// `Spacer`: an empty layout placeholder.
+public final class PNSpacerManager: PNComponentManager {
+    public override func makeView(props: [String: Any]) -> UIView {
+        UIView(frame: .zero)
+    }
+
+    public override func apply(view: UIView, props: [String: Any], initial: Bool) {
+        // Sizing is entirely the layout engine's; nothing visual to apply.
+    }
+}
+
+/// `SafeAreaView`: a plain container; insets are applied by the layout engine.
+public final class PNSafeAreaViewManager: PNComponentManager {
+    public override func makeView(props: [String: Any]) -> UIView {
+        PNContainerView(frame: .zero)
+    }
+}
+
+/// `KeyboardAvoidingView`: a container that keeps the keyboard observer
+/// installed so Python receives keyboard height updates.
+public final class PNKeyboardAvoidingViewManager: PNComponentManager {
+    public override func makeView(props: [String: Any]) -> UIView {
+        PNKeyboardObserver.shared.start()
+        return PNContainerView(frame: .zero)
+    }
+}
+
+/// Publishes the keyboard height through
+/// `callback("module", 0, "Host", {"event": "keyboard", "payload": {"height": h}})`.
+public final class PNKeyboardObserver {
+    public static let shared = PNKeyboardObserver()
+
+    private var started = false
+    private(set) public var height: CGFloat = 0
+
+    private init() {}
+
+    /// Begin observing keyboard notifications (idempotent).
+    public func start() {
+        if started { return }
+        started = true
+        let center = NotificationCenter.default
+        center.addObserver(self, selector: #selector(willShow(_:)), name: UIResponder.keyboardWillShowNotification, object: nil)
+        center.addObserver(self, selector: #selector(willChange(_:)), name: UIResponder.keyboardWillChangeFrameNotification, object: nil)
+        center.addObserver(self, selector: #selector(willHide(_:)), name: UIResponder.keyboardWillHideNotification, object: nil)
+    }
+
+    @objc private func willShow(_ note: Notification) {
+        publish(Self.keyboardHeight(from: note))
+    }
+
+    @objc private func willChange(_ note: Notification) {
+        publish(Self.keyboardHeight(from: note))
+    }
+
+    @objc private func willHide(_ note: Notification) {
+        publish(0)
+    }
+
+    private func publish(_ value: CGFloat) {
+        let clamped = max(0, value)
+        if clamped == height { return }
+        height = clamped
+        PNModuleEvents.emit(module: "Host", event: "keyboard", payload: ["height": Double(clamped)])
+    }
+
+    static func keyboardHeight(from note: Notification) -> CGFloat {
+        guard let frame = (note.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue else {
+            return 0
+        }
+        let screen = PNWindow.screenBounds()
+        if screen.height > 0, frame.origin.y >= screen.height { return 0 }
+        return frame.height
+    }
+}

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

@@ -0,0 +1,87 @@
+import UIKit
+
+/// Per-view state attached to every bridge-created `UIView`.
+///
+/// Managers are shared per element type, so anything a manager needs
+/// to remember about one view (its merged props, style bookkeeping,
+/// recognizers, suppress flags) lives here. The state is stored as an
+/// associated object so it can be reached from any `UIView` reference.
+public final class PNViewState {
+    /// The reconciler tag of the view.
+    public let tag: Int64
+    /// Element type name.
+    public let typeName: String
+    /// Every prop the view has received so far (updates merge; `null` removes).
+    public var props: [String: Any] = [:]
+    /// Free-form storage for manager-specific values (suppress flags, delegates, ...).
+    public var extras: [String: Any] = [:]
+    /// Strong references the view's manager needs to keep alive (delegates, targets).
+    public var retained: [AnyObject] = []
+    /// Recognizers installed from the `gestures` prop.
+    public var gestureRecognizers: [UIGestureRecognizer] = []
+
+    // Style bookkeeping used by `PNViewStyler` at frame time.
+    var requestedCornerRadius: CGFloat?
+    var cornerRadii: [CGFloat]?
+    var sideBorderWidths: [CGFloat]?
+    var sideBorderColors: [UIColor]?
+    var sideBorderLayers: [CALayer?] = [nil, nil, nil, nil]
+
+    init(tag: Int64, typeName: String) {
+        self.tag = tag
+        self.typeName = typeName
+    }
+
+    /// Names of the events wired on the element this render (`_pn_events`).
+    public var eventNames: Set<String> {
+        guard let list = props["_pn_events"] as? [Any] else { return [] }
+        return Set(list.compactMap { $0 as? String })
+    }
+
+    /// Whether the element wired a callback named `name`.
+    public func hasEvent(_ name: String) -> Bool {
+        eventNames.contains(name)
+    }
+
+    /// Typed access to `extras`.
+    public func flag(_ key: String) -> Bool {
+        (extras[key] as? Bool) ?? false
+    }
+
+    private static var key: UInt8 = 0
+
+    /// Attach a fresh state object to `view`.
+    @discardableResult
+    static func attach(_ view: UIView, tag: Int64, typeName: String) -> PNViewState {
+        let state = PNViewState(tag: tag, typeName: typeName)
+        objc_setAssociatedObject(view, &key, state, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+        return state
+    }
+
+    /// The state attached to `view`, if any.
+    public static func existing(for view: UIView) -> PNViewState? {
+        objc_getAssociatedObject(view, &key) as? PNViewState
+    }
+
+    static func detach(_ view: UIView) {
+        objc_setAssociatedObject(view, &key, nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    }
+}
+
+/// Event emission keyed by view.
+public enum PNEvents {
+    /// Emit `name` for `view` with positional `args`. Returns Python's
+    /// JSON reply for request-style events, else `nil`.
+    @discardableResult
+    public static func emit(_ view: UIView, _ name: String, _ args: [Any?] = []) -> String? {
+        guard let state = PNViewState.existing(for: view) else { return nil }
+        return PNBridge.shared.emitEvent(tag: state.tag, name: name, args: args)
+    }
+
+    /// Emit only when the element wired a handler for `name`.
+    @discardableResult
+    public static func emitIfWired(_ view: UIView, _ name: String, _ args: [Any?] = []) -> String? {
+        guard let state = PNViewState.existing(for: view), state.hasEvent(name) else { return nil }
+        return PNBridge.shared.emitEvent(tag: state.tag, name: name, args: args)
+    }
+}