@swiftbrowser/swift 0.1.0 → 0.3.0

package/Sources/UIKit/Alerts.swift

@@ -0,0 +1,69 @@
+// UIKit's alerts and action sheets, as code builds them: a
+// `UIAlertController` with its title, message, actions and text fields. Like
+// any presented view controller (Introspectable.swift), presenting one
+// records it and shows nothing, so no action's handler is called; SwiftUI's
+// `.alert` and `.confirmationDialog` are what the page shows.
+
+import Foundation
+import FoundationBridge
+import SwiftUI
+
+/// An alert's button: its title, style and handler.
+@MainActor
+open class UIAlertAction {
+    public enum Style: Int, Sendable {
+        case `default` = 0
+        case cancel = 1
+        case destructive = 2
+    }
+
+    public let title: String?
+    public let style: Style
+    open var isEnabled = true
+    let handler: ((UIAlertAction) -> Void)?
+
+    public init(title: String?, style: Style, handler: ((UIAlertAction) -> Void)? = nil) {
+        self.title = title
+        self.style = style
+        self.handler = handler
+    }
+}
+
+/// An alert or action sheet. Presenting it shows nothing (see above).
+@MainActor
+open class UIAlertController: UIViewController {
+    public enum Style: Int, Sendable {
+        case actionSheet = 0
+        case alert = 1
+    }
+
+    open var message: String?
+    public let preferredStyle: Style
+    public private(set) var actions: [UIAlertAction] = []
+    open var preferredAction: UIAlertAction?
+    public private(set) var textFields: [UITextField]?
+    open var severity: UIAlertControllerSeverity = .default
+
+    public init(title: String?, message: String?, preferredStyle: Style) {
+        self.message = message
+        self.preferredStyle = preferredStyle
+        super.init(nibName: nil, bundle: nil)
+        self.title = title
+    }
+
+    public required init?(coder: NSCoder) { nil }
+
+    open func addAction(_ action: UIAlertAction) { actions.append(action) }
+
+    open func addTextField(configurationHandler: ((UITextField) -> Void)? = nil) {
+        let field = UITextField()
+        configurationHandler?(field)
+        textFields = (textFields ?? []) + [field]
+    }
+}
+
+/// How serious an alert is (Mac Catalyst); kept.
+public enum UIAlertControllerSeverity: Int, Sendable {
+    case `default` = 0
+    case critical = 1
+}

package/Sources/UIKit/AppDelegate.swift

