aix 0.5.1 → 0.6.1

package/ios/EditMenuDefaultActions.swift

@@ -0,0 +1,70 @@
+import UIKit
+
+enum EditMenuDefaultActions: String, CaseIterable {
+    case define
+    case translate
+    case promptForReplace
+    case cut
+    case copy
+    case paste
+    case delete
+    case select
+    case selectAll
+    case transliterateChinese
+    case insertDrawing
+    case captureTextFromCamera
+    case toggleBoldface
+    case toggleItalics
+    case toggleUnderline
+    case makeTextWritingDirectionRightToLeft
+    case makeTextWritingDirectionLeftToRight
+    case showTextFormattingOptions
+    case findSelected
+    case addShortcut
+    case accessibilitySpeak
+    case accessibilitySpeakLanguageSelection
+    case accessibilityPauseSpeaking
+    case share
+
+    var selectorString: String {
+        switch self {
+        case .define: return "_define:"
+        case .translate: return "_translate:"
+        case .promptForReplace: return "_promptForReplace:"
+        case .cut: return "cut:"
+        case .copy: return "copy:"
+        case .paste: return "paste:"
+        case .delete: return "delete:"
+        case .select: return "select:"
+        case .selectAll: return "selectAll:"
+        case .transliterateChinese: return "_transliterateChinese:"
+        case .insertDrawing: return "_insertDrawing:"
+        case .captureTextFromCamera: return "captureTextFromCamera:"
+        case .toggleBoldface: return "toggleBoldface:"
+        case .toggleItalics: return "toggleItalics:"
+        case .toggleUnderline: return "toggleUnderline:"
+        case .makeTextWritingDirectionRightToLeft: return "makeTextWritingDirectionRightToLeft:"
+        case .makeTextWritingDirectionLeftToRight: return "makeTextWritingDirectionLeftToRight:"
+        case .showTextFormattingOptions: return "_showTextFormattingOptions:"
+        case .findSelected: return "_findSelected:"
+        case .addShortcut: return "_addShortcut:"
+        case .accessibilitySpeak: return "_accessibilitySpeak:"
+        case .accessibilitySpeakLanguageSelection: return "_accessibilitySpeakLanguageSelection:"
+        case .accessibilityPauseSpeaking: return "_accessibilityPauseSpeaking:"
+        case .share: return "_share:"
+        }
+    }
+
+    var selector: Selector {
+        Selector(self.selectorString)
+    }
+
+    static func getSupportedActions(
+        forResponder responder: UIResponder,
+        withSender sender: Any?
+    ) -> [Self] {
+        Self.allCases.filter {
+            responder.canPerformAction($0.selector, withSender: sender)
+        }
+    }
+}

package/ios/HybridAix.swift

@@ -91,6 +91,19 @@ extension UIView {
         }
         return nil
     }
+
+    /// Recursively search subviews to find the first UITextField or UITextView
+    func findTextInput() -> UIView? {
+        if self is UITextField || self is UITextView {
+            return self
+        }
+        for subview in subviews {
+            if let input = subview.findTextInput() {
+                return input
+            }
+        }
+        return nil
+    }
 }
 
 // MARK: - HybridAix (Root Context)
@@ -115,7 +128,15 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
 
     var scrollOnComposerSizeUpdate: AixScrollOnFooterSizeUpdate?
 
-    var mainScrollViewID: String?
+    var mainScrollViewID: String? {
+        didSet {
+            guard mainScrollViewID != oldValue else { return }
+            removePanGestureObserver()
+            removeScrollViewObservers()
+            cachedScrollView = nil
+            didSetupPanGestureObserver = false
+        }
+    }
     
     func scrollToEnd(animated: Bool?) {
         // Dispatch to main thread since this may be called from RN background thread
@@ -144,7 +165,11 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
         }
     }
 
-    private var didScrollToEndInitially = false
+    private var didScrollToEndInitiallyForId: String? = nil
+
+    private var didScrollToEndInitially: Bool {
+        return didScrollToEndInitiallyForId == (mainScrollViewID ?? "")
+    }
     
     // MARK: - Inner View
     
