craft-native 0.0.358 → 0.0.360

package/dist/ios/templates/CraftHybrid.swift

@@ -2,6 +2,7 @@ import Foundation
 import SwiftUI
 import UIKit
 import WebKit
+import Combine
 
 // MARK: - Hybrid: web plus native screens
 //
@@ -1098,7 +1099,7 @@ final class CraftNativeNavigationController: UINavigationController {
     }
 }
 
-final class CraftHybridController: UIViewController, UINavigationControllerDelegate, UIGestureRecognizerDelegate, CraftHybridScreenEvents {
+final class CraftHybridController: UITabBarController, UITabBarControllerDelegate, UINavigationControllerDelegate, UIGestureRecognizerDelegate, CraftHybridScreenEvents {
     private let config: CraftConfig
     private let hybrid = CraftHybrid.shared
     /// The web view's host; nil in an all-native app, which never makes one.
@@ -1107,6 +1108,15 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
     private let parking = UIView()
     private var stacks: [String: UINavigationController] = [:]
     private var currentTab = ""
+    private var tabPlaceholders: [String: UIViewController] = [:]
+    private var systemTabItems: [String: UITabBarItem] = [:]
+    private var chromeSubscription: AnyCancellable?
+    private var chromeUpdatePending = false
+    private var synchronizingTabs = false
+    private var accessoryModel: CraftChrome.Tab?
+    private let accessoryButton = UIButton(type: .system)
+    private static let tabPictures = NSCache<NSURL, UIImage>()
+    private var requestedTabPictures = Set<URL>()
     /// The path each native entry opened at.
     private var nativePaths: [ObjectIdentifier: String] = [:]
     /// Each stack as it was after its last transition, to see what a pop removed.
@@ -1159,10 +1169,30 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
 
     override func viewDidLoad() {
         super.viewDidLoad()
+        hybrid.controller = self
+        delegate = self
+        if #available(iOS 18.0, *) { mode = .tabBar }
+#if compiler(>=6.2)
+        if #available(iOS 26.0, *) { tabBarMinimizeBehavior = .onScrollDown }
+#endif
+        accessoryButton.accessibilityIdentifier = "craft-tab-accessory"
+        accessoryButton.addTarget(self, action: #selector(openTabAccessory), for: .touchUpInside)
+        chromeSubscription = CraftChrome.shared.objectWillChange.sink { [weak self] in
+            guard let self, !self.chromeUpdatePending else { return }
+            self.chromeUpdatePending = true
+            // Published sends before its value changes; coalesce the complete
+            // chrome transaction before updating UIKit's retained tab items.
+            DispatchQueue.main.async { [weak self] in
+                guard let self else { return }
+                self.chromeUpdatePending = false
+                guard self.hybrid.controller === self else { return }
+                self.synchronizeSystemTabs()
+            }
+        }
         view.backgroundColor = config.resolvedBackgroundColor
         parking.frame = view.bounds
         parking.autoresizingMask = [.flexibleWidth, .flexibleHeight]
-        view.addSubview(parking)
+        view.insertSubview(parking, at: 0)
 
         // A native start screen draws first; the web view, whose creation
         // costs a frame or more, starts loading straight after it. An
@@ -1185,6 +1215,165 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
         prepareAdjacentNativeTabs()
     }
 
+    /// UIKit owns the bar, selection indicator, badges and content safe area.
+    /// Placeholders preserve lazy screen creation without inventing a second
+    /// navigation stack when a tab is first selected or prepared for a swipe.
+    private func synchronizeSystemTabs() {
+        guard isViewLoaded, !synchronizingTabs else { return }
+        synchronizingTabs = true
+        defer { synchronizingTabs = false }
+        let chrome = CraftChrome.shared
+        let ids = hybrid.tabIds.isEmpty ? [currentTab] : hybrid.tabIds
+        let controllers = ids.map { id -> UIViewController in
+            let controller: UIViewController
+            if let stack = stacks[id] { controller = stack }
+            else if let placeholder = tabPlaceholders[id] { controller = placeholder }
+            else {
+                controller = UIViewController()
+                tabPlaceholders[id] = controller
+            }
+            // An explicit retained item prevents UINavigationController from
+            // adopting a newly loaded root screen's default tab item later.
+            let item = systemTabItems[id] ?? UITabBarItem(title: nil, image: nil, tag: 0)
+            systemTabItems[id] = item
+            if controller.tabBarItem !== item { controller.tabBarItem = item }
+            return controller
+        }
+        let existing = viewControllers ?? []
+        if existing.count != controllers.count || zip(existing, controllers).contains(where: { $0 !== $1 }) {
+            setViewControllers(controllers, animated: false)
+            customizableViewControllers = []
+        }
+        // UIKit rebuilds item presentation when a lazy placeholder is replaced.
+        // Apply accessibility metadata after installing the retained stacks so
+        // the last prepared tab keeps the same identifier as every other tab.
+        for (id, controller) in zip(ids, controllers) {
+            guard let tab = chrome.tabs.first(where: { $0.id == id }) else { continue }
+            let item = controller.tabBarItem!
+            item.title = tab.displayTitle
+            item.image = systemTabImage(tab, selected: false)
+            item.selectedImage = systemTabImage(tab, selected: true)
+            item.badgeValue = tab.badge
+            item.accessibilityIdentifier = "craft-tab-\(tab.id)"
+            item.accessibilityLabel = tab.accessibilityLabel ?? tab.displayTitle
+        }
+        if let committed = stacks[currentTab], controllers.contains(where: { $0 === committed }), selectedViewController !== committed {
+            UIView.performWithoutAnimation {
+                selectedViewController = committed
+                view.layoutIfNeeded()
+            }
+        }
+        tabBar.tintColor = chrome.tint ?? view.tintColor
+        let hidden = !chrome.tabBarVisible || chrome.tabs.isEmpty
+        if #available(iOS 18.0, *) { setTabBarHidden(hidden, animated: false) }
+        else { tabBar.isHidden = hidden }
+        updateSystemAccessory(hidden: hidden)
+    }
+
+    private func systemTabImage(_ tab: CraftChrome.Tab, selected: Bool) -> UIImage? {
+        if let address = tab.image, let url = URL(string: address), url.scheme == "https" {
+            if let image = Self.tabPictures.object(forKey: url as NSURL) { return image }
+            if requestedTabPictures.insert(url).inserted {
+                URLSession.shared.dataTask(with: url) { [weak self] data, response, _ in
+                    guard let data, let response = response as? HTTPURLResponse,
+                          (200..<300).contains(response.statusCode), let image = UIImage(data: data) else { return }
+                    DispatchQueue.main.async { [weak self] in
+                        let fitted = UIGraphicsImageRenderer(size: CGSize(width: 26, height: 26)).image { _ in
+                            UIBezierPath(ovalIn: CGRect(x: 0, y: 0, width: 26, height: 26)).addClip()
+                            let scale = max(26 / max(1, image.size.width), 26 / max(1, image.size.height))
+                            let size = CGSize(width: image.size.width * scale, height: image.size.height * scale)
+                            image.draw(in: CGRect(x: (26 - size.width) / 2, y: (26 - size.height) / 2, width: size.width, height: size.height))
+                        }.withRenderingMode(.alwaysOriginal)
+                        Self.tabPictures.countLimit = 16
+                        Self.tabPictures.setObject(fitted, forKey: url as NSURL)
+                        guard let self, self.hybrid.controller === self else { return }
+                        self.synchronizeSystemTabs()
+                    }
+                }.resume()
+            }
+        } else if let text = tab.iconText {
+            let attributes: [NSAttributedString.Key: Any] = [
+                .font: UIFont.monospacedDigitSystemFont(ofSize: 16, weight: .semibold), .foregroundColor: UIColor.systemRed,
+            ]
+            let label = text as NSString
+            let size = label.size(withAttributes: attributes)
+            return UIGraphicsImageRenderer(size: CGSize(width: min(48, max(1, size.width)), height: 26)).image { _ in
+                label.draw(in: CGRect(x: 0, y: (26 - size.height) / 2, width: 48, height: size.height), withAttributes: attributes)
+            }.withRenderingMode(.alwaysOriginal)
+        }
+        let appearance = tab.iconAppearance(selected: selected, motionAllowed: false)
+        let filled = selected && tab.selectedSymbol == nil && !appearance.symbol.hasSuffix(".fill")
+            ? UIImage(systemName: appearance.symbol + ".fill") : nil
+        let image = filled ?? UIImage(systemName: appearance.symbol)
+        if let color = appearance.tint.flatMap({ UIColor(hex: $0) }) {
+            return image?.withTintColor(color, renderingMode: .alwaysOriginal)
+        }
+        return image
+    }
+
+    func tabBarController(_ tabBarController: UITabBarController, shouldSelect viewController: UIViewController) -> Bool {
+        let ids = hybrid.tabIds
+        guard let index = viewControllers?.firstIndex(where: { $0 === viewController }), ids.indices.contains(index),
+              let tab = CraftChrome.shared.tabs.first(where: { $0.id == ids[index] }) else { return false }
+        // Craft may wait for the shared web page. Its committed stack decides
+        // selection, including reselect-to-root and interruption of a swipe.
+        CraftChrome.shared.tap(tab)
+        return false
+    }
+
+    private func updateSystemAccessory(hidden: Bool) {
+        let chrome = CraftChrome.shared
+        let model = hidden ? nil : chrome.tabAccessory
+        if let model {
+            var configuration = UIButton.Configuration.plain()
+            configuration.image = UIImage(systemName: model.symbol)
+            configuration.title = model.displayTitle
+            configuration.subtitle = model.badge
+            configuration.imagePadding = 8
+            accessoryButton.configuration = configuration
+            accessoryButton.accessibilityLabel = model.accessibilityLabel ?? model.displayTitle
+            accessoryButton.accessibilityValue = model.badge
+            accessoryButton.accessibilityTraits = chrome.accessorySelected ? [.button, .selected] : [.button]
+        }
+#if compiler(>=6.2)
+        if #available(iOS 26.0, *) {
+            if (model == nil) != (bottomAccessory == nil) {
+                bottomAccessory = model.map { _ in UITabAccessory(contentView: accessoryButton) }
+            }
+            accessoryModel = model
+            return
+        }
+#endif
+        // Older systems have no bottom-accessory container. Keep the action
+        // available above the system bar, without recreating the tab control.
+        if model != nil, accessoryButton.superview == nil { view.addSubview(accessoryButton) }
+        accessoryButton.isHidden = model == nil
+        accessoryButton.backgroundColor = config.resolvedBackgroundColor
+        accessoryModel = model
+        for nav in stacks.values { nav.additionalSafeAreaInsets.bottom = safeAreaForTabBar() }
+        view.setNeedsLayout()
+    }
+
+    @objc private func openTabAccessory() {
+        if let accessoryModel { hybrid.open(accessoryModel.id) }
+    }
+
+    override func viewDidLayoutSubviews() {
+        super.viewDidLayoutSubviews()
+        guard hybrid.controller === self else { return }
+#if compiler(>=6.2)
+        if #available(iOS 26.0, *) {
+            // UIKit already supplies the native safe area. This measurement is
+            // only the web CSS contract, not another native bottom inset.
+            let top = bottomAccessory.map { $0.contentView.convert($0.contentView.bounds, to: view).minY } ?? tabBar.frame.minY
+            CraftChrome.shared.layoutChanged(tabBar.isHidden ? 0 : max(0, view.bounds.maxY - top))
+            return
+        }
+#endif
+        accessoryButton.frame = CGRect(x: 16, y: tabBar.frame.minY - 44, width: max(0, view.bounds.width - 32), height: 44)
+        CraftChrome.shared.layoutChanged(tabBar.isHidden ? 0 : max(0, view.bounds.maxY - tabBar.frame.minY) + (accessoryModel == nil ? 0 : 44))
+    }
+
     private var webAttached = false
 
     private func installTabSwipeGestures() {
@@ -1304,6 +1493,9 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
                 self.reveal(slot)
             }
         }
