craft-native 0.0.163 → 0.0.166

package/dist/ios/templates/CraftHybrid.swift

@@ -1004,6 +1004,8 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
     private var openingWeb = false
     private var firstFrameLogged = false
     private var tabBarHeight: CGFloat = 0
+    private var tabSwipeRecognizers: [UIGestureRecognizer] = []
+    private var activeTabSwipeTarget: String?
 
     init(config: CraftConfig) {
         self.config = config
@@ -1033,6 +1035,7 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
         let tabs = hybrid.tabIds
         let start = CraftHybridRoutes.tab(owning: hybrid.startPath, among: tabs) ?? tabs.first ?? ""
         show(tab: start, rootPath: hybrid.startPath)
+        installTabSwipeGestures()
         if hybrid.hasWeb && hybrid.startsNative {
             DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in self?.attachWeb() }
         }
@@ -1043,6 +1046,151 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
 
     private var webAttached = false
 
+    private func installTabSwipeGestures() {
+        guard tabSwipeRecognizers.isEmpty else { return }
+        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: UIPanGestureRecognizer) {
+        let tabs = hybrid.tabIds
+        guard let index = tabs.firstIndex(of: currentTab), tabs.count > 1 else { return }
+        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,
+               scroll.isScrollEnabled,
+               scroll.alwaysBounceHorizontal || scroll.contentSize.width > scroll.bounds.width + 1 {
+                return true
+            }
+            candidate = current.superview
+        }
+        return false
+    }
+
     /// The web view joins the screen, behind the native screens, and loads.
     private func attachWeb() {
         guard let webHost, !webAttached else { return }
@@ -1155,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)
@@ -1168,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
@@ -1295,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)
         }
@@ -1481,10 +1638,25 @@ 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)
+        }
         guard let nav = visibleStack, isPopRecognizer(gestureRecognizer),
               nav.viewControllers.count > 1, nav.transitionCoordinator == nil else { return false }
         if let native = nav.topViewController as? CraftNativeScreenController,
            gestureRecognizer !== nav.interactivePopGestureRecognizer,
