craft-native 0.0.164 → 0.0.166

package/dist/ios/templates/CraftHybrid.swift

@@ -1004,7 +1004,8 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
     private var openingWeb = false
     private var firstFrameLogged = false
     private var tabBarHeight: CGFloat = 0
-    private var tabSwipeRecognizers: [UISwipeGestureRecognizer] = []
+    private var tabSwipeRecognizers: [UIGestureRecognizer] = []
+    private var activeTabSwipeTarget: String?
 
     init(config: CraftConfig) {
         self.config = config
@@ -1047,28 +1048,137 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
 
     private func installTabSwipeGestures() {
         guard tabSwipeRecognizers.isEmpty else { return }
-        for direction in [UISwipeGestureRecognizer.Direction.left, .right] {
-            let recognizer = UISwipeGestureRecognizer(target: self, action: #selector(tabSwipeRecognized(_:)))
-            recognizer.direction = direction
-            recognizer.delegate = self
-            recognizer.cancelsTouchesInView = false
-            recognizer.delaysTouchesBegan = false
-            view.addGestureRecognizer(recognizer)
-            tabSwipeRecognizers.append(recognizer)
-        }
+        let recognizer = UIPanGestureRecognizer(target: self, action: #selector(tabSwipeRecognized(_:)))
+        recognizer.delegate = self
+        recognizer.cancelsTouchesInView = false
+        recognizer.delaysTouchesBegan = false
+        view.addGestureRecognizer(recognizer)
+        tabSwipeRecognizers.append(recognizer)
     }
 
-    @objc private func tabSwipeRecognized(_ recognizer: UISwipeGestureRecognizer) {
+    @objc private func tabSwipeRecognized(_ recognizer: UIPanGestureRecognizer) {
         let tabs = hybrid.tabIds
         guard let index = tabs.firstIndex(of: currentTab), tabs.count > 1 else { return }
-        let next = recognizer.direction == .left ? index + 1 : index - 1
-        guard tabs.indices.contains(next) else { return }
-        CraftChrome.shared.swipe(to: tabs[next])
+        let translation = recognizer.translation(in: view).x
+        let velocity = recognizer.velocity(in: view).x
+        switch recognizer.state {
+        case .changed:
+            if activeTabSwipeTarget == nil {
+                let direction = abs(translation) > 1 ? translation : velocity
+                guard abs(direction) > 1 else { return }
+                let next = direction < 0 ? index + 1 : index - 1
+                guard tabs.indices.contains(next), beginInteractiveTabSwipe(to: tabs[next], direction: direction < 0 ? -1 : 1) else { return }
+                activeTabSwipeTarget = tabs[next]
+            }
+            updateInteractiveTabSwipe(translation: translation)
+        case .ended, .cancelled, .failed:
+            guard let target = activeTabSwipeTarget else {
+                guard recognizer.state == .ended else { return }
+                let delta = abs(translation) >= 32 ? translation : velocity
+                guard abs(delta) >= 32 else { return }
+                let next = delta < 0 ? index + 1 : index - 1
+                guard tabs.indices.contains(next) else { return }
+                CraftChrome.shared.swipe(to: tabs[next])
+                return
+            }
+            activeTabSwipeTarget = nil
+            let complete = recognizer.state == .ended && (abs(translation) >= max(32, view.bounds.width * 0.28) || abs(velocity) > 700)
+            finishInteractiveTabSwipe(completed: complete) { [weak self] in
+                guard complete else {
+                    CraftChrome.shared.cancelTabSwipe()
+                    return
+                }
+                CraftChrome.shared.commitTabSwipe(to: target)
+                self?.view.layoutIfNeeded()
+            }
+        default:
+            break
+        }
+    }
+
+    /// Prepare a mounted target beside the current stack. Native roots render
+    /// immediately; a web root borrows the shared WebView and stays
+    /// transparent until its page route catches up. Two web roots still use
+    /// the route-aware fallback because one WebView cannot render both pages.
+    private func beginInteractiveTabSwipe(to id: String, direction: CGFloat) -> Bool {
+        guard let current = visibleStack, let target = stacks[id],
+              current.view !== target.view,
+              !(current.topViewController is CraftHybridWebSlot && target.topViewController is CraftHybridWebSlot),
+              view.bounds.width > 0 else { return false }
+        if let slot = target.topViewController as? CraftHybridWebSlot {
+            // There is one shared WebView, so a web-to-web gesture cannot
+            // render two pages at once. A native-to-web gesture can: move the
+            // WebView into the hidden target slot and let its route catch up
+            // while the slot follows the finger. It stays transparent until
+            // the page reports that it reached the target path.
+            slot.awaitingPage = true
+            adoptWeb(into: slot, allowHiddenStack: true)
+            webHost?.view.alpha = 0
+            hybrid.navigatePage(slot.path) { [weak self, weak slot] depth in
+                guard let self, let slot else { return }
+                slot.depth = depth
+                guard self.activeTabSwipeTarget == id,
+                      CraftHybridRoutes.normalize(self.hybrid.pagePath ?? "") == CraftHybridRoutes.normalize(slot.path) else { return }
+                self.reveal(slot)
+            }
+        }
+        target.view.isHidden = false
+        let width = view.bounds.width
+        target.view.frame = view.bounds.offsetBy(dx: direction * width, dy: 0)
+        view.bringSubviewToFront(target.view)
+        CraftChrome.shared.beginTabSwipe(to: id)
+        return true
+    }
+
+    private func updateInteractiveTabSwipe(translation: CGFloat) {
+        guard let targetId = activeTabSwipeTarget, let current = visibleStack,
+              let target = stacks[targetId] else { return }
+        let width = max(1, view.bounds.width)
+        let start = target.view.frame.minX >= width * 0.5 ? width : -width
+        let offset = min(width, max(-width, translation))
+        target.view.frame.origin.x = start + offset
+        current.view.frame.origin.x = offset
+    }
+
+    private func finishInteractiveTabSwipe(completed: Bool, completion: @escaping () -> Void) {
+        guard let targetId = activeTabSwipeTarget, let current = visibleStack,
+              let target = stacks[targetId] else { completion(); return }
+        let width = view.bounds.width
+        let direction: CGFloat = target.view.frame.minX >= 0 ? 1 : -1
+        let end = completed ? 0 : direction * width
+        let duration = CraftChrome.motion(.easeOut(duration: completed ? 0.22 : 0.18)) == nil ? 0 : 0.22
+        UIView.animate(withDuration: duration, animations: {
+            target.view.frame.origin.x = end
+            current.view.frame.origin.x = completed ? -direction * width : 0
+        }, completion: { _ in
+            if !completed {
+                target.view.isHidden = true
+                target.view.frame = self.view.bounds
+                current.view.frame = self.view.bounds
+                if target.topViewController is CraftHybridWebSlot,
+                   current.topViewController is CraftNativeScreenController {
+                    self.parkWeb()
+                }
+            }
+            completion()
+        })
     }
 
     private func horizontalScrollAt(_ point: CGPoint, in root: UIView) -> Bool {
         let local = root.convert(point, from: view)
         guard root.bounds.contains(local), let hit = root.hitTest(local, with: nil) else { return false }
+        // WKWebView keeps its scrolling UIScrollView below the hosting view
+        // that owns the native slot, so it is not necessarily on the hit
+        // view's superview chain. Treat an overflowing page as its own
+        // horizontal gesture surface before the shell claims the swipe.
+        if let webView = CraftChrome.shared.webView,
+           hit === webView || hit.isDescendant(of: webView) || webView.isDescendant(of: hit) {
+            let scroll = webView.scrollView
+            if scroll.isScrollEnabled,
+               scroll.alwaysBounceHorizontal || scroll.contentSize.width > scroll.bounds.width + 1 {
+                return true
+            }
+        }
         var candidate: UIView? = hit
         while let current = candidate {
             if let scroll = current as? UIScrollView,
@@ -1193,6 +1303,7 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
         }
         currentTab = id
         for (key, other) in stacks { other.view.isHidden = key != id }
+        nav.view.frame = view.bounds
         view.bringSubviewToFront(nav.view)
         if let slot = nav.topViewController as? CraftHybridWebSlot, slot.isViewLoaded {
             adoptWeb(into: slot)
@@ -1206,8 +1317,9 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
         pendingTab = nil
     }
 
-    func adoptWeb(into slot: CraftHybridWebSlot) {
-        guard let webHost, slot.navigationController === visibleStack || visibleStack == nil else { return }
+    func adoptWeb(into slot: CraftHybridWebSlot, allowHiddenStack: Bool = false) {
+        guard let webHost,
+              allowHiddenStack || slot.navigationController === visibleStack || visibleStack == nil else { return }
         attachWeb()
         moveWeb(to: slot, in: slot.view)
         webHost.view.alpha = slot.awaitingPage ? 0 : 1
@@ -1333,6 +1445,13 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
 
     func pageNavigated(path: String, direction: String, depth: Int, byHost: Bool) {
         let owner = CraftHybridRoutes.tab(owning: path, among: hybrid.tabIds)
+        if let targetId = activeTabSwipeTarget,
+           let target = stacks[targetId]?.topViewController as? CraftHybridWebSlot,
+           owner == targetId || CraftHybridRoutes.normalize(path) == CraftHybridRoutes.normalize(target.path) {
+            target.depth = depth
+            target.awaitingPage = false
+            reveal(target)
+        }
         if let pending = pendingTab, owner == pending.id || direction == "tab" {
             show(tab: pending.id)
         }
@@ -1521,6 +1640,11 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
     func gestureRecognizerShouldBegin(_ gestureRecognizer: UIGestureRecognizer) -> Bool {
         if tabSwipeRecognizers.contains(where: { $0 === gestureRecognizer }) {
             guard hybrid.tabIds.count > 1, let top = visibleStack?.topViewController else { return false }
+            guard CraftChrome.shared.tabSwipeEnabled else { return false }
+            if let pan = gestureRecognizer as? UIPanGestureRecognizer {
+                let velocity = pan.velocity(in: view)
+                guard abs(velocity.x) > abs(velocity.y) else { return false }
+            }
             if let native = top as? CraftNativeScreenController,
                !native.tabSwipeEnabled || !native.contentSwipeBack { return false }
             return !horizontalScrollAt(gestureRecognizer.location(in: view), in: top.view)
@@ -1533,7 +1657,6 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
             return false
         }
         if let native = nav.topViewController as? CraftNativeScreenController,
-           gestureRecognizer !== nav.interactivePopGestureRecognizer,
            nativeScreenContainsHorizontalScroll(native) {
             let moved = (gestureRecognizer as? UIPanGestureRecognizer)?.translation(in: nav.view).x ?? 0
             if gestureRecognizer.location(in: nav.view).x - moved > 32 { return false }