+        if let container = current.view.superview, target.view.superview !== container {
+            container.addSubview(target.view)
+        }
         target.view.isHidden = false
         let width = view.bounds.width
         tabSwipeFrom = -direction * width
@@ -1321,7 +1513,7 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
             }
         }
         target.view.frame = view.bounds.offsetBy(dx: tabSwipeFrom + tabSwipeBase, dy: 0)
-        view.bringSubviewToFront(target.view)
+        target.view.superview?.bringSubviewToFront(target.view)
         CraftChrome.shared.beginTabSwipe(to: id, from: currentTab)
         lastNavigation = CACurrentMediaTime()
         CraftFramePacing.shared.begin("tab swipe")
@@ -1416,10 +1608,18 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
         let completing = settleCompleting
         CraftFramePacing.shared.end("tab swipe")
         finish()
+        // The two pages are exactly one viewport apart. UIKit can reparent
+        // the outgoing layer when selection commits; its presentation frame
+        // then uses the new container's coordinates, not the old swipe's.
         let (stay, stayX, other, otherId, otherX) = completing
-            ? (target, targetX, current, outgoing, currentX)
-            : (current, currentX, target, targetId, targetX)
+            ? (target, targetX, current, outgoing, targetX - tabSwipeFrom)
+            : (current, currentX, target, targetId, currentX + tabSwipeFrom)
         guard abs(stayX) > 0.5 else { return }
