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

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

@@ -0,0 +1,197 @@
+import UIKit
+
+/// `ScrollView`: a `UIScrollView` wrapping one layout-engine-sized child.
+///
+/// Scroll offsets are reported through `on_scroll` with
+/// `{"x", "y", "extent", "range", "content_width", "content_height"}`.
+/// Commands: `scroll_to_offset`, `scroll_to_end`, `get_scroll_offset`,
+/// `flash_scroll_indicators`.
+public final class PNScrollViewManager: PNComponentManager {
+    public override func makeView(props: [String: Any]) -> UIView {
+        let scroll = UIScrollView(frame: .zero)
+        scroll.contentInsetAdjustmentBehavior = .never
+        return scroll
+    }
+
+    public override func createView(tag: Int64, props: [String: Any]) -> UIView {
+        let view = super.createView(tag: tag, props: props)
+        if let scroll = view as? UIScrollView {
+            let delegate = PNScrollDelegate()
+            scroll.delegate = delegate
+            PNViewState.existing(for: scroll)?.retained.append(delegate)
+        }
+        return view
+    }
+
+    public override func apply(view: UIView, props: [String: Any], initial: Bool) {
+        guard let scroll = view as? UIScrollView else { return }
+        PNViewStyler.applyCommon(scroll, props)
+        if PNProps.has(props, "refresh_control") {
+            applyRefresh(scroll, PNProps.value(props, "refresh_control"))
+        }
+        if PNProps.has(props, "shows_scroll_indicator") {
+            let visible = PNProps.bool(PNProps.value(props, "shows_scroll_indicator")) ?? true
+            scroll.showsVerticalScrollIndicator = visible
+            scroll.showsHorizontalScrollIndicator = visible
+        }
+        if PNProps.has(props, "paging_enabled") {
+            scroll.isPagingEnabled = PNProps.bool(PNProps.value(props, "paging_enabled")) ?? false
+        }
+        if PNProps.has(props, "bounces") {
+            scroll.bounces = PNProps.bool(PNProps.value(props, "bounces")) ?? true
+        }
+        if PNProps.has(props, "scroll_enabled") {
+            scroll.isScrollEnabled = PNProps.bool(PNProps.value(props, "scroll_enabled")) ?? true
+        }
+        if PNProps.has(props, "horizontal") {
+            let horizontal = PNProps.bool(PNProps.value(props, "horizontal")) ?? false
+            scroll.alwaysBounceHorizontal = horizontal
+            scroll.alwaysBounceVertical = !horizontal && scroll.refreshControl != nil
+        }
+        if let mode = PNProps.string(PNProps.value(props, "keyboard_dismiss_mode")) {
+            switch mode {
+            case "on_drag": scroll.keyboardDismissMode = .onDrag
+            case "interactive": scroll.keyboardDismissMode = .interactive
+            default: scroll.keyboardDismissMode = .none
+            }
+        }
+        if PNProps.has(props, "content_inset") {
+            let inset = PNProps.dict(PNProps.value(props, "content_inset")) ?? [:]
+            scroll.contentInset = UIEdgeInsets(
+                top: CGFloat(PNProps.double(inset["top"]) ?? 0), left: CGFloat(PNProps.double(inset["left"]) ?? 0),
+                bottom: CGFloat(PNProps.double(inset["bottom"]) ?? 0), right: CGFloat(PNProps.double(inset["right"]) ?? 0)
+            )
+        }
+        if PNProps.has(props, "scroll_indicator_insets") {
+            let inset = PNProps.dict(PNProps.value(props, "scroll_indicator_insets")) ?? [:]
+            let insets = UIEdgeInsets(
+                top: CGFloat(PNProps.double(inset["top"]) ?? 0), left: CGFloat(PNProps.double(inset["left"]) ?? 0),
+                bottom: CGFloat(PNProps.double(inset["bottom"]) ?? 0), right: CGFloat(PNProps.double(inset["right"]) ?? 0)
+            )
+            scroll.verticalScrollIndicatorInsets = insets
+            scroll.horizontalScrollIndicatorInsets = insets
+        }
+        if PNProps.has(props, "scroll_event_throttle") {
+            PNViewState.existing(for: scroll)?.extras["throttle"] = PNProps.double(PNProps.value(props, "scroll_event_throttle")) ?? 0
+        }
+    }
+
+    public override func command(view: UIView, name: String, args: [String: Any]) -> Any? {
+        guard let scroll = view as? UIScrollView else { return nil }
+        let animated = PNProps.bool(args["animated"]) ?? true
+        switch name {
+        case "scroll_to_offset":
+            let x = CGFloat(PNProps.finite(args["x"]))
+            let y = CGFloat(PNProps.finite(args["y"]))
+            scroll.setContentOffset(CGPoint(x: x, y: y), animated: animated)
+        case "scroll_to_end":
+            let content = scroll.contentSize
+            let bounds = scroll.bounds.size
+            let targetY = max(0, content.height - bounds.height)
+            let targetX = max(0, content.width - bounds.width)
+            let horizontal = content.width > bounds.width && content.height <= bounds.height
+            scroll.setContentOffset(horizontal ? CGPoint(x: targetX, y: 0) : CGPoint(x: 0, y: targetY), animated: animated)
+        case "get_scroll_offset":
+            return ["x": Double(scroll.contentOffset.x), "y": Double(scroll.contentOffset.y)]
+        case "flash_scroll_indicators":
+            scroll.flashScrollIndicators()
+        default:
+            break
+        }
+        return nil
+    }
+
+    // MARK: - Refresh control
+
+    private func applyRefresh(_ scroll: UIScrollView, _ spec: Any?) {
+        guard let spec = spec else {
+            if let existing = scroll.refreshControl {
+                existing.endRefreshing()
+                scroll.refreshControl = nil
+                scroll.alwaysBounceVertical = false
+            }
+            return
+        }
+        let control: UIRefreshControl
+        if let existing = scroll.refreshControl {
+            control = existing
+        } else {
+            control = UIRefreshControl()
+            scroll.refreshControl = control
+            // Content that fits its bounds never engages the pan gesture
+            // without this, making the refresh control unreachable.
+            scroll.alwaysBounceVertical = true
+            let target = PNActionTarget { [weak scroll] in
+                guard let scroll = scroll else { return }
+                PNEvents.emit(scroll, "on_refresh")
+            }
+            control.addTarget(target, action: #selector(PNActionTarget.fire(_:forEvent:)), for: .valueChanged)
+            PNViewState.existing(for: scroll)?.retained.append(target)
+        }
+        let dict = spec as? [String: Any] ?? [:]
+        if let color = PNColor.parse(PNProps.value(dict, "tint_color") ?? PNProps.value(dict, "color")) {
+            control.tintColor = color
+        }
+        if let title = PNProps.string(PNProps.value(dict, "title")) {
+            control.attributedTitle = NSAttributedString(string: title)
+        }
+        if PNProps.bool(dict["refreshing"]) == true {
+            if !control.isRefreshing { control.beginRefreshing() }
+        } else if control.isRefreshing {
+            control.endRefreshing()
+        }
+    }
+}
+
+/// Shared scroll payload builder.
+enum PNScrollPayload {
+    static func make(_ scroll: UIScrollView) -> [String: Any] {
+        let offset = scroll.contentOffset
+        let bounds = scroll.bounds.size
+        let content = scroll.contentSize
+        let horizontal = content.width > bounds.width && content.height <= bounds.height
+        return [
+            "x": Double(offset.x),
+            "y": Double(offset.y),
+            "extent": Double(horizontal ? bounds.width : bounds.height),
+            "range": Double(horizontal ? content.width : content.height),
+            "content_width": Double(content.width),
+            "content_height": Double(content.height),
+            "width": Double(bounds.width),
+            "height": Double(bounds.height),
+        ]
+    }
+}
+
+/// Forwards `UIScrollViewDelegate` callbacks to Python events.
+final class PNScrollDelegate: NSObject, UIScrollViewDelegate {
+    private var lastEmit: TimeInterval = 0
+
+    func scrollViewDidScroll(_ scrollView: UIScrollView) {
+        guard let state = PNViewState.existing(for: scrollView), state.hasEvent("on_scroll") else { return }
+        let throttle = (state.extras["throttle"] as? Double ?? 0) / 1000
+        let now = CACurrentMediaTime()
+        if throttle > 0, now - lastEmit < throttle, scrollView.isDragging || scrollView.isDecelerating { return }
+        lastEmit = now
+        PNEvents.emit(scrollView, "on_scroll", [PNScrollPayload.make(scrollView)])
+    }
+
+    func scrollViewWillBeginDragging(_ scrollView: UIScrollView) {
+        PNEvents.emitIfWired(scrollView, "on_scroll_begin_drag", [PNScrollPayload.make(scrollView)])
+    }
+
+    func scrollViewDidEndDragging(_ scrollView: UIScrollView, willDecelerate decelerate: Bool) {
+        PNEvents.emitIfWired(scrollView, "on_scroll_end_drag", [PNScrollPayload.make(scrollView)])
+        if !decelerate {
+            PNEvents.emitIfWired(scrollView, "on_momentum_scroll_end", [PNScrollPayload.make(scrollView)])
+        }
+    }
+
+    func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
+        PNEvents.emitIfWired(scrollView, "on_momentum_scroll_end", [PNScrollPayload.make(scrollView)])
+    }
+
+    func scrollViewDidEndScrollingAnimation(_ scrollView: UIScrollView) {
+        PNEvents.emitIfWired(scrollView, "on_scroll", [PNScrollPayload.make(scrollView)])
+    }
+}

pythonnative/templates/ios_template/PythonNativeKit/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/templates/ios_template/PythonNativeKit/Sources/PythonNativeKit/Components/PNTextInputManager.swift

@@ -0,0 +1,289 @@
+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 ?? ""
+            if current != value {
+                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 }
+        state.extras["suppress"] = true
+        (view as? UITextField)?.text = text
+        (view as? UITextView)?.text = text
+        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])
+    }
+
+    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()
+    }
+}