@@ -0,0 +1,222 @@
+// The application delegate, as SwiftUI apps adopt one with
+// `@UIApplicationDelegateAdaptor`, and the UIKit types its methods name.
+//
+// The adaptor makes the delegate once, when the app is created, sets it as
+// `UIApplication.shared.delegate`, and calls
+// `application(_:willFinishLaunchingWithOptions:)` then
+// `application(_:didFinishLaunchingWithOptions:)` (no launch options), as
+// UIKit does before the first scene. The other methods are not called: the
+// page gets no device token (RemoteNotifications.swift), no remote
+// notifications or background fetches. The page's one scene connects after
+// launching: the delegate's `configurationForConnecting` names the scene
+// delegate class, which is made and told the scene connected, and an
+// observable scene delegate goes in the environment, as SwiftUI does
+// (SceneDelegates.swift). Responders here are only what a delegate inherits
+// from; views do not take part in a responder chain. `buildMenu(with:)` is
+// never called (there is no menu bar), and alternate app icons are not
+// supported (a web page has one icon).
+
+import Foundation
+import FoundationBridge
+import SwiftUI
+
+/// What an app delegate inherits: an object in UIKit's responder chain.
+@MainActor
+open class UIResponder {
+    public required init() {}
+
+    /// Nil: views do not form a responder chain here.
+    open var next: UIResponder? { nil }
+    open var canBecomeFirstResponder: Bool { false }
+    open var isFirstResponder: Bool { false }
+    @discardableResult open func becomeFirstResponder() -> Bool { false }
+    @discardableResult open func resignFirstResponder() -> Bool { true }
+
+    /// Never called: there is no menu bar.
+    open func buildMenu(with builder: any UIMenuBuilder) {}
+    open func validate(_ command: UICommand) {}
+}
+
+/// The app's delegate. Every method has a default; the adaptor calls the
+/// launching ones (see the file comment).
+@MainActor
+public protocol UIApplicationDelegate: AnyObject {
+    func application(_ application: UIApplication, willFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool
+    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool
+    func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data)
+    func application(_ application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: any Error)
+    func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable: Any]) async -> UIBackgroundFetchResult
+    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession,
+                     options: UIScene.ConnectionOptions) -> UISceneConfiguration
+    func applicationDidBecomeActive(_ application: UIApplication)
+    func applicationWillResignActive(_ application: UIApplication)
+    func applicationDidEnterBackground(_ application: UIApplication)
+    func applicationWillEnterForeground(_ application: UIApplication)
+    func applicationWillTerminate(_ application: UIApplication)
+}
+
+extension UIApplicationDelegate {
+    public func application(_ application: UIApplication, willFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool { true }
+    public func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool { true }
+    public func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {}
+    public func application(_ application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: any Error) {}
+    public func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable: Any]) async -> UIBackgroundFetchResult { .noData }
+    public func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession,
+                            options: UIScene.ConnectionOptions) -> UISceneConfiguration {
+        UISceneConfiguration(name: nil, sessionRole: connectingSceneSession.role)
+    }
+    public func applicationDidBecomeActive(_ application: UIApplication) {}
+    public func applicationWillResignActive(_ application: UIApplication) {}
+    public func applicationDidEnterBackground(_ application: UIApplication) {}
+    public func applicationWillEnterForeground(_ application: UIApplication) {}
+    public func applicationWillTerminate(_ application: UIApplication) {}
+}
+
+/// What a background fetch or a remote notification's handling found.
+public enum UIBackgroundFetchResult: UInt, Sendable {
+    case newData, noData, failed
+}
+
+extension UIApplication {
+    /// Keys of the launch options a delegate is handed (none in the browser).
+    public struct LaunchOptionsKey: Hashable, RawRepresentable, Sendable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public static let url = LaunchOptionsKey(rawValue: "UIApplicationLaunchOptionsURLKey")
+        public static let remoteNotification = LaunchOptionsKey(rawValue: "UIApplicationLaunchOptionsRemoteNotificationKey")
+        public static let shortcutItem = LaunchOptionsKey(rawValue: "UIApplicationLaunchOptionsShortcutItemKey")
+        public static let userActivityDictionary = LaunchOptionsKey(rawValue: "UIApplicationLaunchOptionsUserActivityDictionaryKey")
+    }
+
+    /// The app's delegate: the one `@UIApplicationDelegateAdaptor` made.
+    public var delegate: (any UIApplicationDelegate)? {
+        get { _UIApplicationDelegateStorage.delegate }
+        set { _UIApplicationDelegateStorage.delegate = newValue }
+    }
+
+    /// False: a web page has one icon.
+    public var supportsAlternateIcons: Bool { false }
+    /// Nil: the primary icon.
+    public var alternateIconName: String? { nil }
+
+    /// Fails: alternate icons are not supported (the handler gets the error on the next turn).
+    public func setAlternateIconName(_ alternateIconName: String?, completionHandler: (@MainActor @Sendable ((any Error)?) -> Void)? = nil) {
+        guard let completionHandler else { return }
+        Task { @MainActor in completionHandler(Self.alternateIconsUnsupported) }
+    }
+
+    public func setAlternateIconName(_ alternateIconName: String?) async throws {
+        throw Self.alternateIconsUnsupported
+    }
+
+    static var alternateIconsUnsupported: NSError {
+        NSError(domain: "NSCocoaErrorDomain", code: 3328,
+                userInfo: [NSLocalizedDescriptionKey: "Alternate app icons are not supported in the browser."])
+    }
+}
+
+@MainActor
+enum _UIApplicationDelegateStorage {
+    static var delegate: (any UIApplicationDelegate)?
+}
+
+/// Makes the app's delegate (see the file comment).
+@MainActor
+@propertyWrapper
+public struct UIApplicationDelegateAdaptor<DelegateType: UIResponder & UIApplicationDelegate>: DynamicProperty {
+    let delegate: DelegateType
+
+    public init(_ delegateType: DelegateType.Type = DelegateType.self) {
+        delegate = Self.launch { delegateType.init() }
+    }
+
+    /// The delegate made the first time; later adaptors (the app value made again) share it.
+    static func launch(_ make: () -> DelegateType) -> DelegateType {
+        if let existing = _UIApplicationDelegateStorage.delegate as? DelegateType { return existing }
+        let delegate = make()
+        _UIApplicationDelegateStorage.delegate = delegate
+        _ = delegate.application(UIApplication.shared, willFinishLaunchingWithOptions: nil)
+        _ = delegate.application(UIApplication.shared, didFinishLaunchingWithOptions: nil)
+        _SceneConnection.connect(delegate)
+        return delegate
+    }
+
+    public var wrappedValue: DelegateType { delegate }
+}
+
+// MARK: - Menus
+
+/// A menu bar's builder: there is no menu bar, so nothing is built.
+@MainActor
+public protocol UIMenuBuilder {
+    func menu(for identifier: UIMenu.Identifier) -> UIMenu?
+    func remove(menu removedIdentifier: UIMenu.Identifier)
+    func insertChild(_ childMenu: UIMenu, atStartOfMenu parentIdentifier: UIMenu.Identifier)
+    func insertChild(_ childMenu: UIMenu, atEndOfMenu parentIdentifier: UIMenu.Identifier)
+    func replace(menu replacedIdentifier: UIMenu.Identifier, with replacementMenu: UIMenu)
+}
+
+/// An element of a UIKit menu.
+@MainActor
+open class UIMenuElement {
+    public let title: String
+    public let image: UIImage?
+
+    init(title: String, image: UIImage?) {
+        self.title = title
+        self.image = image
+    }
+}
+
+/// A UIKit menu: kept, never shown.
+@MainActor
+open class UIMenu: UIMenuElement {
+    public struct Identifier: Hashable, RawRepresentable, Sendable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public init(_ rawValue: String) { self.rawValue = rawValue }
+        public static let application = Identifier("com.apple.menu.application")
+        public static let file = Identifier("com.apple.menu.file")
+        public static let edit = Identifier("com.apple.menu.edit")
+        public static let view = Identifier("com.apple.menu.view")
+        public static let window = Identifier("com.apple.menu.window")
+        public static let help = Identifier("com.apple.menu.help")
+        public static let format = Identifier("com.apple.menu.format")
+        public static let document = Identifier("com.apple.menu.document")
+        public static let toolbar = Identifier("com.apple.menu.toolbar")
+        public static let close = Identifier("com.apple.menu.close")
+        public static let newScene = Identifier("com.apple.menu.new-scene")
+        public static let preferences = Identifier("com.apple.menu.preferences")
+    }
+
+    public struct Options: OptionSet, Hashable, Sendable {
+        public let rawValue: UInt
+        public init(rawValue: UInt) { self.rawValue = rawValue }
+        public static let displayInline = Options(rawValue: 1 << 0)
+        public static let destructive = Options(rawValue: 1 << 1)
+        public static let singleSelection = Options(rawValue: 1 << 5)
+    }
+
+    public let identifier: Identifier
+    public let options: Options
+    public let children: [UIMenuElement]
+
+    public init(title: String = "", image: UIImage? = nil, identifier: Identifier? = nil, options: Options = [],
+                children: [UIMenuElement] = []) {
+        self.identifier = identifier ?? Identifier(UUID().uuidString)
+        self.options = options
+        self.children = children
+        super.init(title: title, image: image)
+    }
+}
+
+/// A menu command; kept, never shown.
+@MainActor
+open class UICommand: UIMenuElement {
+    public let action: FoundationBridge.Selector
+
+    public init(title: String, image: UIImage? = nil, action: FoundationBridge.Selector) {
+        self.action = action
+        super.init(title: title, image: image)
+    }
+}

