react-native-platform-components 1.3.0 → 1.5.0

package/ios/PCFloatingToolbarView.swift

@@ -0,0 +1,336 @@
+import UIKit
+
+/// The floating toolbar container: a Liquid Glass capsule on iOS 26, and a
+/// blur-material capsule with a soft shadow on earlier versions, where a blur
+/// over a flat background would otherwise have no edge.
+///
+/// Linked to a ScrollView (by nativeID), it sits on one of its edges: on iOS
+/// 26 that edge's scroll edge effect takes the toolbar's shape and the style
+/// asked for, and with hideOnScroll the toolbar slides past the edge while
+/// the content scrolls down.
+@objcMembers
+public final class PCFloatingToolbarView: UIView {
+    // MARK: - Props (set from ObjC++)
+
+    /// "regular" | "clear"
+    public var effectStyle: String = "regular" {
+        didSet { if oldValue != effectStyle { applyEffect() } }
+    }
+
+    /// Tint over the material; nil keeps the plain material
+    public var tintUIColor: UIColor? {
+        didSet { applyEffect() }
+    }
+
+    /// iOS 26: glass that scales and shimmers under a touch
+    public var interactive: Bool = false {
+        didSet { if oldValue != interactive { applyEffect() } }
+    }
+
+    /// nativeID of the ScrollView the toolbar floats over
+    public var scrollViewNativeID: String = "" {
+        didSet { if oldValue != scrollViewNativeID { unlinkScrollView(); linkScrollView() } }
+    }
+
+    /// iOS 26 edge effect under the toolbar: "" (the scroll view's own) |
+    /// "automatic" | "soft" | "hard" | "hidden"
+    public var scrollEdgeEffect: String = "" {
+        didSet { if oldValue != scrollEdgeEffect { applyScrollEdge() } }
+    }
+
+    /// Slide past the scroll view's edge while its content scrolls down
+    public var hideOnScroll: Bool = false {
+        didSet { if !hideOnScroll { setScrollHidden(false) } }
+    }
+
+    /// Whether the toolbar is slid away (the host passes touches through)
+    public private(set) var isScrollHidden = false
+
+    /// React children mount here
+    public var contentView: UIView { effectView.contentView }
+
+    // MARK: - Internal
+
+    private let effectView = UIVisualEffectView(effect: nil)
+
+    /// The linked scroll view, its offset observation and the edge the
+    /// toolbar sits on
+    private weak var linkedScrollView: UIScrollView?
+    private var offsetObservation: NSKeyValueObservation?
+    private var linkedEdge: UIRectEdge = .bottom
+
+    /// iOS 26: the UIScrollEdgeElementContainerInteraction on this view, and
+    /// the edge effect values it replaced (edge, style, isHidden)
+    private var edgeInteraction: UIInteraction?
+    private var savedEdgeEffect: (edge: UIRectEdge, style: AnyObject, hidden: Bool)?
+
+    /// Liquid Glass needs both the iOS 26 SDK at build time and iOS 26 at runtime.
+    private static var glassAvailable: Bool {
+        #if compiler(>=6.2)
+        if #available(iOS 26.0, *) { return true }
+        #endif
+        return false
+    }
+
+    // MARK: - Init
+
+    public override init(frame: CGRect) {
+        super.init(frame: frame)
+        setup()
+    }
+
+    public required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        setup()
+    }
+
+    private func setup() {
+        clipsToBounds = false
+        effectView.layer.cornerCurve = .continuous
+        addSubview(effectView)
+
+        if !Self.glassAvailable {
+            // The blur is clipped to the capsule; the shadow lives on this view
+            effectView.clipsToBounds = true
+            layer.shadowColor = UIColor.black.cgColor
+            layer.shadowOpacity = 0.12
+            layer.shadowRadius = 10
+            layer.shadowOffset = CGSize(width: 0, height: 4)
+        }
+        applyEffect()
+    }
+
+    // MARK: - Layout
+
+    public override func layoutSubviews() {
+        super.layoutSubviews()
+        effectView.frame = bounds
+        let radius = min(bounds.width, bounds.height) / 2
+        effectView.layer.cornerRadius = radius
+        if !Self.glassAvailable {
+            layer.shadowPath = UIBezierPath(roundedRect: bounds, cornerRadius: radius).cgPath
+        }
+        // The ScrollView may mount after the toolbar, and the toolbar may
+        // move to another edge
+        if let scrollView = linkedScrollView, scrollView.window != nil {
+            if edge(of: scrollView) != linkedEdge { applyScrollEdge() }
+        } else {
+            unlinkScrollView()
+            linkScrollView()
+        }
+    }
+
+    public override func didMoveToWindow() {
+        super.didMoveToWindow()
+        // Off screen, the scroll view gets its edge effect back
+        if window == nil {
+            unlinkScrollView()
+        } else {
+            linkScrollView()
+        }
+    }
+
+    // MARK: - Effect
+
+    private func applyEffect() {
+        #if compiler(>=6.2)
+        if #available(iOS 26.0, *) {
+            let glass = UIGlassEffect(style: effectStyle == "clear" ? .clear : .regular)
+            glass.isInteractive = interactive
+            if let tintUIColor {
+                glass.tintColor = tintUIColor
+            }
+            effectView.effect = glass
+            effectView.contentView.backgroundColor = nil
+            return
+        }
+        #endif
+        effectView.effect = UIBlurEffect(
+            style: effectStyle == "clear" ? .systemUltraThinMaterial : .systemThinMaterial
+        )
+        // UIBlurEffect has no tint; wash the content area with the color instead
+        effectView.contentView.backgroundColor = tintUIColor?.withAlphaComponent(0.35)
+    }
+
+    // MARK: - Linked scroll view
+
+    private func linkScrollView() {
+        guard linkedScrollView == nil, !scrollViewNativeID.isEmpty, let window,
+              let scrollView = Self.scrollView(nativeID: scrollViewNativeID, in: window)
+        else { return }
+        linkedScrollView = scrollView
+        offsetObservation = scrollView.observe(\.contentOffset, options: [.old, .new]) { [weak self] scrollView, change in
+            guard let old = change.oldValue, let new = change.newValue else { return }
+            self?.contentScrolled(scrollView, from: old, to: new)
+        }
+        applyScrollEdge()
+    }
+
+    private func unlinkScrollView() {
+        guard linkedScrollView != nil || offsetObservation != nil || edgeInteraction != nil else { return }
+        offsetObservation?.invalidate()
+        offsetObservation = nil
+        restoreScrollEdge()
+        #if compiler(>=6.2)
+        if #available(iOS 26.0, *), let edgeInteraction {
+            removeInteraction(edgeInteraction)
+        }
+        #endif
+        edgeInteraction = nil
+        linkedScrollView = nil
+        setScrollHidden(false)
+    }
+
+    /// The edge of the scroll view the toolbar sits on: top or bottom for a
+    /// horizontal toolbar, left or right for a vertical one.
+    private func edge(of scrollView: UIScrollView) -> UIRectEdge {
+        // The host, not this view, which moves while hidden
+        let host = superview ?? self
+        let toolbar = host.convert(host.bounds, to: nil)
+        let visible = scrollView.convert(scrollView.bounds, to: nil)
+        if toolbar.width >= toolbar.height {
+            return toolbar.midY < visible.midY ? .top : .bottom
+        }
+        return toolbar.midX < visible.midX ? .left : .right
+    }
+
+    /// The UIScrollView of the React Native view with this nativeID.
+    private static func scrollView(nativeID: String, in root: UIView) -> UIScrollView? {
+        var match: UIView?
+        func find(_ view: UIView) {
+            guard match == nil else { return }
+            if view.responds(to: NSSelectorFromString("nativeId")),
+               view.value(forKey: "nativeId") as? String == nativeID {
+                match = view
+                return
+            }
+            view.subviews.forEach(find)
+        }
+        find(root)
+        guard let match else { return nil }
+        if let scroll = match as? UIScrollView { return scroll }
+        var scroll: UIScrollView?
+        func firstScroll(_ view: UIView) {
+            guard scroll == nil else { return }
+            if let s = view as? UIScrollView { scroll = s; return }
+            view.subviews.forEach(firstScroll)
+        }
+        firstScroll(match)
+        return scroll
+    }
+
+    // MARK: - Scroll edge effect (iOS 26)
+
+    /// Shapes the linked edge's effect around the toolbar and applies the
+    /// style asked for, after giving back what an earlier call replaced.
+    private func applyScrollEdge() {
+        restoreScrollEdge()
+        guard let scrollView = linkedScrollView else { return }
+        linkedEdge = edge(of: scrollView)
+        #if compiler(>=6.2)
+        guard #available(iOS 26.0, *) else { return }
+
+        let interaction = edgeInteraction as? UIScrollEdgeElementContainerInteraction
+            ?? UIScrollEdgeElementContainerInteraction()
+        if edgeInteraction == nil {
+            addInteraction(interaction)
+            edgeInteraction = interaction
+        }
+        interaction.scrollView = scrollView
+        interaction.edge = linkedEdge
+
+        guard !scrollEdgeEffect.isEmpty else { return }
+        let effect = Self.edgeEffect(of: scrollView, at: linkedEdge)
+        savedEdgeEffect = (linkedEdge, effect.style, effect.isHidden)
+        switch scrollEdgeEffect {
+        case "hidden":
+            effect.isHidden = true
+        case "soft":
+            effect.style = .soft
+            effect.isHidden = false
+        case "hard":
+            effect.style = .hard
+            effect.isHidden = false
+        default:
+            effect.style = .automatic
+            effect.isHidden = false
+        }
+        #endif
+    }
+
+    /// Gives the scroll view back the edge effect values applyScrollEdge
+    /// replaced.
+    private func restoreScrollEdge() {
+        #if compiler(>=6.2)
+        if #available(iOS 26.0, *), let saved = savedEdgeEffect, let scrollView = linkedScrollView,
+           let style = saved.style as? UIScrollEdgeEffect.Style {
+            let effect = Self.edgeEffect(of: scrollView, at: saved.edge)
+            effect.style = style
+            effect.isHidden = saved.hidden
+        }
+        #endif
+        savedEdgeEffect = nil
+    }
+
+    #if compiler(>=6.2)
+    @available(iOS 26.0, *)
+    private static func edgeEffect(of scrollView: UIScrollView, at edge: UIRectEdge) -> UIScrollEdgeEffect {
+        switch edge {
+        case .top: return scrollView.topEdgeEffect
+        case .left: return scrollView.leftEdgeEffect
+        case .right: return scrollView.rightEdgeEffect
+        default: return scrollView.bottomEdgeEffect
+        }
+    }
+    #endif
+
+    // MARK: - Hide on scroll
+
+    // The motion of Material's HideViewOnScrollBehavior, as TabBar uses on
+    // Android: out while the content scrolls down, back as it scrolls up or
+    // reaches the top.
+    private func contentScrolled(_ scrollView: UIScrollView, from old: CGPoint, to new: CGPoint) {
+        guard hideOnScroll else { return }
+        let top = -scrollView.adjustedContentInset.top
+        if new.y <= top {
+            setScrollHidden(false)
+            return
+        }
+        // Rubber-banding past the end doesn't scroll the content
+        let bottom = max(top, scrollView.contentSize.height + scrollView.adjustedContentInset.bottom - scrollView.bounds.height)
+        guard new.y != old.y, new.y <= bottom, old.y <= bottom else { return }
+        setScrollHidden(new.y > old.y)
+    }
+
+    private func setScrollHidden(_ hide: Bool) {
+        guard isScrollHidden != hide else { return }
+        isScrollHidden = hide
+        let offset = hide ? hiddenOffset() : .zero
+        UIView.animate(
+            withDuration: hide ? 0.175 : 0.225,
+            delay: 0,
+            options: [hide ? .curveEaseIn : .curveEaseOut, .beginFromCurrentState, .allowUserInteraction]
+        ) {
+            self.transform = CGAffineTransform(translationX: offset.x, y: offset.y)
+        }
+    }
+
+    /// How far to move to get past the linked edge: from the toolbar to the
+    /// edge of the visible scroll view, and at least the toolbar's own size.
+    private func hiddenOffset() -> CGPoint {
+        guard let scrollView = linkedScrollView else { return .zero }
+        let host = superview ?? self
+        let toolbar = host.convert(host.bounds, to: nil)
+        let visible = scrollView.convert(scrollView.bounds, to: nil)
+        switch linkedEdge {
+        case .top:
+            return CGPoint(x: 0, y: min(visible.minY - toolbar.maxY, -toolbar.height))
+        case .left:
+            return CGPoint(x: min(visible.minX - toolbar.maxX, -toolbar.width), y: 0)
+        case .right:
+            return CGPoint(x: max(visible.maxX - toolbar.minX, toolbar.width), y: 0)
+        default:
+            return CGPoint(x: 0, y: max(visible.maxY - toolbar.minY, toolbar.height))
+        }
+    }
+}

