craft-native 0.0.162 → 0.0.164

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") }
@@ -68,11 +68,17 @@ enum CraftNativeActions {
         // A heart-rate strap is the app's own service (CraftHeartRate.swift),
         // so it needs no web view.
         if config.enableHeartRate { values.append("heartRate") }
+        // Workouts on the paired Apple Watch (CraftScheduledWorkouts.swift),
+        // also the app's own service.
+        if config.enableScheduledWorkouts { values.append("scheduledWorkouts") }
         // Photos picked from the library, files downloaded for the share
         // sheet and sent in a form (CraftNativeFiles.swift): the photo picker
         // 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
     }
@@ -187,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"):
@@ -338,6 +357,17 @@ enum CraftNativeActions {
                 complete(requestToken, result.mapError { CraftNativeActionError(code: $0.code, message: $0.message) }, completion)
             }
             return
+        case ("ScheduledWorkouts", _):
+            // Workouts on the paired Apple Watch, the same service as a
+            // page's `craft.scheduledWorkouts` (WorkoutKit's scheduler).
+            guard config.enableScheduledWorkouts else {
+                complete(requestToken, failure("CAPABILITY_DISABLED", "Scheduled workouts are disabled"), completion)
+                return
+            }
+            CraftScheduledWorkouts.shared.perform(method: method, args: args) { result in
+                complete(requestToken, result.mapError { CraftNativeActionError(code: $0.code, message: $0.message) }, completion)
+            }
+            return
         case ("Linking", "openURL"), ("Linking", "canOpenURL"):
             // Another app or the system: `webcal:` subscriptions, `mailto:`,
             // `tel:`, the App Store, this app's page in Settings
@@ -426,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)
@@ -600,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() }
@@ -906,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]
+    }
+}

package/dist/ios/templates/CraftNativeScreen.swift

@@ -341,8 +341,19 @@ private final class CraftNativeVideoView: UIView {
             detachPlayer()
             sourceURI = uri
             loops = false
-            guard let url = URL(string: uri), !uri.isEmpty, url.scheme != nil else {
+            // The copy `craft.media.keep` put on the phone plays in place of
+            // the address, so a kept video plays with no signal.
+            let kept = CraftNativeMedia.local(uri)
+            guard let url = kept ?? URL(string: uri), !uri.isEmpty, kept != nil || url.scheme != nil else {
                 playerController.player = nil
+                // A path with no scheme ("/videos/a.mp4") has nowhere to load
+                // from on a native screen. Say so rather than stay black.
+                if !uri.isEmpty {
+                    DispatchQueue.main.async { [weak self] in
+                        guard let self, self.sourceURI == uri else { return }
+                        self.fire("onError", ["message": "The video address is not a full URL: \(uri)"])
+                    }
+                }
                 return
             }
             let next = AVPlayer(url: url)
@@ -1110,6 +1121,10 @@ private class CraftNativeFlowView: UIStackView {
             }
             if start < items.count { lines.append(start..<items.count) }
         }
+        // Reconciliation reverses the child order for the requested main
+        // axis. A wrapped flex container must keep its lines in cross-axis
+        // order, so restore the groups without changing each line's order.
+        if reverse && wrap && lines.count > 1 { lines.reverse() }
 
         var lineMains: [CGFloat] = []
         var lineCrosses: [CGFloat] = []
@@ -1178,6 +1193,7 @@ private class CraftNativeFlowView: UIStackView {
             case "flex-end": 2
             case "space-between": 3
             case "space-around": 4
+            case "space-evenly": 6
             case "stretch": 5
             default: 0
             }
@@ -1374,6 +1390,9 @@ private class CraftNativeFlowView: UIStackView {
             case "space-around":
                 rowLeading = gridFree / CGFloat(rowHeights.count * 2)
                 rowBetween += gridFree / CGFloat(rowHeights.count)
+            case "space-evenly":
+                rowLeading = gridFree / CGFloat(rowHeights.count + 1)
+                rowBetween += gridFree / CGFloat(rowHeights.count + 1)
             case "stretch": rowExtra = gridFree / CGFloat(max(1, rowHeights.count))
             default: break
             }
@@ -1918,7 +1937,9 @@ private final class CraftNativeSvgView: UIView {
             if let fill = style["fill"] as? String ?? props["fill"] as? String { next.fill = fill }
             if let stroke = style["stroke"] as? String ?? props["stroke"] as? String { next.stroke = stroke }
             if let width = (style["strokeWidth"] as? NSNumber ?? props["strokeWidth"] as? NSNumber) { next.strokeWidth = CGFloat(truncating: width) }
-            if let opacity = props["opacity"] as? NSNumber ?? style["opacity"] as? NSNumber { next.opacity *= CGFloat(truncating: opacity) }
+            // Computed style wins over the component prop, matching Android
+            // and the browser's cascade when both provide opacity.
+            if let opacity = style["opacity"] as? NSNumber ?? props["opacity"] as? NSNumber { next.opacity *= CGFloat(truncating: opacity) }
             if let cap = props["strokeLinecap"] as? String { next.linecap = cap }
             if let join = props["strokeLinejoin"] as? String { next.linejoin = join }
             if let dashes = props["strokeDasharray"] as? [Any] { next.dashes = dashes.compactMap { ($0 as? NSNumber).map { CGFloat(truncating: $0) } } }
@@ -2705,7 +2726,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     /// - `craft.secureStorage.getSync(key)`: the Keychain item the web page's
     ///   `craft.secureStorage.set` wrote.
     /// - `craft.navigation.setOptions({ title, largeTitle, hidden, backTitle,
-    ///   rightButtons })`; a right button's tap is the event `navButton`.
+    ///   tabBarHidden, contentSwipeBack, tabSwipeEnabled, rightButtons })`; a right button's
+    ///   tap is the event `navButton`.
     ///
     /// A runtime that assigns `craft.storage` (or the others) afterwards keeps
     /// these: each namespace is a property whose setter adds them back to the
@@ -2949,6 +2971,13 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     private var navigationBarHidden: Bool?
     /// The app's tab bar away while this screen shows (`tabBarHidden`).
     private var tabBarHidden = false
+    /// Whether iOS 26's content-wide back-swipe may begin on this screen.
+    /// Setting `contentSwipeBack: false` leaves the 32-point edge gesture.
+    private(set) var contentSwipeBack = true
+    /// Whether the shell's horizontal tab switch gesture may begin here.
+    /// This is separate so a screen can keep navigation back while owning its
+    /// own horizontal pager or chart gesture.
+    private(set) var tabSwipeEnabled = true
     private var prefersLargeTitle: Bool?
 
     /// Whether this screen asked for a bar of its own through `setOptions`: a
@@ -2984,6 +3013,12 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                 CraftChrome.shared.setHiddenByScreen(hidden)
             }
         }
+        if let contentSwipeBack = options["contentSwipeBack"] as? Bool {
+            self.contentSwipeBack = contentSwipeBack
+        }
+        if let tabSwipeEnabled = options["tabSwipeEnabled"] as? Bool {
+            self.tabSwipeEnabled = tabSwipeEnabled
+        }
         if let hidden = options["hidden"] as? Bool {
             navigationBarHidden = hidden
             if navigationController?.topViewController === self {