craft-native 0.0.124 → 0.0.125

package/dist/ios/templates/CraftNativeActions.swift

@@ -6,6 +6,11 @@ import UIKit
 import UserNotifications
 
 let craftNativeCapabilityProtocolVersion = 1
+/// URLSession's own request timeout, matching the bridge's 30-second deadline.
+let craftNativeFetchTimeoutSeconds: TimeInterval = 30
+/// A response body larger than this rejects with RESPONSE_TOO_LARGE rather
+/// than being copied into JavaScriptCore as one string.
+let craftNativeFetchMaxResponseBytes = 8 * 1024 * 1024
 
 struct CraftNativeActionError: Error {
     let code: String
@@ -21,12 +26,19 @@ enum CraftNativeActions {
     private static let cancellationLock = NSLock()
     private static var cancelledRequests = Set<String>()
     private static var biometricContexts = [String: LAContext]()
+    private static var fetchTasks = [String: URLSessionDataTask]()
+    private static let fetchSession: URLSession = {
+        let configuration = URLSessionConfiguration.default
+        configuration.timeoutIntervalForRequest = craftNativeFetchTimeoutSeconds
+        configuration.timeoutIntervalForResource = craftNativeFetchTimeoutSeconds
+        return URLSession(configuration: configuration)
+    }()
     private static var initialDeepLinkClaimed = false
     private static var database: OpaquePointer?
     private static let sqliteTransient = unsafeBitCast(-1, to: sqlite3_destructor_type.self)
 
     static func capabilities(config: CraftConfig) -> [String] {
-        var values = ["device", "clipboard", "haptics", "storage", "lifecycle"]
+        var values = ["device", "clipboard", "haptics", "storage", "lifecycle", "fetch"]
         if config.enableBiometric { values.append("biometric") }
         if config.enableSecureStorage { values.append("secureStorage") }
         if config.enableLocalDatabase { values.append("database") }
@@ -115,6 +127,9 @@ enum CraftNativeActions {
             }
             authenticate(requestToken: requestToken, args: args, completion: completion)
             return
+        case ("Network", "fetch"):
+            fetch(requestToken: requestToken, args: args, completion: completion)
+            return
         case ("Lifecycle", "getState"):
             sync = .success(currentAppState())
         case ("DeepLinks", "getInitialURL"):
@@ -147,8 +162,91 @@ enum CraftNativeActions {
         cancellationLock.lock()
         cancelledRequests.insert(requestToken)
         let context = biometricContexts.removeValue(forKey: requestToken)
+        let task = fetchTasks.removeValue(forKey: requestToken)
         cancellationLock.unlock()
         context?.invalidate()
+        task?.cancel()
+    }
+
+    /// `fetch` for native screens: one URLSession data task per request, keyed
+    /// by the request token so the bridge deadline, `API_CANCEL` and route
+    /// teardown all cancel the transfer. Bodies are UTF-8 text both ways.
+    private static func fetch(
+        requestToken: String,
+        args: [Any],
+        completion: @escaping (Result<Any, CraftNativeActionError>) -> Void
+    ) {
+        guard let options = args.first as? [String: Any],
+              let address = options["url"] 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", "fetch needs an absolute http or https URL"), completion)
+            return
+        }
+        let method = ((options["method"] as? String) ?? "GET").uppercased()
+        guard !method.isEmpty, method.allSatisfy({ $0.isLetter && $0.isASCII }) else {
+            complete(requestToken, failure("INVALID_ARGUMENT", "fetch method must be an HTTP token"), completion)
+            return
+        }
+        var request = URLRequest(url: url, timeoutInterval: craftNativeFetchTimeoutSeconds)
+        request.httpMethod = method
+        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", "fetch header values must be strings"), completion)
+                    return
+                }
+                request.setValue(value, forHTTPHeaderField: name)
+            }
+        }
+        if let body = options["body"] as? String {
+            guard method != "GET", method != "HEAD" else {
+                complete(requestToken, failure("INVALID_ARGUMENT", "A GET or HEAD request cannot have a body"), completion)
+                return
+            }
+            request.httpBody = Data(body.utf8)
+        } else if let body = options["body"], !(body is NSNull) {
+            complete(requestToken, failure("INVALID_ARGUMENT", "fetch body must be a string"), completion)
+            return
+        }
+
+        let task = fetchSession.dataTask(with: request) { data, 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"
+                complete(requestToken, failure(code, error.localizedDescription), completion)
+                return
+            }
+            guard let http = response as? HTTPURLResponse else {
+                complete(requestToken, failure("NETWORK_ERROR", "fetch received a response that is not HTTP"), completion)
+                return
+            }
+            let body = data ?? Data()
+            guard body.count <= craftNativeFetchMaxResponseBytes else {
+                complete(requestToken, failure("RESPONSE_TOO_LARGE", "fetch responses are limited to \(craftNativeFetchMaxResponseBytes) bytes"), completion)
+                return
+            }
+            var headers: [String: String] = [:]
+            for (name, value) in http.allHeaderFields {
+                headers[String(describing: name).lowercased()] = String(describing: value)
+            }
+            complete(requestToken, .success([
+                "url": http.url?.absoluteString ?? address,
+                "status": http.statusCode,
+                "statusText": HTTPURLResponse.localizedString(forStatusCode: http.statusCode),
+                "headers": headers,
+                "redirected": http.url.map { $0 != url } ?? false,
+                "body": String(decoding: body, as: UTF8.self),
+            ]), completion)
+        }
+        cancellationLock.lock()
+        let alreadyCancelled = cancelledRequests.contains(requestToken)
+        if !alreadyCancelled { fetchTasks[requestToken] = task }
+        cancellationLock.unlock()
+        if !alreadyCancelled { task.resume() }
     }
 
     private static func claimInitialDeepLink() -> URL? {
@@ -535,6 +633,120 @@ enum CraftNativeActions {
     }
 }
 