package/ios/PCHaptics.swift

@@ -0,0 +1,91 @@
+import UIKit
+
+/// The shared `haptics` prop: a UIKit feedback generator played when a
+/// control reports the user's action. Each view keeps one of these; a
+/// generator is created on first use of its kind (attached to the view on
+/// iOS 17.5+) and kept. UIKit follows the system haptics setting.
+@objcMembers
+@MainActor
+public final class PCHaptics: NSObject {
+    /// "" (unset) | "none" | "selection" | "light" | "medium" | "heavy" |
+    /// "success" | "warning" | "error". "" and "none" play nothing: UIKit has
+    /// no switch for the haptics its own controls play.
+    public var kind: String = ""
+
+    /// Generators by kind, created on first use.
+    private var generators: [String: UIFeedbackGenerator] = [:]
+
+    /// Readies the Taptic Engine for an action that is likely to follow, such
+    /// as a touch down, so the haptic plays without delay.
+    public func prepare(in view: UIView) {
+        generator(for: kind, in: view)?.prepare()
+    }
+
+    /// Plays the haptic for `kind`.
+    public func perform(in view: UIView) {
+        play(kind, in: view)
+    }
+
+    /// Plays `override` when it is set (a menu item's own `haptics`, "none"
+    /// included), else `kind`.
+    public func perform(in view: UIView, override: String) {
+        play(override.isEmpty ? kind : override, in: view)
+    }
+
+    private func play(_ kind: String, in view: UIView) {
+        switch generator(for: kind, in: view) {
+        case let selection as UISelectionFeedbackGenerator:
+            selection.selectionChanged()
+        case let impact as UIImpactFeedbackGenerator:
+            impact.impactOccurred()
+        case let notification as UINotificationFeedbackGenerator:
+            if case let .notification(type) = Feedback(kind) {
+                notification.notificationOccurred(type)
+            }
+        default:
+            break
+        }
+    }
+
+    private enum Feedback {
+        case selection
+        case impact(UIImpactFeedbackGenerator.FeedbackStyle)
+        case notification(UINotificationFeedbackGenerator.FeedbackType)
+
+        init?(_ kind: String) {
+            switch kind {
+            case "selection": self = .selection
+            case "light": self = .impact(.light)
+            case "medium": self = .impact(.medium)
+            case "heavy": self = .impact(.heavy)
+            case "success": self = .notification(.success)
+            case "warning": self = .notification(.warning)
+            case "error": self = .notification(.error)
+            default: return nil
+            }
+        }
+    }
+
+    private func generator(for kind: String, in view: UIView) -> UIFeedbackGenerator? {
+        if let generator = generators[kind] { return generator }
+        guard let feedback = Feedback(kind) else { return nil }
+        let made: UIFeedbackGenerator
+        if #available(iOS 17.5, *) {
+            // Attached to the view: UIKit's replacement for the plain
+            // initializers, which are slated for deprecation
+            switch feedback {
+            case .selection: made = UISelectionFeedbackGenerator(view: view)
+            case let .impact(style): made = UIImpactFeedbackGenerator(style: style, view: view)
+            case .notification: made = UINotificationFeedbackGenerator(view: view)
+            }
+        } else {
+            switch feedback {
+            case .selection: made = UISelectionFeedbackGenerator()
+            case let .impact(style): made = UIImpactFeedbackGenerator(style: style)
+            case .notification: made = UINotificationFeedbackGenerator()
+            }
+        }
+        generators[kind] = made
+        return made
+    }
+}