package/Sources/UIKit/Appearance.swift

@@ -0,0 +1,84 @@
+// UIKit's appearance proxies: `UINavigationBar.appearance().barTintColor = …`
+// styles every navigation bar on iOS. The page draws its own bars, tab bars
+// and lists from SwiftUI's elements, and no UIKit view of a class reaches it
+// (UIView.swift, Introspectable.swift), so here a proxy only records: what is
+// set on it reads back from it, and nothing else changes. Ice Cubes' theme
+// sets the bars' tint this way.
+
+import Foundation
+import FoundationBridge
+import SwiftUI
+
+/// A type whose instances share settings through an appearance proxy.
+@MainActor
+public protocol UIAppearance: AnyObject {
+    /// The proxy for every instance of the class.
+    static func appearance() -> Self
+    /// The proxy for instances inside instances of `containerTypes` (outermost last).
+    static func appearance(whenContainedInInstancesOf containerTypes: [any UIAppearanceContainer.Type]) -> Self
+    /// The proxy for instances with `trait`'s traits.
+    static func appearance(for trait: UITraitCollection) -> Self
+    /// The proxy for instances with `trait`'s traits inside instances of `containerTypes`.
+    static func appearance(for trait: UITraitCollection,
+                           whenContainedInInstancesOf containerTypes: [any UIAppearanceContainer.Type]) -> Self
+}
+
+/// A type an appearance proxy can be scoped to: views and view controllers.
+@MainActor
+public protocol UIAppearanceContainer: AnyObject {}
+
+extension UIView: UIAppearanceContainer {}
+extension UIViewController: UIAppearanceContainer {}
+
+/// The proxies made so far, one per class and scope, kept for the app's life.
+@MainActor
+enum _UIAppearanceProxies {
+    static var proxies: [String: UIView] = [:]
+
+    /// Unarchiving an empty archive: how a proxy of a class is made without
+    /// knowing its initializers (`init?(coder:)` is UIView's required one).
+    final class Coder: NSCoder {}
+
+    static func proxy<V: UIView>(_ type: V.Type, scope: String) -> V {
+        let key = "\(ObjectIdentifier(type).hashValue)|\(scope)"
+        if let proxy = proxies[key] as? V { return proxy }
+        guard let proxy = type.init(coder: Coder()) else {
+            fatalError("\(type).init(coder:) returned nil, so it has no appearance proxy")
+        }
+        proxies[key] = proxy
+        return proxy
+    }
+
+    static func scope(_ containers: [any UIAppearanceContainer.Type], trait: UITraitCollection?) -> String {
+        let names = containers.map { String(reflecting: $0) }.joined(separator: ",")
+        return trait.map { "\(names)|\($0.userInterfaceStyle.rawValue)" } ?? names
+    }
+}
+
+extension UIView: UIAppearance {
+    /// The class's appearance proxy: an instance of the class, made once
+    /// (with `init?(coder:)` and an empty archive, the initializer every
+    /// view has), whose properties read back what the app set on them.
+    /// They are not copied to other instances: no UIKit view of the class is
+    /// drawn on the page, which follows SwiftUI's own styling.
+    public static func appearance() -> Self {
+        _UIAppearanceProxies.proxy(self, scope: "")
+    }
+
+    /// The proxy for views inside `containerTypes`, kept apart from the
+    /// class's own; recorded like it.
+    public static func appearance(whenContainedInInstancesOf containerTypes: [any UIAppearanceContainer.Type]) -> Self {
+        _UIAppearanceProxies.proxy(self, scope: _UIAppearanceProxies.scope(containerTypes, trait: nil))
+    }
+
+    /// The proxy for views with `trait`'s interface style; recorded.
+    public static func appearance(for trait: UITraitCollection) -> Self {
+        _UIAppearanceProxies.proxy(self, scope: _UIAppearanceProxies.scope([], trait: trait))
+    }
+
+    /// The proxy for views with `trait`'s interface style inside `containerTypes`; recorded.
+    public static func appearance(for trait: UITraitCollection,
+                                  whenContainedInInstancesOf containerTypes: [any UIAppearanceContainer.Type]) -> Self {
+        _UIAppearanceProxies.proxy(self, scope: _UIAppearanceProxies.scope(containerTypes, trait: trait))
+    }
+}