+// MARK: - Synchronous reads for a screen's first frame
+
+extension CraftNativeActions {
+    /// The JSON text `craft.storage` keeps under `key`, or nil. The same store
+    /// as the asynchronous Storage module, read without a bridge round trip.
+    static func storageJSON(forKey key: String) -> String? {
+        guard let key = validKey(key), let data = UserDefaults.standard.data(forKey: storagePrefix + key) else { return nil }
+        return String(decoding: data, as: UTF8.self)
+    }
+
+    /// Stores JSON text under `key` (nil removes it). False for an invalid key
+    /// or text that is not JSON, which the asynchronous `get` could not read.
+    @discardableResult
+    static func setStorageJSON(_ json: String?, forKey key: String) -> Bool {
+        guard let key = validKey(key) else { return false }
+        guard let json else {
+            UserDefaults.standard.removeObject(forKey: storagePrefix + key)
+            return true
+        }
+        let data = Data(json.utf8)
+        guard (try? JSONSerialization.jsonObject(with: data, options: [.fragmentsAllowed])) != nil else { return false }
+        UserDefaults.standard.set(data, forKey: storagePrefix + key)
+        return true
+    }
+
+    /// The Keychain item the web page's `craft.secureStorage` wrote under
+    /// `key`: a generic password whose account is the key, as CraftApp's
+    /// `secureStore` writes it. Nil when there is none.
+    static func webSecureValue(forKey key: String) -> String? {
+        guard let key = validKey(key) else { return nil }
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrAccount as String: key,
+            kSecReturnData as String: true,
+            kSecMatchLimit as String: kSecMatchLimitOne,
+        ]
+        var result: AnyObject?
+        guard SecItemCopyMatching(query as CFDictionary, &result) == errSecSuccess, let data = result as? Data else { return nil }
+        return String(data: data, encoding: .utf8)
+    }
+}
+
+/// Last-known data for a screen's first frame: one JSON file per name in
+/// `Application Support/craft-snapshots/<name>.json`. A web page writes them
+/// (`snapshots.set` in the mobile API) and a native screen reads them
+/// synchronously before its first render, or writes its own.
+enum CraftSnapshots {
+    private static let queue = DispatchQueue(label: "dev.craft.snapshots", qos: .utility)
+    private static let lock = NSLock()
+    /// Writes not on disk yet, so a read right after a write sees it.
+    private static var pending: [String: String?] = [:]
+
+    static var directory: URL? {
+        FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first?
+            .appendingPathComponent("craft-snapshots", isDirectory: true)
+    }
+
+    /// Letters, digits, `-`, `_` and `.`, not starting with a dot: a file
+    /// name, never a path.
+    static func isValidName(_ name: String) -> Bool {
+        !name.isEmpty && name.count <= 128 && !name.hasPrefix(".")
+            && name.unicodeScalars.allSatisfy { $0.isASCII && (CharacterSet.alphanumerics.contains($0) || "-_.".unicodeScalars.contains($0)) }
+    }
+
+    static func url(for name: String) -> URL? {
+        guard isValidName(name) else { return nil }
+        return directory?.appendingPathComponent("\(name).json", isDirectory: false)
+    }
+
+    /// The snapshot's JSON text, or nil.
+    static func read(_ name: String) -> String? {
+        guard let url = url(for: name) else { return nil }
+        lock.lock()
+        let waiting = pending[name]
+        lock.unlock()
+        if let waiting { return waiting }
+        guard let data = try? Data(contentsOf: url) else { return nil }
+        return String(decoding: data, as: UTF8.self)
+    }
+
+    /// Replaces the snapshot with JSON text (nil deletes it) off the main
+    /// thread, atomically. `completion` runs on the main queue.
+    static func write(_ name: String, json: String?, completion: ((Bool) -> Void)? = nil) {
+        guard let url = url(for: name), let directory else {
+            DispatchQueue.main.async { completion?(false) }
+            return
+        }
+        if let json, (try? JSONSerialization.jsonObject(with: Data(json.utf8), options: [.fragmentsAllowed])) == nil {
+            DispatchQueue.main.async { completion?(false) }
+            return
+        }
+        lock.lock()
+        pending[name] = .some(json)
+        lock.unlock()
+        queue.async {
+            var ok = true
+            do {
+                if let json {
+                    try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+                    try Data(json.utf8).write(to: url, options: [.atomic])
+                } else if FileManager.default.fileExists(atPath: url.path) {
+                    try FileManager.default.removeItem(at: url)
+                }
+            } catch {
+                ok = false
+            }
+            lock.lock()
+            if let current = pending[name], current == json { pending.removeValue(forKey: name) }
+            lock.unlock()
+            DispatchQueue.main.async { completion?(ok) }
+        }
+    }
+}
+
 /// The Taptic Engine's generators, held for the life of the process.
 ///
 /// Each haptic used to make a fresh generator at the moment of the tap. A new