@@ -732,7 +757,7 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
                 scrollToEndInternal(animated: false)
                 prevIsScrolledNearEnd = getIsScrolledNearEnd(distFromEnd: distFromEnd)
             }
-            didScrollToEndInitially = true
+            didScrollToEndInitiallyForId = mainScrollViewID ?? ""
         } else {
             applyContentInset()
             applyScrollIndicatorInsets()

package/ios/HybridAixCellView.swift

@@ -22,7 +22,6 @@ class HybridAixCellView: HybridAixCellViewSpec {
 
         override init(frame: CGRect) {
             super.init(frame: frame)
-            autoresizingMask = [.flexibleWidth]
             isUserInteractionEnabled = false
         }
 

package/ios/HybridAixComposer.swift

@@ -24,6 +24,15 @@ class HybridAixComposer: HybridAixComposerSpec {
         }
     }
 
+    var fixInput: Bool? = nil {
+        didSet {
+            cachedTextInput = nil
+            if fixInput == true {
+                resolveTextInput()
+            }
+        }
+    }
+
     // MARK: - Inner View
 
     /// Custom UIView that notifies owner when layout changes
@@ -56,6 +65,26 @@ class HybridAixComposer: HybridAixComposerSpec {
         }
     }
 
+    // MARK: - Gesture Target
+
+    /// NSObject helper to bridge target-action for gesture recognizers,
+    /// since HybridAixComposer does not inherit from NSObject.
+    private class GestureTarget: NSObject, UIGestureRecognizerDelegate {
+        let handler: (UIPanGestureRecognizer) -> Void
+
+        init(handler: @escaping (UIPanGestureRecognizer) -> Void) {
+            self.handler = handler
+        }
+
+        @objc func handleGesture(_ gesture: UIPanGestureRecognizer) {
+            handler(gesture)
+        }
+
+        func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer) -> Bool {
+            return true
+        }
+    }
+
     // MARK: - Properties
 
     /// The UIView for this composer
@@ -67,6 +96,12 @@ class HybridAixComposer: HybridAixComposerSpec {
     /// Last reported height (to avoid reporting unchanged heights)
     private var lastReportedHeight: CGFloat = 0
 
+    /// Cached reference to the text input found inside the footer
+    private weak var cachedTextInput: UIView?
+
+    /// Gesture target for pan-to-focus
+    private var panGestureTarget: GestureTarget?
+
     // MARK: - Initialization
 
     override init() {
@@ -105,6 +140,9 @@ class HybridAixComposer: HybridAixComposerSpec {
             // Initial state
             applyKeyboardTransform(height: ctx.keyboardHeight, heightWhenOpen: ctx.keyboardHeightWhenOpen, animated: false)
         }
+
+        // Resolve text input once the hierarchy is connected
+        resolveTextInput()
     }
 
     /// Called when the view is about to be removed from superview
@@ -128,6 +166,50 @@ class HybridAixComposer: HybridAixComposerSpec {
         }
     }
 