package/Sources/UIKit/ColorConversions.swift

@@ -0,0 +1,70 @@
+// Converting between SwiftUI's `Color`, `UIColor` and Core Image's `CIColor`.
+// A color with components converts exactly. A semantic color (the palette,
+// `primary`, UIKit's semantic colors) becomes UIKit's semantic color of that
+// name, which keeps following the color scheme through `Color(uiColor:)` and
+// has its light-mode components; a color from the asset catalog is the
+// page's to resolve, so it converts to black.
+
+import Foundation
+import SwiftUI
+
+extension UIColor {
+    /// The color's components (see the top of this file for semantic and catalog colors).
+    public convenience init(_ color: Color) {
+        guard case .object(let fields) = color._json else { self.init(white: 0, alpha: 1); return }
+        func number(_ key: String) -> CGFloat? {
+            if case .number(let value)? = fields[key] { return CGFloat(value) }
+            return nil
+        }
+        if let r = number("r"), let g = number("g"), let b = number("b") {
+            self.init(red: r, green: g, blue: b, alpha: number("a") ?? 1)
+            return
+        }
+        let opacity = number("a") ?? number("opacity") ?? 1
+        guard case .string(let name)? = fields["name"], let base = UIColor.semanticColors[name] else {
+            self.init(white: 0, alpha: opacity)
+            return
+        }
+        if let semantic = base.semantic {
+            self.init(semantic: semantic.name, opacity: opacity, red: base.red, green: base.green, blue: base.blue, alpha: base.alpha * opacity)
+        } else {
+            self.init(red: base.red, green: base.green, blue: base.blue, alpha: base.alpha * opacity)
+        }
+    }
+
+    /// UIKit's color for each semantic `Color` name.
+    static let semanticColors: [String: UIColor] = {
+        var colors: [String: UIColor] = ["primary": .label, "secondary": .secondaryLabel, "clear": .clear,
+                                             // The app's accent color is the page's; system blue is its default.
+                                             "accent": UIColor(red: 0, green: 0.533, blue: 1, alpha: 1)]
+        let named: [UIColor] = [
+            .systemRed, .systemOrange, .systemYellow, .systemGreen, .systemMint, .systemTeal, .systemCyan, .systemBlue,
+            .systemIndigo, .systemPurple, .systemPink, .systemBrown, .systemGray,
+            .systemBackground, .secondarySystemBackground, .tertiarySystemBackground,
+            .systemGroupedBackground, .secondarySystemGroupedBackground, .tertiarySystemGroupedBackground,
+            .label, .secondaryLabel, .tertiaryLabel, .quaternaryLabel, .placeholderText, .separator, .opaqueSeparator,
+            .systemFill, .secondarySystemFill, .tertiarySystemFill, .quaternarySystemFill,
+            .systemGray2, .systemGray3, .systemGray4, .systemGray5, .systemGray6,
+        ]
+        for color in named {
+            if let name = color.semantic?.name { colors[name] = color }
+        }
+        return colors
+    }()
+
+    public convenience init(ciColor: CIColor) {
+        self.init(red: ciColor.red, green: ciColor.green, blue: ciColor.blue, alpha: ciColor.alpha)
+    }
+
+    public var ciColor: CIColor { CIColor(color: self) }
+}
+
+extension CIColor {
+    public convenience init(color: UIColor) {
+        self.init(red: color.red, green: color.green, blue: color.blue, alpha: color.alpha)
+    }
+
+    public convenience init(cgColor: CGColor) {
+        self.init(color: UIColor(cgColor: cgColor))
+    }
+}