+        // Selection removes UIKit's outgoing view. A caught interactive swipe
+        // needs it beside the new selected view again, in the same container.
+        if let container = stay.view.superview, other.view.superview !== container {
+            container.addSubview(other.view)
+        }
         stay.view.frame = view.bounds.offsetBy(dx: stayX, dy: 0)
         other.view.isHidden = false
         other.view.frame = view.bounds.offsetBy(dx: otherX, dy: 0)
@@ -1604,17 +1804,18 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
         nav.view.backgroundColor = config.resolvedBackgroundColor
         nav.additionalSafeAreaInsets.bottom = safeAreaForTabBar()
         nav.setNavigationBarHidden(true, animated: false)
-        addChild(nav)
         nav.view.frame = view.bounds
         nav.view.autoresizingMask = [.flexibleWidth, .flexibleHeight]
         nav.view.isHidden = hidden
-        view.addSubview(nav.view)
-        nav.didMove(toParent: self)
         // Only once the stack's view has loaded: the recognizer is made then,
         // and before it is nil, so the delegate never took.
         for recognizer in popRecognizers(of: nav) { recognizer.delegate = self }
         stacks[tab] = nav
         shownStacks[ObjectIdentifier(nav)] = nav.viewControllers
+        synchronizeSystemTabs()
+        if hidden, nav.view.superview == nil, let container = visibleStack?.view.superview {
+            container.addSubview(nav.view)
+        }
         return nav
     }
 