package/dist/ios/templates/CraftNativeFlatList.swift

@@ -9,10 +9,10 @@ private final class CraftNativeFlatListLayout: UICollectionViewFlowLayout {
     }
 }
 
-/// A keyed, recycling native list used by the stx-native FlatList primitive.
+/// A keyed, recycling native list used by stx's native FlatList primitive.
 /// The screen controller owns rendered row state; this view owns collection
 /// diffs, viewport state, and UICollectionView cell reuse.
-final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowLayout {
+final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowLayout, UIGestureRecognizerDelegate {
     typealias RenderItem = (_ node: [String: Any], _ identity: String, _ previous: UIView?) -> UIView
 
     private final class Cell: UICollectionViewCell {
@@ -21,6 +21,9 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
         private(set) var representedIdentity: String?
         private(set) var hostedView: UIView?
         var onRecycle: ((String) -> Void)?
+        /// The width (or, sideways, height) the list gives this row, so a row
+        /// is measured at the list's width rather than the layout's estimate.
+        var fittingExtent: CGFloat?
 
         override func prepareForReuse() {
             super.prepareForReuse()
@@ -63,24 +66,25 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
             if let collectionView = ancestor as? UICollectionView,
                let flowLayout = collectionView.collectionViewLayout as? UICollectionViewFlowLayout,
                flowLayout.scrollDirection == .horizontal {
-                let target = CGSize(
-                    width: UIView.layoutFittingCompressedSize.width,
-                    height: layoutAttributes.size.height
+                let height = fittingExtent ?? layoutAttributes.size.height
+                let measured = CraftNativeFlexLayout.measure(
+                    hostedView,
+                    width: nil,
+                    height: height,
+                    maxWidth: CraftNativeFlexLayout.unbounded,
+                    maxHeight: height
                 )
-                let measured = hostedView.systemLayoutSizeFitting(
-                    target,
-                    withHorizontalFittingPriority: .fittingSizeLevel,
-                    verticalFittingPriority: .required
-                )
-                attributes.size.width = max(1, measured.width)
+                attributes.size = CGSize(width: max(1, ceil(measured.width)), height: max(1, height))
             } else {
-                let target = CGSize(width: layoutAttributes.size.width, height: UIView.layoutFittingCompressedSize.height)
-                let measured = hostedView.systemLayoutSizeFitting(
-                    target,
-                    withHorizontalFittingPriority: .required,
-                    verticalFittingPriority: .fittingSizeLevel
+                let width = fittingExtent ?? layoutAttributes.size.width
+                let measured = CraftNativeFlexLayout.measure(
+                    hostedView,
+                    width: width,
+                    height: nil,
+                    maxWidth: width,
+                    maxHeight: CraftNativeFlexLayout.unbounded
                 )
-                attributes.size.height = max(1, measured.height)
+                attributes.size = CGSize(width: max(1, width), height: max(1, ceil(measured.height)))
             }
             return attributes
         }
@@ -119,6 +123,10 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
     private var isApplyingSnapshot = false
     private var pendingApply: (() -> Void)?
     private var pendingThemeRefresh = false
+    private let nativeRefreshControl = UIRefreshControl()
+    private var refreshHandler: (() -> Void)?
+    private let keyboardTapGesture = UITapGestureRecognizer()
+    private var keyboardShouldPersistTaps = "never"
 
     init() {
         let layout = CraftNativeFlatListLayout()
@@ -130,7 +138,12 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
         backgroundColor = .clear
         alwaysBounceVertical = true
         delegate = self
+        keyboardTapGesture.cancelsTouchesInView = false
+        keyboardTapGesture.delegate = self
+        keyboardTapGesture.addTarget(self, action: #selector(keyboardTap))
+        addGestureRecognizer(keyboardTapGesture)
         register(Cell.self, forCellWithReuseIdentifier: Cell.reuseIdentifier)
+        nativeRefreshControl.addTarget(self, action: #selector(refreshTriggered), for: .valueChanged)
         diffableDataSource = UICollectionViewDiffableDataSource<Int, String>(collectionView: self) {
             [weak self] collectionView, indexPath, identity in
             guard let self = self,
@@ -142,6 +155,7 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
                   let renderItem = self.renderItem else { return UICollectionViewCell() }
             let view = renderItem(item.node, identity, cell.hostedView)
             cell.onRecycle = self.recycleItem
+            cell.fittingExtent = self.itemExtent(isChrome: item.isChrome)
             cell.host(view, identity: identity)
             return cell
         }
@@ -149,6 +163,123 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
 
     required init?(coder: NSCoder) { nil }
 
+    /// Called when a list that does not scroll changes height, so the
+    /// containers around it make room.
+    var onFittingHeightChanged: (() -> Void)?
+
+    override var contentSize: CGSize {
+        didSet {
+            guard !isScrollEnabled, abs(oldValue.height - contentSize.height) > 0.5 else { return }
+            invalidateIntrinsicContentSize()
+            onFittingHeightChanged?()
+        }
+    }
+
+    override var isScrollEnabled: Bool {
+        didSet {
+            guard isScrollEnabled != oldValue else { return }
+            alwaysBounceVertical = isScrollEnabled && flowLayout.scrollDirection == .vertical
+            onFittingHeightChanged?()
+        }
+    }
+
+    /// The height of every row at `width`: what a list that does not scroll
+    /// (`scrollEnabled={false}`) takes inside a scroll view or a column.
+    /// Rows not measured yet count at their estimate, and the list asks for
+    /// room again as they are.
+    func fittingHeight(width: CGFloat) -> CGFloat {
+        guard !isScrollEnabled else { return 0 }
+        if abs(bounds.width - width) > 0.5 { frame.size.width = width }
+        layoutIfNeeded()
+        let content = flowLayout.collectionViewContentSize.height
+        return max(0, ceil(content + contentInset.top + contentInset.bottom))
+    }
+
+    /// The width a row gets: the list's own width inside its content padding,
+    /// shared between columns for data rows.
+    private func itemExtent(isChrome: Bool) -> CGFloat {
+        if flowLayout.scrollDirection == .horizontal {
+            return max(1, bounds.height - adjustedContentInset.top - adjustedContentInset.bottom)
+        }
+        let width = max(1, bounds.width - adjustedContentInset.left - adjustedContentInset.right)
+        let count = isChrome ? 1 : columns
+        let spacing = flowLayout.minimumInteritemSpacing * CGFloat(count - 1)
+        return max(1, (width - spacing) / CGFloat(count))
+    }
+
+    override func layoutSubviews() {
+        let estimate = flowLayout.scrollDirection == .horizontal
+            ? CGSize(width: 44, height: itemExtent(isChrome: true))
+            : CGSize(width: itemExtent(isChrome: false), height: 44)
+        if flowLayout.estimatedItemSize != estimate, bounds.width > 0 {
+            flowLayout.estimatedItemSize = estimate
+        }
+        super.layoutSubviews()
+        craftApplyCornerRadius()
+    }
+
+    func setContentContainerStyle(_ raw: [String: Any]?) {
+        func number(_ value: Any?) -> CGFloat? { (value as? NSNumber).map { CGFloat(truncating: $0) } }
+        let padding = number(raw?["padding"]) ?? 0
+        let horizontal = number(raw?["paddingHorizontal"]) ?? padding
+        let vertical = number(raw?["paddingVertical"]) ?? padding
+        contentInset = UIEdgeInsets(
+            top: number(raw?["paddingTop"]) ?? vertical,
+            left: number(raw?["paddingLeft"]) ?? horizontal,
+            bottom: number(raw?["paddingBottom"]) ?? vertical,
+            right: number(raw?["paddingRight"]) ?? horizontal
+        )
+        scrollIndicatorInsets = contentInset
+        collectionViewLayout.invalidateLayout()
+    }
+
+    func setKeyboardShouldPersistTaps(_ value: Any?) {
+        let requested = value as? String
+        keyboardShouldPersistTaps = ["always", "handled", "never"].contains(requested) ? requested! : "never"
+        keyboardTapGesture.isEnabled = keyboardShouldPersistTaps != "always"
+    }
+
+    private var refreshingProp = false
+
+    /// `onRefresh` and `refreshing`, controlled as in React Native: a pull
+    /// the screen does not answer with `refreshing` true ends at once.
+    func setRefreshHandler(_ handler: (() -> Void)?, refreshing: Bool) {
+        refreshHandler = handler
+        refreshingProp = refreshing
+        let control = handler == nil ? nil : nativeRefreshControl
+        if refreshControl !== control { refreshControl = control }
+        if handler == nil || !refreshing {
+            if nativeRefreshControl.isRefreshing { nativeRefreshControl.endRefreshing() }
+        } else if !nativeRefreshControl.isRefreshing {
+            nativeRefreshControl.beginRefreshing()
+        }
+    }
+
+    @objc private func refreshTriggered() {
+        refreshHandler?()
+        DispatchQueue.main.async { [weak self] in
+            guard let self, !self.refreshingProp, self.nativeRefreshControl.isRefreshing else { return }
+            self.nativeRefreshControl.endRefreshing()
+        }
+    }
+
+    @objc private func keyboardTap() {
+        guard keyboardShouldPersistTaps != "always" else { return }
+        if keyboardShouldPersistTaps == "handled" {
+            let point = keyboardTapGesture.location(in: self)
+            var hit = hitTest(point, with: nil)
+            while let view = hit, view !== self {
+                if view is UIControl || !(view.gestureRecognizers ?? []).isEmpty { return }
+                hit = view.superview
+            }
+        }
+        window?.endEditing(true)
+    }
+
+    func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer) -> Bool {
+        true
+    }
+
     var visibleItemIdentities: [String] {
         indexPathsForVisibleItems
             .sorted { $0.item < $1.item }
@@ -320,11 +451,9 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
         guard items.indices.contains(indexPath.item) else { return CGSize(width: bounds.width, height: 44) }
         let item = items[indexPath.item]
         if flowLayout.scrollDirection == .horizontal {
-            return CGSize(width: 44, height: max(1, bounds.height))
+            return CGSize(width: 44, height: itemExtent(isChrome: item.isChrome))
         }
-        let count = item.isChrome ? 1 : columns
-        let spacing = flowLayout.minimumInteritemSpacing * CGFloat(count - 1)
-        return CGSize(width: max(1, (bounds.width - spacing) / CGFloat(count)), height: 44)
+        return CGSize(width: itemExtent(isChrome: item.isChrome), height: 44)
     }
 
     private func evaluateEndReached() {