package/Sources/UIKit/Controls.swift

@@ -0,0 +1,225 @@
+// UIKit pieces that view controllers built in code use, as far as camera
+// screens (CodeScanner's `ScannerViewController`) need them: buttons, touches,
+// layout guides, supported orientations and presentation delegates.
+//
+// - `UIButton` keeps a title, title color, image and background image per
+//   state and is drawn as a SwiftUI `Button` (ViewTranslation.swift) whose tap
+//   sends the button's `.touchUpInside` and `.primaryActionTriggered` actions.
+// - Touches are not delivered: the page's taps reach buttons and SwiftUI views,
+//   not `touchesBegan(_:with:)`, which views and controllers have to override.
+// - A view's `safeAreaLayoutGuide` and `layoutMarginsGuide` are its own edges
+//   (the page lays the safe area out around the app; margins are not applied).
+
+import Foundation
+import FoundationBridge
+import SwiftUI
+
+extension UIControl {
+    public struct State: OptionSet, Hashable, Sendable {
+        public let rawValue: UInt
+        public init(rawValue: UInt) { self.rawValue = rawValue }
+        public static let normal = State([])
+        public static let highlighted = State(rawValue: 1 << 0)
+        public static let disabled = State(rawValue: 1 << 1)
+        public static let selected = State(rawValue: 1 << 2)
+        public static let focused = State(rawValue: 1 << 3)
+    }
+}
+
+/// A button: drawn as a SwiftUI `Button` with its normal title and images.
+@MainActor
+open class UIButton: UIControl {
+    public enum ButtonType: Int, Sendable {
+        case custom = 0, system, detailDisclosure, infoLight, infoDark, contactAdd, close
+        public static let plain = ButtonType.system
+    }
+
+    public let buttonType: ButtonType
+    private var titles: [UInt: String] = [:]
+    private var titleColors: [UInt: UIColor] = [:]
+    private var images: [UInt: UIImage] = [:]
+    private var backgroundImages: [UInt: UIImage] = [:]
+
+    public override init(frame: CGRect) {
+        buttonType = .custom
+        super.init(frame: frame)
+    }
+
+    public init(type buttonType: ButtonType) {
+        self.buttonType = buttonType
+        super.init(frame: .zero)
+    }
+
+    public required init?(coder: NSCoder) {
+        buttonType = .custom
+        super.init(coder: coder)
+    }
+
+    open func setTitle(_ title: String?, for state: UIControl.State) {
+        titles[state.rawValue] = title
+        _setNeedsTranslation()
+    }
+
+    open func setTitleColor(_ color: UIColor?, for state: UIControl.State) {
+        titleColors[state.rawValue] = color
+        _setNeedsTranslation()
+    }
+
+    open func setImage(_ image: UIImage?, for state: UIControl.State) {
+        images[state.rawValue] = image
+        _setNeedsTranslation()
+    }
+
+    open func setBackgroundImage(_ image: UIImage?, for state: UIControl.State) {
+        backgroundImages[state.rawValue] = image
+        _setNeedsTranslation()
+    }
+
+    /// The value for `state`, else the normal state's, as UIKit falls back.
+    open func title(for state: UIControl.State) -> String? { titles[state.rawValue] ?? titles[0] }
+    open func titleColor(for state: UIControl.State) -> UIColor? { titleColors[state.rawValue] ?? titleColors[0] }
+    open func image(for state: UIControl.State) -> UIImage? { images[state.rawValue] ?? images[0] }
+    open func backgroundImage(for state: UIControl.State) -> UIImage? { backgroundImages[state.rawValue] ?? backgroundImages[0] }
+
+    open var currentTitle: String? { title(for: .normal) }
+    open var currentTitleColor: UIColor { titleColor(for: .normal) ?? (buttonType == .custom ? .white : tintColor) }
+    open var currentImage: UIImage? { image(for: .normal) }
+    open var currentBackgroundImage: UIImage? { backgroundImage(for: .normal) }
+
+    open override var intrinsicContentSize: CGSize {
+        let text = CGFloat(currentTitle?.count ?? 0) * 9
+        let image = currentImage?.size ?? .zero
+        let background = currentBackgroundImage?.size ?? .zero
+        return CGSize(width: max(text + image.width + (text > 0 ? 16 : 0), background.width, 30),
+                      height: max(image.height, background.height, 30))
+    }
+
+    /// What a tap does: the actions for `.touchUpInside` and `.primaryActionTriggered`.
+    public func _tap() {
+        guard isEnabled else { return }
+        sendActions(for: [.touchUpInside, .primaryActionTriggered])
+    }
+}
+
+// MARK: - Touches
+
+/// A finger on the screen. The page does not deliver touches to UIKit views.
+@MainActor
+open class UITouch {
+    public enum Phase: Int, Sendable { case began, moved, stationary, ended, cancelled }
+    public enum TouchType: Int, Sendable { case direct, indirect, pencil }
+
+    open var view: UIView?
+    open var window: UIWindow? { nil }
+    open var phase: Phase = .began
+    open var tapCount = 1
+    open var type: TouchType = .direct
+    open var timestamp: TimeInterval = 0
+    let point: CGPoint
+
+    public init() { point = .zero }
+
+    open func location(in view: UIView?) -> CGPoint { point }
+    open func previousLocation(in view: UIView?) -> CGPoint { point }
+}
+
+/// An event's touches.
+@MainActor
+open class UIEvent {
+    public enum EventType: Int, Sendable { case touches, motion, remoteControl, presses }
+    open var type: EventType { .touches }
+    open var allTouches: Set<UITouch>? { nil }
+    open var timestamp: TimeInterval { 0 }
+    public init() {}
+}
+
+extension UITouch: @preconcurrency Hashable {
+    nonisolated public static func == (lhs: UITouch, rhs: UITouch) -> Bool { lhs === rhs }
+    nonisolated public func hash(into hasher: inout Hasher) { hasher.combine(ObjectIdentifier(self)) }
+}
+
+// MARK: - Layout guides
+
+/// A rectangle constraints can refer to: here, its view's own edges.
+@MainActor
+open class UILayoutGuide {
+    public private(set) weak var owningView: UIView?
+    open var identifier = ""
+
+    public init() {}
+    init(owningView: UIView) { self.owningView = owningView }
+
+    open var layoutFrame: CGRect { owningView?.bounds ?? .zero }
+
+    /// The view the anchors are on (a guide no view owns anchors to nothing).
+    private var view: UIView { owningView ?? UIView(frame: .zero) }
+
+    public var topAnchor: NSLayoutYAxisAnchor { view.topAnchor }
+    public var bottomAnchor: NSLayoutYAxisAnchor { view.bottomAnchor }
+    public var centerYAnchor: NSLayoutYAxisAnchor { view.centerYAnchor }
+    public var leadingAnchor: NSLayoutXAxisAnchor { view.leadingAnchor }
+    public var trailingAnchor: NSLayoutXAxisAnchor { view.trailingAnchor }
+    public var leftAnchor: NSLayoutXAxisAnchor { view.leftAnchor }
+    public var rightAnchor: NSLayoutXAxisAnchor { view.rightAnchor }
+    public var centerXAnchor: NSLayoutXAxisAnchor { view.centerXAnchor }
+    public var widthAnchor: NSLayoutDimension { view.widthAnchor }
+    public var heightAnchor: NSLayoutDimension { view.heightAnchor }
+}
+
+// MARK: - Orientation
+
+public struct UIInterfaceOrientationMask: OptionSet, Hashable, Sendable {
+    public let rawValue: UInt
+    public init(rawValue: UInt) { self.rawValue = rawValue }
+    public static let portrait = UIInterfaceOrientationMask(rawValue: 1 << 1)
+    public static let portraitUpsideDown = UIInterfaceOrientationMask(rawValue: 1 << 2)
+    public static let landscapeRight = UIInterfaceOrientationMask(rawValue: 1 << 3)
+    public static let landscapeLeft = UIInterfaceOrientationMask(rawValue: 1 << 4)
+    public static let landscape: UIInterfaceOrientationMask = [.landscapeLeft, .landscapeRight]
+    public static let all: UIInterfaceOrientationMask = [.portrait, .portraitUpsideDown, .landscapeLeft, .landscapeRight]
+    public static let allButUpsideDown: UIInterfaceOrientationMask = [.portrait, .landscapeLeft, .landscapeRight]
+}
+
+/// The page's orientation: portrait, as the phone frame is.
+public enum UIInterfaceOrientation: Int, Sendable {
+    case unknown = 0, portrait, portraitUpsideDown, landscapeLeft, landscapeRight
+    public var isPortrait: Bool { self == .portrait || self == .portraitUpsideDown }
+    public var isLandscape: Bool { self == .landscapeLeft || self == .landscapeRight }
+}
+
+extension UIWindowScene {
+    public var interfaceOrientation: UIInterfaceOrientation { .portrait }
+}
+
+// MARK: - Presentation delegates
+
+/// Told about a presentation the viewer dismissed. The page's presentations
+/// are SwiftUI's, so it is never called for a UIKit one.
+@MainActor
+public protocol UIAdaptivePresentationControllerDelegate: AnyObject {
+    func presentationControllerDidDismiss(_ presentationController: UIPresentationController)
+    func presentationControllerWillDismiss(_ presentationController: UIPresentationController)
+    func presentationControllerShouldDismiss(_ presentationController: UIPresentationController) -> Bool
+    func presentationControllerDidAttemptToDismiss(_ presentationController: UIPresentationController)
+}
+
+extension UIAdaptivePresentationControllerDelegate {
+    public func presentationControllerDidDismiss(_ presentationController: UIPresentationController) {}
+    public func presentationControllerWillDismiss(_ presentationController: UIPresentationController) {}
+    public func presentationControllerShouldDismiss(_ presentationController: UIPresentationController) -> Bool { true }
+    public func presentationControllerDidAttemptToDismiss(_ presentationController: UIPresentationController) {}
+}
+
+// MARK: - Images from a bundle
+
+extension UIImage {
+    /// The catalog image `name` (the app's catalogs: a package's are not
+    /// published), whatever the bundle and configuration.
+    public convenience init?(named name: String, in bundle: FoundationBridge.Bundle?, with configuration: UIImage.Configuration?) {
+        self.init(named: name)
+    }
+
+    public convenience init?(named name: String, in bundle: FoundationBridge.Bundle?, compatibleWith traitCollection: UITraitCollection?) {
+        self.init(named: name)
+    }
+}