@@ -1664,10 +1865,11 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
             (nav.topViewController as? CraftNativeScreenController)?.screenVisibilityChanged(true)
         }
         currentTab = id
+        synchronizeSystemTabs()
         if let top = nav.topViewController { CraftChrome.shared.visiblePath = nativePaths[ObjectIdentifier(top)] }
         for (key, other) in stacks { other.view.isHidden = key != id }
         nav.view.frame = view.bounds
-        view.bringSubviewToFront(nav.view)
+        nav.view.superview?.bringSubviewToFront(nav.view)
         prepareAdjacentNativeTabs()
         if let slot = nav.topViewController as? CraftHybridWebSlot, slot.isViewLoaded {
             adoptWeb(into: slot)
@@ -2028,15 +2230,16 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
 
     func tabBarCovers(_ height: CGFloat) {
         tabBarHeight = height
-        let inset = safeAreaForTabBar()
-        for nav in stacks.values where nav.additionalSafeAreaInsets.bottom != inset {
-            nav.additionalSafeAreaInsets.bottom = inset
-        }
     }
 
     private func safeAreaForTabBar() -> CGFloat {
-        let bottom = view.window?.safeAreaInsets.bottom ?? view.safeAreaInsets.bottom
-        return max(0, tabBarHeight - bottom)
+        // UIKit supplies the bar (and on iOS 26, its accessory) inset. Only
+        // the older-system accessory above that bar needs an extra inset.
+#if compiler(>=6.2)
+        if #available(iOS 26.0, *) { return 0 }
+#endif
+        let chrome = CraftChrome.shared
+        return chrome.tabBarVisible && !chrome.tabs.isEmpty && chrome.tabAccessory != nil ? 44 : 0
     }
 
     override func viewSafeAreaInsetsDidChange() {
@@ -2157,6 +2360,12 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
 
     func gestureRecognizerShouldBegin(_ gestureRecognizer: UIGestureRecognizer) -> Bool {
         if tabSwipeRecognizers.contains(where: { $0 === gestureRecognizer }) {
+            // System tab-bar tracking owns touches on the bar and accessory;
+            // Craft's content swipe must not steal their drag/hold gestures.
+            let point = gestureRecognizer.location(in: view)
+            if !tabBar.isHidden, tabBar.frame.contains(point) { return false }
+            if !accessoryButton.isHidden, accessoryButton.window != nil,
+               accessoryButton.convert(accessoryButton.bounds, to: view).contains(point) { return false }
             // A swipe may begin while the last one settles: it catches it.
             guard activeTabSwipeTarget == nil || tabSwipeSettling,
                   hybrid.tabIds.count > 1, let nav = visibleStack, let top = nav.topViewController else { return false }

package/dist/ios/templates/CraftNativeActions.swift

@@ -49,6 +49,7 @@ enum CraftNativeActions {
         values.append("storageSetIfAbsent")
         values.append("viewScroll")
         values.append("crypto")
+        values.append("shortcuts")
         if config.enableBiometric { values.append("biometric") }
         if config.enableSecureStorage { values.append("secureStorage") }
         if config.enableLocalDatabase { values.append("database") }
@@ -212,6 +213,17 @@ enum CraftNativeActions {
                 complete(requestToken, storage(method: method, args: args), completion)
             }
             return
+        case ("Shortcuts", _):
+            // UIKit quick actions belong to the app, not the calling route.
+            // A queued call from a disposed screen must not change that menu.
+            DispatchQueue.main.async {
+                cancellationLock.lock()
+                let cancelled = cancelledRequests.remove(requestToken) != nil
+                cancellationLock.unlock()
+                guard !cancelled else { return }
+                complete(requestToken, shortcuts(method: method, args: args), completion)
+            }
+            return
         case ("SecureStorage", _):
             guard config.enableSecureStorage else {
                 complete(requestToken, failure("CAPABILITY_DISABLED", "Secure storage is disabled"), completion)
@@ -950,6 +962,44 @@ enum CraftNativeActions {
         }
     }
 
+    private static func shortcuts(method: String, args: [Any]) -> Result<Any, CraftNativeActionError> {
+        if method == "clear" {
+            guard args.isEmpty else { return failure("INVALID_ARGUMENT", "Shortcuts.clear takes no arguments") }
+            UIApplication.shared.shortcutItems = nil
+            return .success(true)
+        }
+        guard method == "set" else { return failure("UNSUPPORTED_METHOD", "Unknown Shortcuts method") }
+        guard args.count == 1, let items = args.first as? [[String: Any]], items.count <= 4 else {
+            return failure("INVALID_ARGUMENT", "Shortcuts.set needs a list of at most four shortcuts")
+        }
+        var types = Set<String>()
+        var shortcuts: [UIApplicationShortcutItem] = []
+        for item in items {
+            guard let type = item["type"] as? String, !type.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty,
+                  let title = item["title"] as? String, !title.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty,
+                  types.insert(type).inserted else {
+                return failure("INVALID_ARGUMENT", "Every shortcut needs a unique type and a non-empty title")
+            }
+            for name in ["subtitle", "iconName"] where item[name] != nil {
+                guard item[name] is String else { return failure("INVALID_ARGUMENT", "Shortcut \(name) must be a string") }
+            }
+            var userInfo: [String: NSSecureCoding]?
+            if let raw = item["userInfo"] {
+                guard let info = raw as? [String: Any], PropertyListSerialization.propertyList(info, isValidFor: .binary),
+                      let secure = info as? [String: NSSecureCoding] else {
+                    return failure("INVALID_ARGUMENT", "Shortcut userInfo must contain property-list values")
+                }
+                userInfo = secure
+            }
+            shortcuts.append(UIApplicationShortcutItem(type: type, localizedTitle: title,
+                localizedSubtitle: item["subtitle"] as? String,
+                icon: (item["iconName"] as? String).map { UIApplicationShortcutIcon(systemImageName: $0) }, userInfo: userInfo))
+        }
+        // Validate the whole list before replacing the previously valid menu.
+        UIApplication.shared.shortcutItems = shortcuts
+        return .success(["count": shortcuts.count])
+    }
+
     private static func storage(method: String, args: [Any]) -> Result<Any, CraftNativeActionError> {
         do {
             if method == "clear" { try CraftPersistentStorage.clear(prefix: storagePrefix); return .success(true) }

package/dist/ios/templates/CraftNativeFiles.swift

@@ -192,10 +192,12 @@ enum CraftNativeFiles {
         do {
             let url = try newFile(named: name)
             guard let destination = CGImageDestinationCreateWithURL(url as CFURL, UTType.jpeg.identifier as CFString, 1, nil) else {
+                try? FileManager.default.removeItem(at: url.deletingLastPathComponent())
                 return .failure(CraftNativeActionError(code: "WRITE_ERROR", message: "The photo could not be saved"))
             }
             CGImageDestinationAddImage(destination, image, [kCGImageDestinationLossyCompressionQuality: quality] as CFDictionary)
             guard CGImageDestinationFinalize(destination) else {
+                try? FileManager.default.removeItem(at: url.deletingLastPathComponent())
                 return .failure(CraftNativeActionError(code: "WRITE_ERROR", message: "The photo could not be saved"))
             }
             return .success(describe(url, type: "image/jpeg", extra: ["width": image.width, "height": image.height]))
@@ -731,11 +733,11 @@ enum CraftNativeMedia {
         lock.lock()
         defer { lock.unlock() }
         if let flight, inFlight[address]?.id != flight {
-            return .failure(CraftNativeActionError(code: "CANCELLED", message: "The video cache was cleared"))
+            return .failure(CraftNativeActionError(code: "CANCELLED", message: "The media cache was cleared"))
         }
         // A background transfer from before the cache was cleared (sign-out).
         if let stillWanted, !stillWanted() {
-            return .failure(CraftNativeActionError(code: "CANCELLED", message: "The video cache was cleared"))
+            return .failure(CraftNativeActionError(code: "CANCELLED", message: "The media cache was cleared"))
         }
         let staging = root.appendingPathComponent(UUID().uuidString + ".part")
         defer { try? fm.removeItem(at: staging) }
@@ -784,7 +786,7 @@ enum CraftNativeMedia {
             catch { failure = error }
         }
         lock.unlock()
-        for done in waiting { done(.failure(CraftNativeActionError(code: "CANCELLED", message: "The video cache was cleared"))) }
+        for done in waiting { done(.failure(CraftNativeActionError(code: "CANCELLED", message: "The media cache was cleared"))) }
         if let failure { throw failure }
         return removed
     }