+           !native.contentSwipeBack {
+            return false
+        }
+        if let native = nav.topViewController as? CraftNativeScreenController,
            nativeScreenContainsHorizontalScroll(native) {
             let moved = (gestureRecognizer as? UIPanGestureRecognizer)?.translation(in: nav.view).x ?? 0
             if gestureRecognizer.location(in: nav.view).x - moved > 32 { return false }

package/dist/ios/templates/CraftNativeActions.swift

@@ -40,7 +40,7 @@ enum CraftNativeActions {
     static func capabilities(config: CraftConfig) -> [String] {
         // `speech`, `audio` (background sound) and `eventStream` (a fetch read
         // as it arrives) need nothing the app has to declare.
-        var values = ["device", "clipboard", "haptics", "storage", "lifecycle", "fetch", "dialog", "speech", "audio", "eventStream", "linking"]
+        var values = ["device", "clipboard", "haptics", "storage", "lifecycle", "fetch", "dialog", "speech", "audio", "eventStream", "linking", "badge"]
         if config.enableBiometric { values.append("biometric") }
         if config.enableSecureStorage { values.append("secureStorage") }
         if config.enableLocalDatabase { values.append("database") }
@@ -76,6 +76,9 @@ enum CraftNativeActions {
         // runs out of process and asks no permission. Taking a photo needs
         // the camera, which the app declares.
         values.append("files")
+        // Video and audio kept on the phone for offline (CraftNativeMedia),
+        // which the native Video element plays in place of the address.
+        values.append("media")
         if config.enableCamera { values.append("camera") }
         return values
     }
@@ -190,6 +193,19 @@ enum CraftNativeActions {
             return
         case ("Files", "remove"):
             sync = .success(CraftNativeFiles.remove(args.first as? String ?? ""))
+        case ("Media", "keep"):
+            keepMedia(requestToken: requestToken, args: args, completion: completion)
+            return
+        case ("Media", "path"):
+            sync = .success(CraftNativeMedia.local(args.first as? String ?? "")?.path ?? NSNull())
+        case ("Media", "prune"):
+            let keep = (args.first as? [Any] ?? []).compactMap { $0 as? String }
+            DispatchQueue.global(qos: .utility).async {
+                complete(requestToken, .success(CraftNativeMedia.prune(keep: keep)), completion)
+            }
+            return
+        case ("Media", "usage"):
+            sync = .success(CraftNativeMedia.usage())
         case ("Lifecycle", "getState"):
             sync = .success(currentAppState())
         case ("DeepLinks", "getInitialURL"):
@@ -440,6 +456,19 @@ enum CraftNativeActions {
                 complete(requestToken, .success(true), completion)
             }
             return
+        case ("Badge", "set"):
+            guard let value = args.first as? NSNumber,
+                  value.doubleValue.isFinite,
+                  value.doubleValue >= 0,
+                  value.doubleValue.rounded() == value.doubleValue else {
+                complete(requestToken, failure("INVALID_ARGUMENT", "Badge.set needs a non-negative whole number"), completion)
+                return
+            }
+            setBadgeCount(value.intValue) { complete(requestToken, $0, completion) }
+            return
+        case ("Badge", "clear"):
+            setBadgeCount(0) { complete(requestToken, $0, completion) }
+            return
         case ("Notifications", _):
             guard config.enableLocalNotifications else {
                 complete(requestToken, failure("CAPABILITY_DISABLED", "Local notifications are disabled"), completion)
@@ -614,6 +643,63 @@ enum CraftNativeActions {
         if !alreadyCancelled { task.resume() }
     }
 
+    /// `craft.media.keep`: the file at an address kept on the phone for
+    /// offline, fetched once (a copy already there answers at once, and two
+    /// screens asking at the same time share one download). A refused answer
+    /// (not 2xx) keeps nothing and says its status. Cancelled like fetch.
+    private static func keepMedia(
+        requestToken: String,
+        args: [Any],
+        completion: @escaping (Result<Any, CraftNativeActionError>) -> Void
+    ) {
+        guard let address = args.first as? String,
+              let url = URL(string: address),
+              let scheme = url.scheme?.lowercased(), scheme == "https" || scheme == "http",
+              url.host?.isEmpty == false else {
+            complete(requestToken, failure("INVALID_ARGUMENT", "media.keep needs an absolute http or https URL"), completion)
+            return
+        }
+        if let kept = CraftNativeMedia.local(address) {
+            complete(requestToken, .success(CraftNativeMedia.describe(address, kept)), completion)
+            return
+        }
+        let options = args.count > 1 ? args[1] as? [String: Any] ?? [:] : [:]
+        var request = URLRequest(url: url, timeoutInterval: craftNativeFetchTimeoutSeconds)
+        request.httpMethod = "GET"
+        if let headers = options["headers"] as? [String: Any] {
+            for (name, value) in headers {
+                guard let value = value as? String else {
+                    complete(requestToken, failure("INVALID_ARGUMENT", "media.keep header values must be strings"), completion)
+                    return
+                }
+                request.setValue(value, forHTTPHeaderField: name)
+            }
+        }
+        if CraftNativeMedia.join(address, { complete(requestToken, $0, completion) }) { return }
+        let task = fetchSession.downloadTask(with: request) { location, response, error in
+            cancellationLock.lock()
+            fetchTasks.removeValue(forKey: requestToken)
+            cancellationLock.unlock()
+            if let error = error {
+                let code = (error as? URLError)?.code == .timedOut ? "TIMEOUT" : "NETWORK_ERROR"
+                CraftNativeMedia.finish(address, failure(code, error.localizedDescription))
+                return
+            }
+            guard let http = response as? HTTPURLResponse, let location else {
+                CraftNativeMedia.finish(address, failure("NETWORK_ERROR", "media.keep received a response that is not HTTP"))
+                return
+            }
+            // The system deletes `location` once this returns: move it now.
+            CraftNativeMedia.finish(address, CraftNativeMedia.store(address, at: location, response: http))
+        }
+        cancellationLock.lock()
+        let alreadyCancelled = cancelledRequests.contains(requestToken)
+        if !alreadyCancelled { fetchTasks[requestToken] = task }
+        cancellationLock.unlock()
+        if alreadyCancelled { CraftNativeMedia.finish(address, failure("CANCELLED", "media.keep was cancelled")) }
+        else { task.resume() }
+    }
+
     private static func claimInitialDeepLink() -> URL? {
         cancellationLock.lock()
         defer { cancellationLock.unlock() }
@@ -920,6 +1006,30 @@ enum CraftNativeActions {
         }
     }
 
+    /// Set the app icon badge without requesting notification authorization.
+    /// Native screens use this same permission-free path as the page bridge.
+    private static func setBadgeCount(
+        _ count: Int,
+        completion: @escaping (Result<Any, CraftNativeActionError>) -> Void
+    ) {
+        DispatchQueue.main.async {
+            if #available(iOS 16.0, *) {
+                UNUserNotificationCenter.current().setBadgeCount(count) { error in
+                    DispatchQueue.main.async {
+                        if let error {
+                            completion(.failure(CraftNativeActionError(code: "NATIVE_CALL_FAILED", message: error.localizedDescription)))
+                        } else {
+                            completion(.success(true))
+                        }
+                    }
+                }
+            } else {
+                UIApplication.shared.applicationIconBadgeNumber = count
+                completion(.success(true))
+            }
+        }
+    }
+
     static func deepLinkData(_ url: URL) -> [String: Any] {
         let components = URLComponents(url: url, resolvingAgainstBaseURL: false)
         return [

package/dist/ios/templates/CraftNativeFiles.swift

@@ -1,3 +1,4 @@
+import CryptoKit
 import Foundation
 import ImageIO
 import PhotosUI
@@ -375,3 +376,109 @@ enum CraftNativeFiles {
         return ["ok": false, "status": response.statusCode, "body": text]
     }
 }
+
+// `craft.media` on a native screen: video and audio kept on the phone for
+// when there is no signal (a gym's basement, a plane). Not tmp/craft-files,
+// which iOS and the sweep above both empty: Application Support/craft-media,
+// left out of iCloud backups because every file can be fetched again. A file
+// is named by its address's SHA-256, so the native `Video` element finds the
+// copy of the URL it was given and plays it instead, with no lookup in
+// JavaScript. The screen decides what to keep (`keep`) and what to drop
+// (`prune`); nothing is evicted behind its back.
+enum CraftNativeMedia {
+    static var root: URL {
+        let base = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first
+            ?? FileManager.default.temporaryDirectory
+        return base.appendingPathComponent("craft-media", isDirectory: true)
+    }
+
+    private static let lock = NSLock()
+    /// Addresses being fetched now, so a second `keep` waits for the first.
+    private static var inFlight: [String: [(Result<Any, CraftNativeActionError>) -> Void]] = [:]
+
+    /// Where `address`'s copy lives (whether or not it is there yet). The
+    /// extension is the address's, because AVPlayer reads the type from it.
+    static func file(for address: String) -> URL {
+        let digest = SHA256.hash(data: Data(address.utf8)).map { String(format: "%02x", $0) }.joined()
+        let ext = URL(string: address)?.pathExtension.lowercased() ?? ""
+        let safe = ext.range(of: "^[a-z0-9]{1,5}$", options: .regularExpression) != nil ? ext : "bin"
+        return root.appendingPathComponent("\(digest).\(safe)")
+    }
+
+    /// The copy of `address` on this phone, or nil.
+    static func local(_ address: String) -> URL? {
+        guard !address.isEmpty else { return nil }
+        let url = file(for: address)
+        return FileManager.default.fileExists(atPath: url.path) ? url : nil
+    }
+
+    static func describe(_ address: String, _ url: URL) -> [String: Any] {
+        let size = (try? url.resourceValues(forKeys: [.fileSizeKey]).fileSize) ?? 0
+        return ["ok": true, "url": address, "path": url.path, "size": size]
+    }
+
+    /// Joins a fetch of `address` already under way; true when one was.
+    static func join(_ address: String, _ done: @escaping (Result<Any, CraftNativeActionError>) -> Void) -> Bool {
+        lock.lock()
+        defer { lock.unlock() }
+        if inFlight[address] != nil {
+            inFlight[address]!.append(done)
+            return true
+        }
+        inFlight[address] = [done]
+        return false
+    }
+
+    static func finish(_ address: String, _ result: Result<Any, CraftNativeActionError>) {
+        lock.lock()
+        let waiting = inFlight.removeValue(forKey: address) ?? []
+        lock.unlock()
+        for done in waiting { done(result) }
+    }
+
+    /// A finished download moved into place (atomically, so a half-written
+    /// file is never played), or a refusal with the server's status.
+    static func store(_ address: String, at location: URL, response: HTTPURLResponse) -> Result<Any, CraftNativeActionError> {
+        guard (200..<300).contains(response.statusCode) else {
+            return .success(["ok": false, "url": address, "status": response.statusCode])
+        }
+        let fm = FileManager.default
+        do {
+            var folder = root
+            if !fm.fileExists(atPath: folder.path) {
+                try fm.createDirectory(at: folder, withIntermediateDirectories: true)
+                var values = URLResourceValues()
+                values.isExcludedFromBackup = true
+                try? folder.setResourceValues(values)
+            }
+            let target = file(for: address)
+            let staging = root.appendingPathComponent(UUID().uuidString + ".part")
+            try fm.moveItem(at: location, to: staging)
+            _ = try? fm.removeItem(at: target)
+            try fm.moveItem(at: staging, to: target)
+            return .success(describe(address, target))
+        }
+        catch {
+            return .failure(CraftNativeActionError(code: "IO_ERROR", message: "media.keep could not store the file: \(error.localizedDescription)"))
+        }
+    }
+
+    /// Removes every copy whose address is not in `keep`; answers how many.
+    static func prune(keep: [String]) -> Int {
+        let wanted = Set(keep.map { file(for: $0).lastPathComponent })
+        let files = (try? FileManager.default.contentsOfDirectory(at: root, includingPropertiesForKeys: nil)) ?? []
+        var removed = 0
+        for url in files where !wanted.contains(url.lastPathComponent) {
+            if (try? FileManager.default.removeItem(at: url)) != nil { removed += 1 }
+        }
+        return removed
+    }
+
+    /// What the kept copies come to, in bytes, and how many there are.
+    static func usage() -> [String: Any] {
+        let files = (try? FileManager.default.contentsOfDirectory(at: root, includingPropertiesForKeys: [.fileSizeKey])) ?? []
+        let kept = files.filter { $0.pathExtension != "part" }
+        let bytes = kept.reduce(0) { $0 + ((try? $1.resourceValues(forKeys: [.fileSizeKey]).fileSize) ?? 0) }
+        return ["files": kept.count, "bytes": bytes]
+    }
+}