craft-native 0.0.123 → 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") }
@@ -44,6 +56,10 @@ enum CraftNativeActions {
             guard config.enableHaptics else { return failure("CAPABILITY_DISABLED", "Haptics is disabled") }
             triggerHaptic(style: body["style"] as? String ?? "medium")
             return .success(true)
+        case "hapticPrepare":
+            guard config.enableHaptics else { return failure("CAPABILITY_DISABLED", "Haptics is disabled") }
+            CraftHaptics.prepare(body["kind"] as? String)
+            return .success(true)
         case "clipboardWrite":
             guard config.enableClipboard else { return failure("CAPABILITY_DISABLED", "Clipboard is disabled") }
             guard let text = body["text"] as? String else {
@@ -82,6 +98,12 @@ enum CraftNativeActions {
             sync = perform(action: "getDeviceInfo", body: [:], config: config)
         case ("Haptics", "impact"):
             sync = perform(action: "haptic", body: ["style": args.first ?? NSNull()], config: config)
+        case ("Haptics", "notification"):
+            sync = perform(action: "haptic", body: ["style": (args.first as? String) ?? "success"], config: config)
+        case ("Haptics", "selection"):
+            sync = perform(action: "haptic", body: ["style": "selection"], config: config)
+        case ("Haptics", "prepare"):
+            sync = perform(action: "hapticPrepare", body: ["kind": args.first ?? NSNull()], config: config)
         case ("Clipboard", "write"):
             sync = perform(action: "clipboardWrite", body: ["text": args.first ?? NSNull()], config: config)
         case ("Clipboard", "read"):
@@ -105,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"):
@@ -137,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? {
@@ -460,15 +568,7 @@ enum CraftNativeActions {
     }
 
     static func triggerHaptic(style: String) {
-        switch style {
-        case "light": UIImpactFeedbackGenerator(style: .light).impactOccurred()
-        case "heavy": UIImpactFeedbackGenerator(style: .heavy).impactOccurred()
-        case "success": UINotificationFeedbackGenerator().notificationOccurred(.success)
-        case "warning": UINotificationFeedbackGenerator().notificationOccurred(.warning)
-        case "error": UINotificationFeedbackGenerator().notificationOccurred(.error)
-        case "selection": UISelectionFeedbackGenerator().selectionChanged()
-        default: UIImpactFeedbackGenerator(style: .medium).impactOccurred()
-        }
+        CraftHaptics.play(style)
     }
 
     static func currentAppState() -> String {
@@ -532,3 +632,203 @@ 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
+/// generator has to wake the engine before it can play, which is the tens of
+/// milliseconds between a finger landing and the feel that makes web haptics
+/// read as late. These are made once, prepared again after every use, and
+/// `prepare` lets a page warm one before a gesture it knows is coming (the
+/// start of a drag, a long press about to complete).
+///
+/// The three kinds are the three UIKit has, and they are not interchangeable:
+/// a notification is the success, warning or error pattern, a selection is the
+/// detent a picker plays, and an impact is a single tap at one of five weights.
+/// The page used to get impacts for all of them.
+///
+/// Main thread only, like every UIFeedbackGenerator. Every caller is.
+enum CraftHaptics {
+    private static var impacts: [UIImpactFeedbackGenerator.FeedbackStyle: UIImpactFeedbackGenerator] = [:]
+    private static var notifier: UINotificationFeedbackGenerator?
+    private static var selector: UISelectionFeedbackGenerator?
+
+    /// An impact weight by name, or nil for a name that is not one.
+    static func impactStyle(_ name: String) -> UIImpactFeedbackGenerator.FeedbackStyle? {
+        switch name {
+        case "light": return .light
+        case "medium": return .medium
+        case "heavy": return .heavy
+        case "soft": return .soft
+        case "rigid": return .rigid
+        default: return nil
+        }
+    }
+
+    /// Play one haptic: an impact weight, a notification type, or `selection`.
+    /// Anything else plays a medium impact, as an unknown style always has.
+    static func play(_ style: String) {
+        switch style {
+        case "success": notification().notificationOccurred(.success); notification().prepare()
+        case "warning": notification().notificationOccurred(.warning); notification().prepare()
+        case "error": notification().notificationOccurred(.error); notification().prepare()
+        case "selection": selection().selectionChanged(); selection().prepare()
+        default:
+            let generator = impact(impactStyle(style) ?? .medium)
+            generator.impactOccurred()
+            generator.prepare()
+        }
+    }
+
+    /// Warm a generator so the next haptic plays without the engine's wake-up
+    /// delay. `impact`, `notification` or `selection` for one kind, an impact
+    /// weight or notification type for that one, nothing for all of them.
+    /// UIKit keeps a prepared engine awake for a few seconds only.
+    static func prepare(_ kind: String?) {
+        switch kind {
+        case "impact": impact(.medium).prepare()
+        case "notification", "success", "warning", "error": notification().prepare()
+        case "selection": selection().prepare()
+        case let name? where impactStyle(name) != nil: impact(impactStyle(name)!).prepare()
+        default:
+            impact(.medium).prepare()
+            notification().prepare()
+            selection().prepare()
+        }
+    }
+
+    private static func impact(_ style: UIImpactFeedbackGenerator.FeedbackStyle) -> UIImpactFeedbackGenerator {
+        if let generator = impacts[style] { return generator }
+        let generator = UIImpactFeedbackGenerator(style: style)
+        impacts[style] = generator
+        return generator
+    }
+
+    private static func notification() -> UINotificationFeedbackGenerator {
+        if let notifier { return notifier }
+        let generator = UINotificationFeedbackGenerator()
+        notifier = generator
+        return generator
+    }
+
+    private static func selection() -> UISelectionFeedbackGenerator {
+        if let selector { return selector }
+        let generator = UISelectionFeedbackGenerator()
+        selector = generator
+        return generator
+    }
+}