package/ios/PCImageLoader.swift

@@ -8,11 +8,42 @@ import UIKit
 /// as `http(s)://` (Metro) or `data:` URLs and load asynchronously.
 ///
 /// Must be used from the main thread.
-final class PCImageLoader {
+final class PCImageLoader: NSObject, URLSessionTaskDelegate {
     static let shared = PCImageLoader()
 
-    private var cache: [String: UIImage] = [:]
+    /// A symbol by name: an SF Symbol, else a custom symbol or image from the
+    /// app's asset catalog, so an app's own icons (custom symbols exported
+    /// from SVG with the SF Symbols app) work wherever SF Symbol names do.
+    static func symbol(named name: String) -> UIImage? {
+        guard !name.isEmpty else { return nil }
+        return UIImage(systemName: name) ?? UIImage(named: name)
+    }
+
+    private let cache = NSCache<NSString, UIImage>()
     private var pending: [String: [(UIImage?) -> Void]] = [:]
+    private var generations: [String: Int] = [:]
+    private var nextGeneration = 0
+    // Custom credentials/body must not enter the shared URL cache or be
+    // forwarded to a redirect target. Decoded images use the full request key.
+    private lazy var requestSession: URLSession = {
+        let configuration = URLSessionConfiguration.ephemeral
+        configuration.urlCache = nil
+        configuration.httpShouldSetCookies = false
+        configuration.urlCredentialStorage = nil
+        return URLSession(configuration: configuration, delegate: self, delegateQueue: nil)
+    }()
+
+    private override init() {
+        super.init()
+        cache.countLimit = 32
+    }
+
+    func urlSession(_ session: URLSession, task: URLSessionTask,
+                    willPerformHTTPRedirection response: HTTPURLResponse,
+                    newRequest request: URLRequest,
+                    completionHandler: @escaping (URLRequest?) -> Void) {
+        completionHandler(nil)
+    }
 
     /// Returns the image immediately when it is cached or readable from disk.
     /// Otherwise starts a load and calls `completion` on the main thread with
@@ -21,34 +52,67 @@ final class PCImageLoader {
     func image(
         uri: String,
         scale: CGFloat,
+        request: String = "",
         completion: @escaping (UIImage?) -> Void
     ) -> UIImage? {
-        let key = "\(uri)@\(scale)x"
-        if let cached = cache[key] {
+        var options: [String: Any] = [:]
+        if !request.isEmpty {
+            guard let data = request.data(using: .utf8),
+                  let decoded = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+            else { return nil }
+            options = decoded
+        }
+        let policy = options.removeValue(forKey: "cache") as? String ?? "default"
+        guard let keyData = try? JSONSerialization.data(
+            withJSONObject: [uri, scale, options], options: [.sortedKeys]),
+              let key = String(data: keyData, encoding: .utf8) else { return nil }
+        if policy != "reload", let cached = cache.object(forKey: key as NSString) {
             return cached
         }
+        if policy == "only-if-cached" { return nil }
 
         guard let url = URL(string: uri) else { return nil }
 
         if url.isFileURL {
             guard let data = try? Data(contentsOf: url),
                   let image = UIImage(data: data, scale: scale) else { return nil }
-            cache[key] = image
+            cache.setObject(image, forKey: key as NSString)
             return image
         }
 
-        if pending[key] != nil {
-            pending[key]?.append(completion)
+        let pendingKey = key + (policy == "reload" ? ":reload" : ":cached")
+        if pending[pendingKey] != nil {
+            pending[pendingKey]?.append(completion)
             return nil
         }
-        pending[key] = [completion]
+        pending[pendingKey] = [completion]
+        nextGeneration += 1
+        let generation = nextGeneration
+        generations[key] = generation
+
+        var urlRequest = URLRequest(url: url)
+        urlRequest.httpMethod = options["method"] as? String ?? "GET"
+        urlRequest.httpBody = (options["body"] as? String)?.data(using: .utf8)
+        urlRequest.allHTTPHeaderFields = options["headers"] as? [String: String]
+        let custom = !options.isEmpty
+        if custom || policy == "reload" {
+            urlRequest.cachePolicy = .reloadIgnoringLocalCacheData
+        }
 
-        URLSession.shared.dataTask(with: url) { [weak self] data, _, _ in
-            let image = data.flatMap { UIImage(data: $0, scale: scale) }
+        (custom ? requestSession : URLSession.shared).dataTask(with: urlRequest) { [weak self] data, response, error in
+            let http = response as? HTTPURLResponse
+            let success = error == nil && (http == nil || (200..<300).contains(http!.statusCode))
+            let image = success ? data.flatMap { UIImage(data: $0, scale: scale) } : nil
+            let canCache = !(http?.value(forHTTPHeaderField: "Cache-Control")?
+                .lowercased().contains("no-store") ?? false)
             DispatchQueue.main.async {
                 guard let self else { return }
-                if let image { self.cache[key] = image }
-                let callbacks = self.pending.removeValue(forKey: key) ?? []
+                if self.generations[key] == generation {
+                    if let image, canCache { self.cache.setObject(image, forKey: key as NSString) }
+                    else { self.cache.removeObject(forKey: key as NSString) }
+                    self.generations.removeValue(forKey: key)
+                }
+                let callbacks = self.pending.removeValue(forKey: pendingKey) ?? []
                 callbacks.forEach { $0(image) }
             }
         }.resume()

package/ios/PCLiquidGlass.mm

@@ -28,6 +28,12 @@ using namespace facebook::react;
 
 - (instancetype)initWithFrame:(CGRect)frame {
   if (self = [super initWithFrame:frame]) {
+    // Fabric views seed _props with their own defaults: RCTViewComponentView
+    // asserts on it in debug builds of React Native core, and the first
+    // updateProps would otherwise read the base ViewProps as PCLiquidGlassProps.
+    static const auto defaultProps = std::make_shared<const PCLiquidGlassProps>();
+    _props = defaultProps;
+
     _view = [[PCLiquidGlassView alloc] initWithEffect:nil];
     _view.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
     [self addSubview:_view];
@@ -62,6 +68,31 @@ using namespace facebook::react;
   [childComponentView removeFromSuperview];
 }
 
+// Removed from its parent: inside a glass container the glass dematerializes
+// in place rather than vanishing
+- (void)willMoveToSuperview:(UIView *)newSuperview {
+  if (newSuperview == nil && self.superview != nil) {
+    [_view willUnmount];
+  }
+  [super willMoveToSuperview:newSuperview];
+}
+
+// Inside a glass container on screen, a new frame animates, which morphs the
+// merged glass instead of jumping
+- (void)updateLayoutMetrics:(const LayoutMetrics &)layoutMetrics
+           oldLayoutMetrics:(const LayoutMetrics &)oldLayoutMetrics {
+  BOOL morphs = oldLayoutMetrics != EmptyLayoutMetrics &&
+      layoutMetrics.frame != oldLayoutMetrics.frame && _view.morphsLayoutChanges;
+  if (!morphs) {
+    [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
+    return;
+  }
+  [PCLiquidGlassView morph:^{
+    [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
+    [self layoutIfNeeded];
+  }];
+}
+
 
 - (void)updateProps:(Props::Shared const &)props
            oldProps:(Props::Shared const &)oldProps {
@@ -77,6 +108,11 @@ using namespace facebook::react;
     _view.glassCornerRadius = newProps.cornerRadius;
   }
 
+  // cornerStyle -> cornerConfiguration on iOS 26
+  if (!prevProps || newProps.cornerStyle != prevProps->cornerStyle) {
+    _view.cornerStyle = [NSString stringWithUTF8String:newProps.cornerStyle.c_str()];
+  }
+
   // iOS-specific props
   const auto &newIos = newProps.ios;
   const auto &oldIos = prevProps ? prevProps->ios : PCLiquidGlassIosStruct{};