@rdlabo/ionic-theme-ios27 1.2.1 → 2.0.0-beta.pr303.shaf4f5ca16816f

package/ios/Sources/IonicNativeUIShellPlugin/Components/ShellSegment.swift

@@ -1,91 +0,0 @@
-import UIKit
-
-private final class ShellSegmentElement: UIAccessibilityElement {
-    var activate: (() -> Bool)?
-    override func accessibilityActivate() -> Bool { activate?() ?? false }
-}
-
-final class ShellSegment: UISegmentedControl {
-    static let kind = ShellComponent.segment
-    var labels: [String] = []
-    private var items: [ShellItem] = []
-    override func layoutSubviews() {
-        super.layoutSubviews()
-        let total = (0..<numberOfSegments).reduce(CGFloat.zero) { $0 + widthForSegment(at: $1) }
-        var x: CGFloat = 0
-        accessibilityElements = labels.prefix(numberOfSegments).enumerated().map { index, label in
-            let width = total > 0 ? bounds.width * widthForSegment(at: index) / total : bounds.width / CGFloat(numberOfSegments)
-            let element = ShellSegmentElement(accessibilityContainer: self)
-            element.accessibilityLabel = label
-            element.accessibilityTraits = [.button]
-            if index == selectedSegmentIndex { element.accessibilityTraits.insert(.selected) }
-            if !isEnabledForSegment(at: index) { element.accessibilityTraits.insert(.notEnabled) }
-            let origin = effectiveUserInterfaceLayoutDirection == .rightToLeft ? bounds.width - x - width : x
-            element.accessibilityFrameInContainerSpace = CGRect(x: origin, y: 0, width: width, height: bounds.height)
-            element.activate = { [weak self] in
-                guard let self, self.isEnabledForSegment(at: index) else { return false }
-                self.selectedSegmentIndex = index
-                self.sendActions(for: .valueChanged)
-                self.setNeedsLayout()
-                return true
-            }
-            x += width
-            return element
-        }
-    }
-
-    @available(iOS 26.0, *)
-    static func make(_ node: ShellControl, scale: CGFloat, rendering: ShellRendering, activate: @escaping (String) -> Void) -> UISegmentedControl? {
-        guard !node.items.isEmpty else { return nil }
-        let control = ShellSegment(items: [])
-        control.isAccessibilityElement = false
-        control.apportionsSegmentWidthsByContent = false
-        control.update(node, scale: scale, rendering: rendering)
-        control.addAction(UIAction { [weak control] _ in
-            guard let control, control.items.indices.contains(control.selectedSegmentIndex) else { return }
-            activate(control.items[control.selectedSegmentIndex].id)
-        }, for: .valueChanged)
-        return control
-    }
-
-    @available(iOS 26.0, *)
-    func update(_ node: ShellControl, scale: CGFloat, rendering: ShellRendering) {
-        let previous = items
-        let rebuilt = previous.map(\.id) != node.items.map(\.id)
-        if rebuilt {
-            removeAllSegments()
-            for index in node.items.indices { insertSegment(withTitle: "", at: index, animated: false) }
-        }
-        if let first = node.items.first, previous.first?.content.fontSize != first.content.fontSize {
-            setTitleTextAttributes([.font: UIFont.systemFont(ofSize: first.content.fontSize, weight: .medium)], for: .normal)
-        }
-        let direction: UISemanticContentAttribute = node.rtl ? .forceRightToLeft : .forceLeftToRight
-        if semanticContentAttribute != direction { semanticContentAttribute = direction }
-        // Ionic button frames exclude their margins. Distribute the full track
-        // width so UIKit's fixed segment widths do not shrink the projected track.
-        let totalItemWidth = node.items.reduce(0.0) { $0 + $1.frame.width }
-        let widthScale = totalItemWidth > 0 ? node.frame.width / totalItemWidth * scale : scale
-        for (index, item) in node.items.enumerated() {
-            let old = rebuilt ? nil : previous[index].content
-            let content = item.content
-            if old?.label != content.label || old?.icon != content.icon ||
-                old?.iconWidth != content.iconWidth || old?.iconHeight != content.iconHeight ||
-                old?.iconTemplate != content.iconTemplate || old?.color != content.color {
-                let image = rendering.image(content)
-                setImage(image, forSegmentAt: index)
-                setTitle(image == nil ? content.label : nil, forSegmentAt: index)
-            }
-            if isEnabledForSegment(at: index) == content.disabled { setEnabled(!content.disabled, forSegmentAt: index) }
-            let width = item.frame.width * widthScale
-            if widthForSegment(at: index) != width { setWidth(width, forSegmentAt: index) }
-        }
-        items = node.items
-        labels = items.map { $0.content.accessibilityLabel }
-        accessibilityIdentifier = node.id
-        let selected = items.firstIndex { $0.content.selected } ?? UISegmentedControl.noSegment
-        // A native tap has already selected this index. Reassigning it can interrupt
-        // UIKit's in-flight lens animation when the Web selection echoes back.
-        if selectedSegmentIndex != selected { selectedSegmentIndex = selected }
-        setNeedsLayout()
-    }
-}

