pythonnative 0.40.0__cp313-cp313-win_amd64.whl

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

@@ -0,0 +1,106 @@
+import UIKit
+
+/// `TabBar`: a native `UITabBar`. Height is 49 pt plus the bottom safe
+/// area so the bar reaches the home indicator (the screen root extends
+/// past the bottom inset for this reason).
+public final class PNTabBarManager: PNComponentManager {
+    public static let baseHeight: CGFloat = 49
+
+    /// The intrinsic bar height for the current bottom safe-area inset.
+    public static func height(for view: UIView?) -> CGFloat {
+        let bottom = view?.window?.safeAreaInsets.bottom ?? PNWindow.keyWindow()?.safeAreaInsets.bottom ?? 0
+        return baseHeight + bottom
+    }
+
+    public override func makeView(props: [String: Any]) -> UIView {
+        UITabBar(frame: CGRect(x: 0, y: 0, width: 0, height: PNTabBarManager.height(for: nil)))
+    }
+
+    public override func createView(tag: Int64, props: [String: Any]) -> UIView {
+        let view = super.createView(tag: tag, props: props)
+        if let bar = view as? UITabBar {
+            let delegate = PNTabBarDelegate()
+            bar.delegate = delegate
+            PNViewState.existing(for: bar)?.retained.append(delegate)
+        }
+        return view
+    }
+
+    public override func measure(view: UIView, maxW: CGFloat, maxH: CGFloat) -> CGSize {
+        let w = maxW.isFinite && maxW < 1e6 ? maxW : 320
+        return CGSize(width: w, height: PNTabBarManager.height(for: view))
+    }
+
+    public override func apply(view: UIView, props: [String: Any], initial: Bool) {
+        guard let bar = view as? UITabBar else { return }
+        let merged = mergedProps(bar)
+        let items = PNTabBarManager.items(merged)
+        if PNProps.has(props, "items") {
+            bar.setItems(items.enumerated().map { index, item in
+                let title = PNProps.string(item["title"]) ?? PNProps.string(item["name"]) ?? ""
+                let icon = PNTabBarManager.icon(item["icon"])
+                let barItem = UITabBarItem(title: title, image: icon, tag: index)
+                if let badge = PNProps.string(PNProps.value(item, "badge")) { barItem.badgeValue = badge }
+                return barItem
+            }, animated: false)
+        }
+        if PNProps.has(props, "active_tab") || PNProps.has(props, "active_index") || PNProps.has(props, "items") {
+            let activeName = PNProps.string(PNProps.value(merged, "active_tab"))
+            var index = PNProps.int(PNProps.value(merged, "active_index"))
+            if index == nil, let activeName = activeName {
+                index = items.firstIndex { PNProps.string($0["name"]) == activeName }
+            }
+            if let index = index, let barItems = bar.items, index >= 0, index < barItems.count {
+                bar.selectedItem = barItems[index]
+            }
+        }
+        if let color = PNColor.parse(PNProps.value(props, "active_color") ?? PNProps.value(props, "tint_color")) {
+            bar.tintColor = color
+        }
+        if let color = PNColor.parse(PNProps.value(props, "inactive_color")) {
+            bar.unselectedItemTintColor = color
+        }
+        if let color = PNColor.parse(PNProps.value(props, "background_color")) {
+            bar.barTintColor = color
+            bar.backgroundColor = color
+            let appearance = UITabBarAppearance()
+            appearance.configureWithOpaqueBackground()
+            appearance.backgroundColor = color
+            bar.standardAppearance = appearance
+            if #available(iOS 15.0, *) {
+                bar.scrollEdgeAppearance = appearance
+            }
+        }
+        if PNProps.has(props, "translucent") {
+            bar.isTranslucent = PNProps.bool(PNProps.value(props, "translucent")) ?? true
+        }
+        PNViewStyler.applyAccessibility(bar, props)
+    }
+
+    static func items(_ props: [String: Any]) -> [[String: Any]] {
+        ((PNProps.value(props, "items") as? [Any]) ?? []).compactMap { $0 as? [String: Any] }
+    }
+
+    /// Resolve an icon spec (SF Symbol name or `{"ios": name}`) to an image.
+    static func icon(_ spec: Any?) -> UIImage? {
+        var name: String?
+        if let text = spec as? String {
+            name = text
+        } else if let dict = spec as? [String: Any] {
+            name = PNProps.string(dict["ios"])
+        }
+        guard let name = name, !name.isEmpty else { return nil }
+        return UIImage(systemName: name) ?? UIImage(named: name)
+    }
+}
+
+/// Forwards `tabBar(_:didSelect:)` as `on_tab_select(name)` (plus `on_select(index)`).
+final class PNTabBarDelegate: NSObject, UITabBarDelegate {
+    func tabBar(_ tabBar: UITabBar, didSelect item: UITabBarItem) {
+        let index = item.tag
+        let items = PNTabBarManager.items(PNViewState.existing(for: tabBar)?.props ?? [:])
+        guard index >= 0, index < items.count else { return }
+        PNEvents.emit(tabBar, "on_tab_select", [PNProps.string(items[index]["name"]) ?? ""])
+        PNEvents.emitIfWired(tabBar, "on_select", [index])
+    }
+}

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