+    // MARK: - Text Input
+
+    /// Find and cache the text input inside the footer's view hierarchy
+    var textInput: UIView? {
+        if let cached = cachedTextInput {
+            return cached
+        }
+        let searchRoot = view.superview ?? view
+        let input = searchRoot.findTextInput()
+        cachedTextInput = input
+        return input
+    }
+
+    /// Resolve the text input and apply patches
+    private func resolveTextInput() {
+        print("[Aix] resolveTextInput: fixInput=\(fixInput), textInput=\(textInput)")
+        guard fixInput == true, let input = textInput else { return }
+        guard let scrollView = input as? UIScrollView else { return }
+        print("[Aix] resolveTextInput: scrollView=\(scrollView)")
+        scrollView.showsVerticalScrollIndicator = false
+        scrollView.showsHorizontalScrollIndicator = false
+        scrollView.bounces = false
+        scrollView.alwaysBounceVertical = false
+        scrollView.alwaysBounceHorizontal = false
+        scrollView.keyboardDismissMode = .interactive
+        let target = GestureTarget { [weak self] gesture in
+            self?.handlePanToFocus(gesture)
+        }
+        self.panGestureTarget = target
+        let panGesture = UIPanGestureRecognizer(target: target, action: #selector(GestureTarget.handleGesture(_:)))
+        panGesture.delegate = target
+        scrollView.addGestureRecognizer(panGesture)
+    }
+
+    /// Handle pan to focus the text input
+    private func handlePanToFocus(_ gesture: UIPanGestureRecognizer) {
+        guard gesture.state == .began else { return }
+        guard let input = textInput else { return }
+        let velocity = gesture.velocity(in: input)
+        if velocity.y < -250.0 && !input.isFirstResponder {
+            input.becomeFirstResponder()
+        }
+    }
+
     // MARK: - Keyboard handling
 
     /// Apply keyboard transform to move the composer with the keyboard

package/ios/HybridAixDropzone.swift

@@ -0,0 +1,104 @@
+import Foundation
+import UIKit
+
+class HybridAixDropzone: HybridAixDropzoneSpec {
+    var onDrop: ((_ events: [AixInputWrapperOnPasteEvent]) -> Void)?
+
+    private let dropDelegate = DropzoneDelegate()
+
+    // MARK: - Inner View
+    private final class InnerView: UIView {
+        weak var owner: HybridAixDropzone?
+
+        override func point(inside point: CGPoint, with event: UIEvent?) -> Bool {
+            return false
+        }
+
+        override func didMoveToWindow() {
+            super.didMoveToWindow()
+            owner?.setupDropInteraction()
+        }
+    }
+
+    let view: UIView
+
+    // MARK: - Init
+    override init() {
+        let inner = InnerView()
+        self.view = inner
+        super.init()
+        inner.owner = self
+    }
+
+    private var didSetup = false
+
+    private func setupDropInteraction() {
+        guard !didSetup, view.window != nil else { return }
+        didSetup = true
+
+        dropDelegate.onImages = { [weak self] images in
+            self?.handleDroppedImages(images)
+        }
+
+        // Add drop interaction to the Fabric container (superview) so it covers the full area
+        let target = view.superview ?? view
+        target.addInteraction(UIDropInteraction(delegate: dropDelegate))
+    }
+
+    // MARK: - Drop Handling
+    private func handleDroppedImages(_ images: [UIImage]) {
+        var events: [AixInputWrapperOnPasteEvent] = []
+        for image in images {
+            if let uri = try? PasteFileManager.save(image: image) {
+                let fileURL = URL(fileURLWithPath: uri)
+                events.append(AixInputWrapperOnPasteEvent(
+                    type: "image",
+                    filePath: uri,
+                    fileExtension: fileURL.pathExtension,
+                    fileName: fileURL.lastPathComponent
+                ))
+            }
+        }
+        if !events.isEmpty {
+            onDrop?(events)
+        }
+    }
+}
+
+// MARK: - Drop Delegate
+private final class DropzoneDelegate: NSObject, UIDropInteractionDelegate {
+    var onImages: (([UIImage]) -> Void)?
+
+    func dropInteraction(_ interaction: UIDropInteraction, canHandle session: UIDropSession) -> Bool {
+        return session.items.contains { $0.itemProvider.canLoadObject(ofClass: UIImage.self) }
+    }
+
+    func dropInteraction(_ interaction: UIDropInteraction, sessionDidUpdate session: UIDropSession) -> UIDropProposal {
+        return UIDropProposal(operation: .copy)
+    }
+
+    func dropInteraction(_ interaction: UIDropInteraction, performDrop session: UIDropSession) {
+        let providers = session.items.map { $0.itemProvider }
+        var images: [UIImage] = []
+        let lock = NSLock()
+        let group = DispatchGroup()
+
+        for provider in providers {
+            guard provider.canLoadObject(ofClass: UIImage.self) else { continue }
+            group.enter()
+            provider.loadObject(ofClass: UIImage.self) { object, _ in
+                defer { group.leave() }
+                guard let image = object as? UIImage else { return }
+                lock.lock()
+                images.append(image)
+                lock.unlock()
+            }
+        }
+
+        group.notify(queue: .main) { [weak self] in
+            if !images.isEmpty {
+                self?.onImages?(images)
+            }
+        }
+    }
+}