package/ios/Sources/IonicNativeUIShellPlugin/Components/ShellTabBar.swift

@@ -1,221 +0,0 @@
-import UIKit
-
-enum ShellTabBar {
-    struct Anchor: Decodable, Equatable {
-        let x: Double
-        let y: Double
-        var isValid: Bool { [0, 0.5, 1].contains(x) && [0, 1].contains(y) }
-    }
-
-    /// Optimistic tab selection until the Web selected state catches up (or times out).
-    struct PendingSelection: Equatable {
-        var id: String
-        var until: CFAbsoluteTime
-        static func start(_ id: String, ttl: CFTimeInterval = 1) -> PendingSelection {
-            PendingSelection(id: id, until: CFAbsoluteTimeGetCurrent() + ttl)
-        }
-    }
-
-    static let kind = ShellComponent.tabBar
-    /// Tab bars waiting for an iOS 26 title-layout warmup after the next `fit`.
-    private static var pendingTitleWarmup = Set<ObjectIdentifier>()
-
-    static func make(_ node: ShellControl, rendering: ShellRendering, delegate: UITabBarDelegate) -> UITabBar {
-        let control = UITabBar()
-        configureLayout(control)
-#if DEBUG
-        NSLog("[Native UI Shell] Created UITabBar %@", node.id)
-#endif
-        control.delegate = delegate
-        update(control, node: node, rendering: rendering)
-        return control
-    }
-
-    static func configureLayout(_ tabBar: UITabBar) {
-        // The reader accepts icon-top tabs. Keep that layout local to the native
-        // bar instead of letting the iPad idiom turn it into inline items.
-        if #available(iOS 17.0, *) {
-            tabBar.traitOverrides.horizontalSizeClass = .compact
-            tabBar.traitOverrides.verticalSizeClass = .regular
-        }
-        tabBar.itemPositioning = .fill
-    }
-
-    static func update(_ tabBar: UITabBar, node: ShellControl, rendering: ShellRendering) {
-        var pending: PendingSelection?
-        update(tabBar, node: node, rendering: rendering, pendingSelection: &pending)
-    }
-
-    static func update(_ tabBar: UITabBar, node: ShellControl, rendering: ShellRendering,
-                       pendingSelection: inout PendingSelection?) {
-        let items = node.items
-        let ids = items.map(\.id)
-        var needsTitleWarmup = false
-        // Keep UIKit's item identities and interaction state across DOM selection updates.
-        if tabBar.items?.map({ $0.accessibilityIdentifier ?? "" }) != ids {
-            tabBar.items = items.map { item in
-                let tab = UITabBarItem(title: item.content.label, image: rendering.image(item.content), tag: 0)
-                tab.accessibilityIdentifier = item.id
-                return tab
-            }
-            needsTitleWarmup = true
-        }
-        let nativeItems = tabBar.items ?? []
-        for (tab, item) in zip(nativeItems, items) {
-            let title = item.content.label
-            if tab.title != title {
-                tab.title = title
-                needsTitleWarmup = true
-            }
-            let icon = rendering.image(item.content)
-            if tab.image !== icon {
-                tab.image = icon
-                needsTitleWarmup = true
-            }
-            if tab.selectedImage !== icon { tab.selectedImage = icon }
-            tab.isEnabled = !item.content.disabled
-            tab.accessibilityLabel = item.content.accessibilityLabel
-            if applyTypography(item.content, to: tab) { needsTitleWarmup = true }
-            applyBadge(item.content.badge, to: tab, rendering: rendering)
-        }
-        let domSelected = zip(nativeItems, items).first { $0.1.content.selected }
-        let selectedItem = domSelected?.0
-        if let pending = pendingSelection {
-            let pendingItem = zip(nativeItems, items).first { $0.1.id == pending.id }
-            let expired = CFAbsoluteTimeGetCurrent() >= pending.until
-            let unavailable = pendingItem == nil || pendingItem!.1.content.disabled
-            if unavailable || expired {
-                // Ionic rejected the tap, the item vanished, or the echo timed out.
-                pendingSelection = nil
-                if tabBar.selectedItem !== selectedItem { tabBar.selectedItem = selectedItem }
-            } else if domSelected?.1.id == pending.id {
-                pendingSelection = nil
-                if tabBar.selectedItem !== selectedItem { tabBar.selectedItem = selectedItem }
-            } else if tabBar.selectedItem !== pendingItem!.0 {
-                // Keep the optimistic native selection until the Web selected state catches up.
-                tabBar.selectedItem = pendingItem!.0
-            }
-        } else if tabBar.selectedItem !== selectedItem {
-            tabBar.selectedItem = selectedItem
-        }
-        tabBar.semanticContentAttribute = node.rtl ? .forceRightToLeft : .forceLeftToRight
-        tabBar.accessibilityIdentifier = node.id
-        // Warm after `fit` settles geometry — not on every motion-driven frame sync.
-        if needsTitleWarmup { pendingTitleWarmup.insert(ObjectIdentifier(tabBar)) }
-    }
-
-    @discardableResult
-    static func applyTypography(_ content: ShellItemContent, to item: UITabBarItem) -> Bool {
-        let weight: UIFont.Weight
-        switch content.fontWeight {
-        case ..<150: weight = .ultraLight
-        case ..<250: weight = .thin
-        case ..<350: weight = .light
-        case ..<450: weight = .regular
-        case ..<550: weight = .medium
-        case ..<650: weight = .semibold
-        case ..<750: weight = .bold
-        case ..<850: weight = .heavy
-        default: weight = .black
-        }
-        let font = UIFont.systemFont(ofSize: content.fontSize, weight: weight)
-        var changed = false
-        for state in [UIControl.State.normal, .selected] {
-            if item.titleTextAttributes(for: state)?[.font] as? UIFont != font {
-                item.setTitleTextAttributes([.font: font], for: state)
-                changed = true
-            }
-        }
-        return changed
-    }
-
-    static func applyBadge(_ badge: ShellBadge?, to item: UITabBarItem, rendering: ShellRendering) {
-        // nil removes a badge; an empty string keeps the native notification dot.
-        item.badgeValue = badge?.value
-        item.accessibilityValue = badge?.value
-        item.badgeColor = badge.map { rendering.color($0.color) }
-        let attributes = badge.map { [NSAttributedString.Key.foregroundColor: rendering.color($0.textColor)] }
-        item.setBadgeTextAttributes(attributes, for: .normal)
-        item.setBadgeTextAttributes(attributes, for: .selected)
-    }
-
-    static func fit(_ tabBar: UITabBar, node: ShellControl, bounds: CGRect) -> Bool {
-        // Place a new bar before asking UIKit for its safe-area-dependent size.
-        // Measuring at the initial zero frame makes a restored iPad bar 5pt shorter.
-        if tabBar.bounds.isEmpty {
-            tabBar.frame = bounds
-            tabBar.layoutIfNeeded()
-        }
-        let fitted = tabBar.sizeThatFits(bounds.size)
-        var size = CGSize(width: bounds.width,
-                          height: max(bounds.height, fitted.height))
-        if tabBar.bounds.size != size { tabBar.bounds.size = size }
-        tabBar.layoutIfNeeded()
-        // UIKit's tab content occupies only part of UITabBar's outer frame.
-        // Align that content to ion-tab-bar, whose CSS already owns placement.
-        guard var content = contentFrame(tabBar) else {
-            return false
-        }
-        // Reserve ion-tab-bar's width for the tab content, excluding UIKit's outer gutters.
-        // UIKit can cap the content width for a small number of items.
-        // Do not keep expanding the outer frame beyond its natural size.
-        size.width = min(bounds.width + tabBar.bounds.width - content.width,
-                         max(bounds.width, fitted.width))
-        if abs(tabBar.bounds.width - size.width) > 0.1 {
-            tabBar.bounds.size = size
-            tabBar.layoutIfNeeded()
-            guard let measured = contentFrame(tabBar) else {
-                return false
-            }
-            content = measured
-        }
-        // UIKit owns the adaptive platter size, including changes after badge/title updates.
-        // Preserve the DOM placement anchor instead of requiring identical item widths.
-        let anchor = node.tabBarAnchor
-        let x = anchor?.x ?? 0
-        let y = anchor?.y ?? 0
-        let center = CGPoint(x: bounds.minX + (bounds.width - content.width) * x - content.minX + size.width / 2,
-                             y: bounds.minY + (bounds.height - content.height) * y - content.minY + size.height / 2)
-        if tabBar.center != center { tabBar.center = center }
-        if pendingTitleWarmup.remove(ObjectIdentifier(tabBar)) != nil {
-            warmUnselectedTitleLayout(tabBar)
-        }
-        return true
-    }
-
-    /// iOS 26 only: programmatically visit each unselected item so UIKit measures
-    /// its title the same way a user tap would. Selection does not call the
-    /// tab-bar delegate. No-op on iOS 27+, where first paint already matches Web.
-    static func warmUnselectedTitleLayout(_ tabBar: UITabBar) {
-        let version = ProcessInfo.processInfo.operatingSystemVersion
-        guard version.majorVersion == 26, let items = tabBar.items, items.count > 1 else { return }
-        let selected = tabBar.selectedItem
-        UIView.performWithoutAnimation {
-            for item in items where item !== selected {
-                tabBar.selectedItem = item
-                tabBar.layoutIfNeeded()
-            }
-            if tabBar.selectedItem !== selected {
-                tabBar.selectedItem = selected
-                tabBar.layoutIfNeeded()
-            }
-        }
-    }
-
-    private static func contentFrame(_ tabBar: UITabBar) -> CGRect? {
-        contentFrames(tabBar).reduce(nil) { (result: CGRect?, frame) in result.map { $0.union(frame) } ?? frame }
-    }
-
-    static func contentFrames(_ tabBar: UITabBar) -> [CGRect] {
-        contentViews(tabBar).map { $0.frame }
-    }
-
-    static func contentViews(_ tabBar: UITabBar) -> [UIView] {
-        func containsControl(_ view: UIView) -> Bool {
-            view is UIControl || view.subviews.contains(where: containsControl)
-        }
-        return tabBar.subviews
-            .filter { !$0.isHidden && $0.alpha > 0 && containsControl($0) }
-            .filter { !$0.frame.isEmpty }
-    }
-}