@@ -0,0 +1,297 @@
+import UIKit
+
+/// `TextInput`: a single-line `UITextField` or multiline `UITextView`.
+///
+/// The class is chosen at creation from the `multiline` prop. Programmatic
+/// `value` updates set a suppress flag so they don't echo into `on_change`.
+public final class PNTextInputManager: PNComponentManager {
+    public override func makeView(props: [String: Any]) -> UIView {
+        if PNProps.bool(PNProps.value(props, "multiline")) == true {
+            let view = UITextView(frame: .zero)
+            view.font = UIFont.systemFont(ofSize: 17)
+            view.backgroundColor = .white
+            return view
+        }
+        let field = UITextField(frame: .zero)
+        field.borderStyle = .roundedRect
+        return field
+    }
+
+    public override func createView(tag: Int64, props: [String: Any]) -> UIView {
+        let view = super.createView(tag: tag, props: props)
+        let delegate = PNTextInputDelegate(view: view)
+        PNViewState.existing(for: view)?.retained.append(delegate)
+        if let field = view as? UITextField {
+            field.delegate = delegate
+            field.addTarget(delegate, action: #selector(PNTextInputDelegate.editingChanged(_:)), for: .editingChanged)
+            field.addTarget(delegate, action: #selector(PNTextInputDelegate.editingDidEndOnExit(_:)), for: .editingDidEndOnExit)
+        } else if let textView = view as? UITextView {
+            textView.delegate = delegate
+        }
+        return view
+    }
+
+    public override func apply(view: UIView, props: [String: Any], initial: Bool) {
+        guard let state = PNViewState.existing(for: view) else { return }
+        let field = view as? UITextField
+        let textView = view as? UITextView
+        if PNProps.has(props, "max_length") {
+            state.extras["max_length"] = PNProps.int(PNProps.value(props, "max_length")) as Any? ?? NSNull()
+        }
+        if let value = PNProps.string(PNProps.value(props, "value")) {
+            let current = field?.text ?? textView?.text ?? ""
+            let acknowledged = PNProps.int(props["_pn_edit_revision"]) ?? 0
+            let edited = state.extras["edit_revision"] as? Int ?? 0
+            if current != value && acknowledged >= edited && (view as? UITextInput)?.markedTextRange == nil {
+                PNTextInputManager.setText(view, value)
+            }
+        }
+        if let field = field {
+            if PNProps.has(props, "placeholder") {
+                field.placeholder = PNProps.string(PNProps.value(props, "placeholder")) ?? ""
+            }
+            if let color = PNColor.parse(PNProps.value(props, "placeholder_color")) {
+                let placeholder = PNProps.string(PNProps.value(state.props, "placeholder")) ?? ""
+                field.attributedPlaceholder = NSAttributedString(string: placeholder, attributes: [.foregroundColor: color])
+            }
+            if PNProps.has(props, "clear_button") {
+                field.clearButtonMode = PNProps.bool(PNProps.value(props, "clear_button")) == true ? .whileEditing : .never
+            }
+        }
+        if let size = PNProps.double(PNProps.value(props, "font_size")) {
+            let font = UIFont.systemFont(ofSize: CGFloat(size))
+            field?.font = font
+            textView?.font = font
+        }
+        if let color = PNColor.parse(PNProps.value(props, "color")) {
+            field?.textColor = color
+            textView?.textColor = color
+        }
+        if let color = PNColor.parse(PNProps.value(props, "background_color")) {
+            view.backgroundColor = color
+        }
+        if PNProps.has(props, "secure") {
+            let secure = PNProps.bool(PNProps.value(props, "secure")) ?? false
+            field?.isSecureTextEntry = secure
+            textView?.isSecureTextEntry = secure
+        }
+        if let keyboard = PNProps.string(PNProps.value(props, "keyboard_type")) {
+            let type = PNTextInputManager.keyboardType(keyboard)
+            field?.keyboardType = type
+            textView?.keyboardType = type
+        }
+        if let cap = PNProps.string(PNProps.value(props, "auto_capitalize")) {
+            let type = PNTextInputManager.capitalization(cap)
+            field?.autocapitalizationType = type
+            textView?.autocapitalizationType = type
+        }
+        if PNProps.has(props, "auto_correct") {
+            let type: UITextAutocorrectionType = PNProps.bool(PNProps.value(props, "auto_correct")) == true ? .yes : .no
+            field?.autocorrectionType = type
+            textView?.autocorrectionType = type
+        }
+        if let key = PNProps.string(PNProps.value(props, "return_key_type")) {
+            let type = PNTextInputManager.returnKey(key)
+            field?.returnKeyType = type
+            textView?.returnKeyType = type
+        }
+        if let color = PNColor.parse(PNProps.value(props, "selection_color")) {
+            view.tintColor = color
+        }
+        if PNProps.has(props, "text_content_type") {
+            let type = PNProps.string(PNProps.value(props, "text_content_type")).flatMap(PNTextInputManager.contentType)
+            field?.textContentType = type
+            textView?.textContentType = type
+        }
+        if PNProps.has(props, "editable") {
+            let editable = PNProps.bool(PNProps.value(props, "editable")) ?? true
+            field?.isEnabled = editable
+            textView?.isEditable = editable
+        }
+        if PNProps.bool(PNProps.value(props, "auto_focus")) == true {
+            view.becomeFirstResponder()
+        }
+        PNViewStyler.applyDecoration(view, props)
+    }
+
+    public override func measure(view: UIView, maxW: CGFloat, maxH: CGFloat) -> CGSize {
+        let size = super.measure(view: view, maxW: maxW, maxH: maxH)
+        return CGSize(width: max(size.width, 100), height: max(size.height, 36))
+    }
+
+    public override func command(view: UIView, name: String, args: [String: Any]) -> Any? {
+        switch name {
+        case "focus":
+            view.becomeFirstResponder()
+        case "blur":
+            view.resignFirstResponder()
+        case "clear":
+            PNTextInputManager.setText(view, "")
+        case "get_value":
+            return (view as? UITextField)?.text ?? (view as? UITextView)?.text ?? ""
+        case "set_selection":
+            if let start = PNProps.int(args["start"]) {
+                let end = PNProps.int(args["end"]) ?? start
+                PNTextInputManager.setSelection(view, start: start, end: end)
+            }
+        default:
+            break
+        }
+        return nil
+    }
+
+    // MARK: - Helpers
+
+    static func setText(_ view: UIView, _ text: String) {
+        guard let state = PNViewState.existing(for: view) else { return }
+        let input = view as? UITextInput
+        let selection = input?.selectedTextRange
+        let start = selection.flatMap { range in input.map { $0.offset(from: $0.beginningOfDocument, to: range.start) } } ?? 0
+        let end = selection.flatMap { range in input.map { $0.offset(from: $0.beginningOfDocument, to: range.end) } } ?? start
+        state.extras["suppress"] = true
+        (view as? UITextField)?.text = text
+        (view as? UITextView)?.text = text
+        setSelection(view, start: min(start, text.utf16.count), end: min(end, text.utf16.count))
+        state.extras["suppress"] = false
+    }
+
+    static func setSelection(_ view: UIView, start: Int, end: Int) {
+        guard let input = view as? UITextInput else { return }
+        let begin = input.beginningOfDocument
+        guard let from = input.position(from: begin, offset: start),
+              let to = input.position(from: begin, offset: end)
+        else { return }
+        input.selectedTextRange = input.textRange(from: from, to: to)
+    }
+
+    static func keyboardType(_ name: String) -> UIKeyboardType {
+        switch name {
+        case "ascii": return .asciiCapable
+        case "numbers_and_punctuation": return .numbersAndPunctuation
+        case "url": return .URL
+        case "number_pad", "numeric": return .numberPad
+        case "phone_pad": return .phonePad
+        case "email_address", "email": return .emailAddress
+        case "decimal_pad", "decimal": return .decimalPad
+        case "web_search": return .webSearch
+        default: return .default
+        }
+    }
+
+    static func capitalization(_ name: String) -> UITextAutocapitalizationType {
+        switch name {
+        case "none": return .none
+        case "words": return .words
+        case "characters": return .allCharacters
+        default: return .sentences
+        }
+    }
+
+    static func returnKey(_ name: String) -> UIReturnKeyType {
+        switch name {
+        case "go": return .go
+        case "google": return .google
+        case "join": return .join
+        case "next": return .next
+        case "route": return .route
+        case "search": return .search
+        case "send": return .send
+        case "yahoo": return .yahoo
+        case "done": return .done
+        default: return .default
+        }
+    }
+
+    static func contentType(_ name: String) -> UITextContentType? {
+        switch name.trimmingCharacters(in: .whitespaces).lowercased() {
+        case "username": return .username
+        case "password": return .password
+        case "new_password": return .newPassword
+        case "one_time_code": return .oneTimeCode
+        case "email", "email_address": return .emailAddress
+        case "name": return .name
+        case "url": return .URL
+        case "telephone", "telephone_number", "phone", "phone_number": return .telephoneNumber
+        default: return nil
+        }
+    }
+}
+
+/// Delegate and control target for both input classes.
+final class PNTextInputDelegate: NSObject, UITextFieldDelegate, UITextViewDelegate {
+    private weak var view: UIView?
+
+    init(view: UIView) {
+        self.view = view
+    }
+
+    private func currentText() -> String {
+        (view as? UITextField)?.text ?? (view as? UITextView)?.text ?? ""
+    }
+
+    private func emitChange() {
+        guard let view = view, let state = PNViewState.existing(for: view), !state.flag("suppress") else { return }
+        var text = currentText()
+        if let maxLength = state.extras["max_length"] as? Int, maxLength >= 0, text.count > maxLength {
+            text = String(text.prefix(maxLength))
+            PNTextInputManager.setText(view, text)
+        }
+        PNEvents.emit(view, "on_change", [text])
+        PNLayout.invalidate(state.tag)
+    }
+
+    private func emitSelection() {
+        guard let view = view, let state = PNViewState.existing(for: view), state.hasEvent("on_selection_change"),
+              let input = view as? UITextInput, let range = input.selectedTextRange
+        else { return }
+        let start = input.offset(from: input.beginningOfDocument, to: range.start)
+        let end = input.offset(from: input.beginningOfDocument, to: range.end)
+        PNEvents.emit(view, "on_selection_change", [["start": start, "end": end]])
+    }
+
+    // MARK: UITextField
+
+    @objc func editingChanged(_ sender: Any?) {
+        emitChange()
+    }
+
+    @objc func editingDidEndOnExit(_ sender: Any?) {
+        guard let view = view else { return }
+        PNEvents.emit(view, "on_submit", [currentText()])
+    }
+
+    func textFieldShouldReturn(_ textField: UITextField) -> Bool {
+        textField.resignFirstResponder()
+        return true
+    }
+
+    func textFieldDidBeginEditing(_ textField: UITextField) {
+        if let view = view { PNEvents.emit(view, "on_focus") }
+    }
+
+    func textFieldDidEndEditing(_ textField: UITextField) {
+        if let view = view { PNEvents.emit(view, "on_blur") }
+    }
+
+    func textFieldDidChangeSelection(_ textField: UITextField) {
+        emitSelection()
+    }
+
+    // MARK: UITextView
+
+    func textViewDidChange(_ textView: UITextView) {
+        emitChange()
+    }
+
+    func textViewDidBeginEditing(_ textView: UITextView) {
+        if let view = view { PNEvents.emit(view, "on_focus") }
+    }
+
+    func textViewDidEndEditing(_ textView: UITextView) {
+        if let view = view { PNEvents.emit(view, "on_blur") }
+    }
+
+    func textViewDidChangeSelection(_ textView: UITextView) {
+        emitSelection()
+    }
+}

pythonnative/native/ios/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
+    }
+}