@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/UIKit/UIView.swift

@@ -0,0 +1,855 @@
+// UIKit's view classes. Packages that serve both UIKit and SwiftUI apps
+// declare UIKit views next to their SwiftUI ones (NukeUI's `LazyImageView`
+// next to `LazyImage`), and apps put UIKit views on screen with
+// `UIViewRepresentable` (Representable.swift). The classes keep their state
+// (frames, subviews, images, constraints); the page draws a view that a
+// representable shows by translating it into SwiftUI views
+// (ViewTranslation.swift). A change to something drawn tells that
+// representable, so a change made outside a SwiftUI pass (a delegate
+// callback, a timer) is drawn too. Constraints are solved for the simple
+// cases: an edge, center or size equal to the superview's, a sibling's or a
+// constant. Layers draw their color, corner radius, border and opacity (and
+// a layer that draws itself, AVFoundation's `AVPlayerLayer`, its video);
+// nothing animates. A layer is displayed before its view is first drawn, and
+// `setNeedsDisplay()` displays it again at once: its view's `display(_:)`
+// runs, so a view that shows its content from there (Gifu's `GIFImageView`,
+// a frame at a time) is drawn with it.
+
+import Foundation
+import FoundationBridge
+import SwiftUI
+
+// MARK: - Layers and animations
+
+/// A layer: its properties, kept. Its view draws the background color, corner
+/// radius, border and opacity (ViewTranslation.swift); nothing is animated.
+open class CALayer: @unchecked Sendable {
+    open var frame: CGRect = .zero
+    open var bounds: CGRect = .zero
+    open var backgroundColor: CGColor? { didSet { _changed() } }
+    open var cornerRadius: CGFloat = 0 { didSet { _changed() } }
+    open var masksToBounds = false { didSet { _changed() } }
+    open var opacity: Float = 1 { didSet { _changed() } }
+    open var isHidden = false { didSet { _changed() } }
+    open var borderWidth: CGFloat = 0 { didSet { _changed() } }
+    open var borderColor: CGColor? { didSet { _changed() } }
+    open var shadowOpacity: Float = 0
+    open var shadowRadius: CGFloat = 3
+    open var shadowColor: CGColor?
+    open var shadowOffset: CGSize = CGSize(width: 0, height: -3)
+    open var contents: Any?
+    public private(set) var animations: [String: CAAnimation] = [:]
+    /// The view this is the layer of, told when something drawn changes.
+    weak var _view: UIView?
+    /// Asked to display the layer's content: its view, as on iOS.
+    open weak var delegate: (any CALayerDelegate)?
+    private var displayRequested = false
+    private var isDisplaying = false
+    /// Whether the layer was displayed once; the page displays it before
+    /// drawing it the first time, as iOS does a view's layer.
+    public private(set) var _hasDisplayed = false
+    /// Sublayers are kept; of their content only a `_drawing` is drawn.
+    public private(set) var sublayers: [CALayer]?
+    public private(set) weak var superlayer: CALayer?
+
+    /// Required, so a view can make its `layerClass`.
+    public required init() {}
+
+    /// What the layer draws, as SwiftUI, or nil (the default: a layer's own
+    /// content is not drawn). AVFoundation's `AVPlayerLayer` answers its
+    /// player's video; the view whose layer (or sublayer) it is draws it
+    /// filling its bounds (ViewTranslation.swift).
+    open var _drawing: AnyView? { nil }
+
+    open func addSublayer(_ layer: CALayer) {
+        insertSublayer(layer, at: UInt32(sublayers?.count ?? 0))
+    }
+
+    open func insertSublayer(_ layer: CALayer, at index: UInt32) {
+        layer.removeFromSuperlayer()
+        var list = sublayers ?? []
+        list.insert(layer, at: min(Int(index), list.count))
+        sublayers = list
+        layer.superlayer = self
+        _changed()
+    }
+
+    open func insertSublayer(_ layer: CALayer, below sibling: CALayer?) {
+        let index = sibling.flatMap { sibling in sublayers?.firstIndex { $0 === sibling } } ?? 0
+        insertSublayer(layer, at: UInt32(index))
+    }
+
+    open func insertSublayer(_ layer: CALayer, above sibling: CALayer?) {
+        let index = sibling.flatMap { sibling in sublayers?.firstIndex { $0 === sibling }.map { $0 + 1 } } ?? (sublayers?.count ?? 0)
+        insertSublayer(layer, at: UInt32(index))
+    }
+
+    open func replaceSublayer(_ oldLayer: CALayer, with newLayer: CALayer) {
+        guard let index = sublayers?.firstIndex(where: { $0 === oldLayer }) else { return }
+        oldLayer.removeFromSuperlayer()
+        insertSublayer(newLayer, at: UInt32(index))
+    }
+
+    open func removeFromSuperlayer() {
+        guard let parent = superlayer else { return }
+        parent.sublayers?.removeAll { $0 === self }
+        superlayer = nil
+        parent._changed()
+    }
+
+    /// Displays the layer: its delegate's `display(_:)` runs at once (on
+    /// iOS it waits for the frame's commit, a turn of the run loop later). A
+    /// request made while the layer displays is part of that display.
+    open func setNeedsDisplay() {
+        displayRequested = true
+        guard !isDisplaying else { return }
+        displayIfNeeded()
+    }
+
+    open func setNeedsDisplay(_ rect: CGRect) { setNeedsDisplay() }
+
+    open func needsDisplay() -> Bool { displayRequested }
+
+    open func displayIfNeeded() {
+        guard displayRequested else { return }
+        display()
+    }
+
+    /// Asks the delegate to display the layer.
+    open func display() {
+        displayRequested = false
+        _hasDisplayed = true
+        guard let delegate else { return }
+        isDisplaying = true
+        defer {
+            isDisplaying = false
+            displayRequested = false
+        }
+        MainActor.assumeIsolated { delegate.display(self) }
+    }
+
+    open func add(_ animation: CAAnimation, forKey key: String?) {
+        if let key { animations[key] = animation }
+    }
+
+    open func removeAnimation(forKey key: String) { animations[key] = nil }
+    open func removeAllAnimations() { animations = [:] }
+
+    /// Tells the view this layer (or its nearest superlayer) belongs to that
+    /// something drawn changed. Subclasses call it for their own properties.
+    public func _changed() {
+        var layer: CALayer? = self
+        while let current = layer, current._view == nil { layer = current.superlayer }
+        guard let view = layer?._view else { return }
+        MainActor.assumeIsolated { view._setNeedsTranslation() }
+    }
+}
+
+/// What a layer asks of its view. `UIView` implements `display(_:)`; a view
+/// that overrides it shows its content from there.
+@MainActor
+public protocol CALayerDelegate: AnyObject {
+    func display(_ layer: CALayer)
+}
+
+open class CAAnimation: @unchecked Sendable {
+    open var duration: TimeInterval = 0.25
+    open var beginTime: TimeInterval = 0
+    open var repeatCount: Float = 0
+    open var autoreverses = false
+    open var isRemovedOnCompletion = true
+
+    public init() {}
+}
+
+open class CAPropertyAnimation: CAAnimation, @unchecked Sendable {
+    open var keyPath: String?
+
+    public convenience init(keyPath path: String?) {
+        self.init()
+        keyPath = path
+    }
+}
+
+open class CABasicAnimation: CAPropertyAnimation, @unchecked Sendable {
+    open var fromValue: Any?
+    open var toValue: Any?
+    open var byValue: Any?
+}
+
+// MARK: - Layout constraints
+
+/// What an anchor stands for.
+enum _LayoutAttribute: Sendable {
+    case none, leading, trailing, centerX, width, top, bottom, centerY, height
+
+    var isHorizontal: Bool { self == .leading || self == .trailing || self == .centerX || self == .width }
+}
+
+/// A priority, as Auto Layout's (1…1000). Kept; the solver ignores it.
+public struct UILayoutPriority: RawRepresentable, Hashable, Comparable, Sendable, ExpressibleByFloatLiteral, ExpressibleByIntegerLiteral {
+    public let rawValue: Float
+    public init(rawValue: Float) { self.rawValue = rawValue }
+    public init(_ rawValue: Float) { self.rawValue = rawValue }
+    public init(floatLiteral value: Float) { rawValue = value }
+    public init(integerLiteral value: Int) { rawValue = Float(value) }
+    public static func < (lhs: UILayoutPriority, rhs: UILayoutPriority) -> Bool { lhs.rawValue < rhs.rawValue }
+    public static let required = UILayoutPriority(1000)
+    public static let defaultHigh = UILayoutPriority(750)
+    public static let defaultLow = UILayoutPriority(250)
+    public static let fittingSizeLevel = UILayoutPriority(50)
+}
+
+/// A constraint between two anchors (or an anchor and a constant). Active
+/// constraints of the simple kinds are solved when the view tree is laid out
+/// (`UIView.layoutIfNeeded`, and before the page draws it); inequalities
+/// and priorities are kept and ignored.
+open class NSLayoutConstraint: @unchecked Sendable {
+    public enum Relation: Int, Sendable { case lessThanOrEqual = -1, equal = 0, greaterThanOrEqual = 1 }
+
+    open var isActive = false {
+        didSet {
+            guard isActive != oldValue else { return }
+            MainActor.assumeIsolated { register(isActive) }
+        }
+    }
+    open var constant: CGFloat {
+        didSet { MainActor.assumeIsolated { (_first.item ?? _second?.item)?._setNeedsTranslation() } }
+    }
+    open var priority: UILayoutPriority = .required
+    open var identifier: String?
+    public let multiplier: CGFloat
+    public let relation: Relation
+    let _first: _AnchorRef
+    let _second: _AnchorRef?
+
+    init(first: _AnchorRef, second: _AnchorRef?, relation: Relation = .equal, multiplier: CGFloat = 1, constant: CGFloat) {
+        _first = first
+        _second = second
+        self.relation = relation
+        self.multiplier = multiplier
+        self.constant = constant
+    }
+
+    open class func activate(_ constraints: [NSLayoutConstraint]) {
+        for constraint in constraints { constraint.isActive = true }
+    }
+
+    open class func deactivate(_ constraints: [NSLayoutConstraint]) {
+        for constraint in constraints { constraint.isActive = false }
+    }
+
+    /// Activation keeps the constraint on both its views (they hold it, it
+    /// holds them weakly), as the solver looks for it from either side.
+    @MainActor private func register(_ active: Bool) {
+        for item in [_first.item, _second?.item].compactMap({ $0 }) {
+            if active {
+                if !item._layoutConstraints.contains(where: { $0 === self }) { item._layoutConstraints.append(self) }
+            } else {
+                item._layoutConstraints.removeAll { $0 === self }
+            }
+            item._setNeedsTranslation()
+        }
+    }
+}
+
+/// An anchor's view and attribute.
+struct _AnchorRef: @unchecked Sendable {
+    weak var item: UIView?
+    let attribute: _LayoutAttribute
+}
+
+open class NSLayoutAnchor<AnchorType: AnyObject>: @unchecked Sendable {
+    let _ref: _AnchorRef
+
+    public init() { _ref = _AnchorRef(item: nil, attribute: .none) }
+
+    init(item: UIView, attribute: _LayoutAttribute) { _ref = _AnchorRef(item: item, attribute: attribute) }
+
+    open func constraint(equalTo anchor: NSLayoutAnchor<AnchorType>) -> NSLayoutConstraint {
+        NSLayoutConstraint(first: _ref, second: anchor._ref, constant: 0)
+    }
+    open func constraint(equalTo anchor: NSLayoutAnchor<AnchorType>, constant c: CGFloat) -> NSLayoutConstraint {
+        NSLayoutConstraint(first: _ref, second: anchor._ref, constant: c)
+    }
+    open func constraint(greaterThanOrEqualTo anchor: NSLayoutAnchor<AnchorType>, constant c: CGFloat = 0) -> NSLayoutConstraint {
+        NSLayoutConstraint(first: _ref, second: anchor._ref, relation: .greaterThanOrEqual, constant: c)
+    }
+    open func constraint(lessThanOrEqualTo anchor: NSLayoutAnchor<AnchorType>, constant c: CGFloat = 0) -> NSLayoutConstraint {
+        NSLayoutConstraint(first: _ref, second: anchor._ref, relation: .lessThanOrEqual, constant: c)
+    }
+}
+
+open class NSLayoutXAxisAnchor: NSLayoutAnchor<NSLayoutXAxisAnchor>, @unchecked Sendable {}
+open class NSLayoutYAxisAnchor: NSLayoutAnchor<NSLayoutYAxisAnchor>, @unchecked Sendable {}
+
+open class NSLayoutDimension: NSLayoutAnchor<NSLayoutDimension>, @unchecked Sendable {
+    open func constraint(equalToConstant c: CGFloat) -> NSLayoutConstraint {
+        NSLayoutConstraint(first: _ref, second: nil, constant: c)
+    }
+    open func constraint(greaterThanOrEqualToConstant c: CGFloat) -> NSLayoutConstraint {
+        NSLayoutConstraint(first: _ref, second: nil, relation: .greaterThanOrEqual, constant: c)
+    }
+    open func constraint(lessThanOrEqualToConstant c: CGFloat) -> NSLayoutConstraint {
+        NSLayoutConstraint(first: _ref, second: nil, relation: .lessThanOrEqual, constant: c)
+    }
+    open func constraint(equalTo anchor: NSLayoutDimension, multiplier m: CGFloat, constant c: CGFloat = 0) -> NSLayoutConstraint {
+        NSLayoutConstraint(first: _ref, second: anchor._ref, multiplier: m, constant: c)
+    }
+}
+
+// MARK: - Views
+
+/// A view: frames, subviews and appearance. A representable's view is drawn
+/// (ViewTranslation.swift); any other is kept and never drawn.
+@MainActor
+open class UIView: CALayerDelegate {
+    public enum ContentMode: Int, Sendable {
+        case scaleToFill, scaleAspectFit, scaleAspectFill, redraw, center, top, bottom, left, right
+        case topLeft, topRight, bottomLeft, bottomRight
+    }
+
+    public struct AnimationOptions: OptionSet, Sendable {
+        public let rawValue: UInt
+        public init(rawValue: UInt) { self.rawValue = rawValue }
+        public static let allowUserInteraction = AnimationOptions(rawValue: 1 << 1)
+        public static let beginFromCurrentState = AnimationOptions(rawValue: 1 << 2)
+        public static let curveEaseInOut = AnimationOptions([])
+        public static let curveEaseIn = AnimationOptions(rawValue: 1 << 16)
+        public static let curveEaseOut = AnimationOptions(rawValue: 2 << 16)
+        public static let curveLinear = AnimationOptions(rawValue: 3 << 16)
+        public static let transitionCrossDissolve = AnimationOptions(rawValue: 5 << 20)
+    }
+
+    /// How a view's frame follows its superview's size (applied when the
+    /// superview's bounds change, as UIKit does).
+    public struct AutoresizingMask: OptionSet, Sendable {
+        public let rawValue: UInt
+        public init(rawValue: UInt) { self.rawValue = rawValue }
+        public static let flexibleLeftMargin = AutoresizingMask(rawValue: 1 << 0)
+        public static let flexibleWidth = AutoresizingMask(rawValue: 1 << 1)
+        public static let flexibleRightMargin = AutoresizingMask(rawValue: 1 << 2)
+        public static let flexibleTopMargin = AutoresizingMask(rawValue: 1 << 3)
+        public static let flexibleHeight = AutoresizingMask(rawValue: 1 << 4)
+        public static let flexibleBottomMargin = AutoresizingMask(rawValue: 1 << 5)
+    }
+
+    private var storedBounds: CGRect
+    private var storedCenter: CGPoint
+
+    /// Its center and its bounds' size, in the superview's coordinates.
+    open var frame: CGRect {
+        get {
+            CGRect(x: storedCenter.x - storedBounds.width / 2, y: storedCenter.y - storedBounds.height / 2,
+                   width: storedBounds.width, height: storedBounds.height)
+        }
+        set {
+            let oldSize = storedBounds.size
+            storedCenter = CGPoint(x: newValue.midX, y: newValue.midY)
+            storedBounds.size = newValue.size
+            boundsSizeChanged(from: oldSize)
+            _setNeedsTranslation()
+        }
+    }
+    open var bounds: CGRect {
+        get { storedBounds }
+        set {
+            let oldSize = storedBounds.size
+            storedBounds = newValue
+            boundsSizeChanged(from: oldSize)
+            _setNeedsTranslation()
+        }
+    }
+    open var center: CGPoint {
+        get { storedCenter }
+        set {
+            storedCenter = newValue
+            _setNeedsTranslation()
+        }
+    }
+    open var isHidden = false { didSet { _setNeedsTranslation() } }
+    open var alpha: CGFloat = 1 { didSet { _setNeedsTranslation() } }
+    open var backgroundColor: UIColor? { didSet { _setNeedsTranslation() } }
+    open var tintColor: UIColor! = .systemBlue { didSet { _setNeedsTranslation() } }
+    open var contentMode: ContentMode = .scaleToFill { didSet { _setNeedsTranslation() } }
+    open var clipsToBounds = false { didSet { _setNeedsTranslation() } }
+    open var isUserInteractionEnabled = true { didSet { _setNeedsTranslation() } }
+    open var translatesAutoresizingMaskIntoConstraints = true
+    open var autoresizingMask: AutoresizingMask = []
+    open var autoresizesSubviews = true
+    open var tag = 0
+    open var accessibilityLabel: String?
+    open var isAccessibilityElement = false
+    /// The view's layer, an instance of `layerClass` (made on first use).
+    public private(set) lazy var layer: CALayer = {
+        let layer = (type(of: self).layerClass as? CALayer.Type)?.init() ?? CALayer()
+        layer._view = self
+        layer.delegate = self
+        return layer
+    }()
+    /// The class of the view's layer (`AVPlayerLayer` for a player view).
+    open class var layerClass: AnyClass { CALayer.self }
+    public private(set) weak var superview: UIView?
+    public private(set) var subviews: [UIView] = []
+    open var intrinsicContentSize: CGSize { CGSize(width: UIView.noIntrinsicMetric, height: UIView.noIntrinsicMetric) }
+    public static let noIntrinsicMetric: CGFloat = -1
+    public static let layoutFittingCompressedSize = CGSize(width: 0, height: 0)
+    public static let layoutFittingExpandedSize = CGSize(width: 1_000_000, height: 1_000_000)
+    /// Kept; the page follows the app's color scheme.
+    open var overrideUserInterfaceStyle: UIUserInterfaceStyle = .unspecified
+    /// The window the view is in: the nearest `UIWindow` up its superviews.
+    /// SwiftUI draws the page without windows, so a representable's view is
+    /// in none: this is nil for it.
+    open var window: UIWindow? {
+        var current: UIView? = self
+        while let view = current {
+            if let window = view as? UIWindow { return window }
+            current = view.superview
+        }
+        return nil
+    }
+    /// Never called: no UIKit view moves into a window on the page (a
+    /// representable's view included; code waiting for one never hears).
+    open func willMove(toWindow newWindow: UIWindow?) {}
+    open func didMoveToWindow() {}
+    /// Called when the view joins or leaves a superview.
+    open func willMove(toSuperview newSuperview: UIView?) {}
+    open func didMoveToSuperview() {}
+    open func didAddSubview(_ subview: UIView) {}
+    open func willRemoveSubview(_ subview: UIView) {}
+    /// Kept; the browser sends no hardware key commands to UIKit views.
+    open var keyCommands: [UIKeyCommand]? { nil }
+
+    /// Active constraints this view takes part in.
+    var _layoutConstraints: [NSLayoutConstraint] = []
+    /// Set on the root view of a representable (Representable.swift): told
+    /// when something drawn in its tree changes.
+    var _translationHook: (() -> Void)?
+    private var isLayingOut = false
+    private var contentHugging: [NSLayoutConstraint.Axis: UILayoutPriority] = [:]
+    private var compressionResistance: [NSLayoutConstraint.Axis: UILayoutPriority] = [:]
+
+    public init(frame: CGRect) {
+        storedBounds = CGRect(origin: .zero, size: frame.size)
+        storedCenter = CGPoint(x: frame.midX, y: frame.midY)
+        layer._view = self
+    }
+
+    public convenience init() { self.init(frame: .zero) }
+
+    public required init?(coder: NSCoder) {
+        storedBounds = .zero
+        storedCenter = .zero
+        layer._view = self
+    }
+
+    open func addSubview(_ view: UIView) {
+        view.removeFromSuperview()
+        view.willMove(toSuperview: self)
+        subviews.append(view)
+        view.superview = self
+        view.didMoveToSuperview()
+        didAddSubview(view)
+        _setNeedsTranslation()
+    }
+
+    open func insertSubview(_ view: UIView, at index: Int) {
+        view.removeFromSuperview()
+        view.willMove(toSuperview: self)
+        subviews.insert(view, at: min(index, subviews.count))
+        view.superview = self
+        view.didMoveToSuperview()
+        didAddSubview(view)
+        _setNeedsTranslation()
+    }
+
+    open func insertSubview(_ view: UIView, belowSubview siblingSubview: UIView) {
+        insertSubview(view, at: subviews.firstIndex { $0 === siblingSubview } ?? 0)
+    }
+
+    open func insertSubview(_ view: UIView, aboveSubview siblingSubview: UIView) {
+        insertSubview(view, at: (subviews.firstIndex { $0 === siblingSubview } ?? subviews.count - 1) + 1)
+    }
+
+    open func removeFromSuperview() {
+        guard let parent = superview else { return }
+        parent.willRemoveSubview(self)
+        willMove(toSuperview: nil)
+        parent.subviews.removeAll { $0 === self }
+        superview = nil
+        didMoveToSuperview()
+        parent._setNeedsTranslation()
+    }
+
+    open func bringSubviewToFront(_ view: UIView) {
+        guard let index = subviews.firstIndex(where: { $0 === view }) else { return }
+        subviews.append(subviews.remove(at: index))
+        _setNeedsTranslation()
+    }
+
+    open func sendSubviewToBack(_ view: UIView) {
+        guard let index = subviews.firstIndex(where: { $0 === view }) else { return }
+        subviews.insert(subviews.remove(at: index), at: 0)
+        _setNeedsTranslation()
+    }
+
+    open func isDescendant(of view: UIView) -> Bool {
+        var current: UIView? = self
+        while let candidate = current {
+            if candidate === view { return true }
+            current = candidate.superview
+        }
+        return false
+    }
+
+    /// The view is drawn again with its new layout.
+    open func setNeedsLayout() { _setNeedsTranslation() }
+    /// Solves the subviews' constraints and calls `layoutSubviews()`, down the tree.
+    open func layoutIfNeeded() { _layoutTree() }
+    open func layoutSubviews() {}
+    open func setNeedsDisplay() { layer.setNeedsDisplay() }
+    open func setNeedsDisplay(_ rect: CGRect) { setNeedsDisplay() }
+    /// The layer's delegate method: the view is drawn again. A subclass that
+    /// overrides it shows its content from there.
+    open func display(_ layer: CALayer) { _setNeedsTranslation() }
+    /// Whether instances answer a selector. One made from a method
+    /// (`#selector(display(_:))`) names a method the compiler found; one made
+    /// from a string names nothing that can be called.
+    open class func instancesRespond(to aSelector: FoundationBridge.Selector?) -> Bool { aSelector?._hasMethod ?? false }
+    open func setNeedsUpdateConstraints() {}
+    open func updateConstraints() {}
+    open func updateConstraintsIfNeeded() {}
+    /// Resizes the view to `sizeThatFits` its current size.
+    open func sizeToFit() {
+        let size = sizeThatFits(bounds.size)
+        frame = CGRect(origin: frame.origin, size: CGSize(width: max(0, size.width), height: max(0, size.height)))
+    }
+    open func sizeThatFits(_ size: CGSize) -> CGSize {
+        let intrinsic = intrinsicContentSize
+        return CGSize(width: intrinsic.width < 0 ? bounds.width : intrinsic.width,
+                      height: intrinsic.height < 0 ? bounds.height : intrinsic.height)
+    }
+    open func systemLayoutSizeFitting(_ targetSize: CGSize) -> CGSize { sizeThatFits(targetSize) }
+    open func invalidateIntrinsicContentSize() { _setNeedsTranslation() }
+
+    open var constraints: [NSLayoutConstraint] { _layoutConstraints }
+    open func addConstraint(_ constraint: NSLayoutConstraint) { constraint.isActive = true }
+    open func addConstraints(_ constraints: [NSLayoutConstraint]) { NSLayoutConstraint.activate(constraints) }
+    open func removeConstraint(_ constraint: NSLayoutConstraint) { constraint.isActive = false }
+    open func removeConstraints(_ constraints: [NSLayoutConstraint]) { NSLayoutConstraint.deactivate(constraints) }
+
+    open func contentHuggingPriority(for axis: NSLayoutConstraint.Axis) -> UILayoutPriority {
+        contentHugging[axis] ?? .defaultLow
+    }
+    open func setContentHuggingPriority(_ priority: UILayoutPriority, for axis: NSLayoutConstraint.Axis) {
+        contentHugging[axis] = priority
+    }
+    open func contentCompressionResistancePriority(for axis: NSLayoutConstraint.Axis) -> UILayoutPriority {
+        compressionResistance[axis] ?? .defaultHigh
+    }
+    open func setContentCompressionResistancePriority(_ priority: UILayoutPriority, for axis: NSLayoutConstraint.Axis) {
+        compressionResistance[axis] = priority
+    }
+
+    public var topAnchor: NSLayoutYAxisAnchor { NSLayoutYAxisAnchor(item: self, attribute: .top) }
+    public var bottomAnchor: NSLayoutYAxisAnchor { NSLayoutYAxisAnchor(item: self, attribute: .bottom) }
+    public var centerYAnchor: NSLayoutYAxisAnchor { NSLayoutYAxisAnchor(item: self, attribute: .centerY) }
+    public var leftAnchor: NSLayoutXAxisAnchor { NSLayoutXAxisAnchor(item: self, attribute: .leading) }
+    public var rightAnchor: NSLayoutXAxisAnchor { NSLayoutXAxisAnchor(item: self, attribute: .trailing) }
+    public var leadingAnchor: NSLayoutXAxisAnchor { NSLayoutXAxisAnchor(item: self, attribute: .leading) }
+    public var trailingAnchor: NSLayoutXAxisAnchor { NSLayoutXAxisAnchor(item: self, attribute: .trailing) }
+    public var centerXAnchor: NSLayoutXAxisAnchor { NSLayoutXAxisAnchor(item: self, attribute: .centerX) }
+    public var widthAnchor: NSLayoutDimension { NSLayoutDimension(item: self, attribute: .width) }
+    public var heightAnchor: NSLayoutDimension { NSLayoutDimension(item: self, attribute: .height) }
+    /// The view's own edges: the page lays the safe area out around the app (Controls.swift).
+    public private(set) lazy var safeAreaLayoutGuide = UILayoutGuide(owningView: self)
+    /// The view's own edges: margins are kept, not applied.
+    public private(set) lazy var layoutMarginsGuide = UILayoutGuide(owningView: self)
+    open var layoutMargins = UIEdgeInsets(top: 8, left: 8, bottom: 8, right: 8)
+    open var preservesSuperviewLayoutMargins = false
+
+    /// Not called: the page's taps reach buttons and SwiftUI views (Controls.swift).
+    open func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {}
+    open func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?) {}
+    open func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) {}
+    open func touchesCancelled(_ touches: Set<UITouch>, with event: UIEvent?) {}
+
+    /// Runs `animations` at once (nothing animates on the page), then `completion`.
+    public class func animate(withDuration duration: TimeInterval, delay: TimeInterval = 0, options: AnimationOptions = [],
+                              animations: @escaping () -> Void, completion: ((Bool) -> Void)? = nil) {
+        animations()
+        completion?(true)
+    }
+
+    public class func animate(withDuration duration: TimeInterval, animations: @escaping () -> Void) {
+        animations()
+    }
+
+    public class func transition(with view: UIView, duration: TimeInterval, options: AnimationOptions = [],
+                                 animations: (() -> Void)?, completion: ((Bool) -> Void)? = nil) {
+        animations?()
+        completion?(true)
+    }
+
+    public class func performWithoutAnimation(_ actionsWithoutAnimation: () -> Void) {
+        actionsWithoutAnimation()
+    }
+
+    // MARK: Drawing and layout (internal)
+
+    /// Tells the representable showing this view, if any, that something
+    /// drawn changed: it is translated again (Representable.swift decides
+    /// whether that needs a render).
+    func _setNeedsTranslation() {
+        var current: UIView? = self
+        while let view = current {
+            if let hook = view._translationHook {
+                hook()
+                return
+            }
+            current = view.superview
+        }
+    }
+
+    /// Solves the subviews' constraints, then lets the view lay them out
+    /// (`layoutSubviews`), and does the same for each subview.
+    func _layoutTree() {
+        guard !isLayingOut else { return }
+        isLayingOut = true
+        defer { isLayingOut = false }
+        _solveSubviewConstraints()
+        layoutSubviews()
+        for subview in subviews { subview._layoutTree() }
+    }
+
+    /// UIKit's autoresizing: each flexible part of a subview's mask takes a
+    /// share of the change in this view's size.
+    private func boundsSizeChanged(from oldSize: CGSize) {
+        let newSize = storedBounds.size
+        guard autoresizesSubviews, newSize != oldSize, oldSize != .zero || newSize != .zero else { return }
+        for subview in subviews where subview.translatesAutoresizingMaskIntoConstraints && !subview.autoresizingMask.isEmpty {
+            let mask = subview.autoresizingMask
+            var frame = subview.frame
+            func resize(_ origin: inout CGFloat, _ length: inout CGFloat, delta: CGFloat,
+                        flexibleLead: Bool, flexibleLength: Bool, flexibleTrail: Bool, old: CGFloat) {
+                guard delta != 0 else { return }
+                let parts = [flexibleLead ? origin : nil, flexibleLength ? length : nil,
+                             flexibleTrail ? max(0, old - origin - length) : nil].compactMap { $0 }
+                let flexibleCount = [flexibleLead, flexibleLength, flexibleTrail].filter { $0 }.count
+                guard flexibleCount > 0 else { return }
+                let total = parts.reduce(0, +)
+                func share(_ part: CGFloat) -> CGFloat { total > 0 ? delta * part / total : delta / CGFloat(flexibleCount) }
+                let leadShare = flexibleLead ? share(origin) : 0
+                let lengthShare = flexibleLength ? share(length) : 0
+                origin += leadShare
+                length = max(0, length + lengthShare)
+            }
+            resize(&frame.origin.x, &frame.size.width, delta: newSize.width - oldSize.width,
+                   flexibleLead: mask.contains(.flexibleLeftMargin), flexibleLength: mask.contains(.flexibleWidth),
+                   flexibleTrail: mask.contains(.flexibleRightMargin), old: oldSize.width)
+            resize(&frame.origin.y, &frame.size.height, delta: newSize.height - oldSize.height,
+                   flexibleLead: mask.contains(.flexibleTopMargin), flexibleLength: mask.contains(.flexibleHeight),
+                   flexibleTrail: mask.contains(.flexibleBottomMargin), old: oldSize.height)
+            subview.frame = frame
+        }
+    }
+
+    /// Sets the frame of each subview that uses constraints from its active
+    /// equalities with this view, a sibling (already placed: subviews are
+    /// solved in order, twice, so one placed later is seen the second time)
+    /// or a constant. An axis the constraints do not settle keeps the frame's
+    /// value, or the intrinsic size for a length.
+    private func _solveSubviewConstraints() {
+        let constrained = subviews.filter { !$0.translatesAutoresizingMaskIntoConstraints && !$0._layoutConstraints.isEmpty }
+        guard !constrained.isEmpty else { return }
+        for _ in 0..<2 {
+            for subview in constrained { subview._solveConstraints(in: self) }
+        }
+    }
+
+    private func _solveConstraints(in parent: UIView) {
+        // The value of an attribute of a view this one is constrained to, in
+        // the parent's bounds coordinates.
+        func value(of ref: _AnchorRef) -> CGFloat? {
+            guard let item = ref.item else { return nil }
+            let rect: CGRect
+            if item === parent {
+                rect = CGRect(origin: .zero, size: parent.bounds.size)
+            } else if item.superview === parent {
+                rect = item.frame
+            } else {
+                return nil
+            }
+            switch ref.attribute {
+            case .leading: return rect.minX
+            case .trailing: return rect.maxX
+            case .centerX: return rect.midX
+            case .width: return rect.width
+            case .top: return rect.minY
+            case .bottom: return rect.maxY
+            case .centerY: return rect.midY
+            case .height: return rect.height
+            case .none: return nil
+            }
+        }
+        var solved: [_LayoutAttribute: CGFloat] = [:]
+        var aspects: [(attribute: _LayoutAttribute, of: _LayoutAttribute, multiplier: CGFloat, constant: CGFloat)] = []
+        for constraint in _layoutConstraints where constraint.isActive && constraint.relation == .equal {
+            let (mine, other, forward): (_AnchorRef, _AnchorRef?, Bool)
+            if constraint._first.item === self {
+                (mine, other, forward) = (constraint._first, constraint._second, true)
+            } else if let second = constraint._second, second.item === self {
+                (mine, other, forward) = (second, constraint._first, false)
+            } else {
+                continue
+            }
+            if let other, other.item === self {
+                // width = height × m + c (an aspect ratio), settled after the rest.
+                if forward { aspects.append((mine.attribute, other.attribute, constraint.multiplier, constraint.constant)) }
+                continue
+            }
+            let base: CGFloat
+            if let other {
+                guard let v = value(of: other) else { continue }
+                base = v
+            } else {
+                base = 0
+            }
+            // first = second × m + c; read from the second's side, second = (first − c) / m.
+            solved[mine.attribute] = forward
+                ? base * constraint.multiplier + constraint.constant
+                : (constraint.multiplier == 0 ? base : (base - constraint.constant) / constraint.multiplier)
+        }
+        for aspect in aspects where solved[aspect.attribute] == nil {
+            if let length = solved[aspect.of] { solved[aspect.attribute] = length * aspect.multiplier + aspect.constant }
+        }
+        let intrinsic = intrinsicContentSize
+        func axis(lead: CGFloat?, trail: CGFloat?, center: CGFloat?, length: CGFloat?,
+                  intrinsic: CGFloat, current: (origin: CGFloat, length: CGFloat)) -> (CGFloat, CGFloat) {
+            var size = length
+            if size == nil, let lead, let trail { size = trail - lead }
+            if size == nil, let lead, let center { size = 2 * (center - lead) }
+            if size == nil, let trail, let center { size = 2 * (trail - center) }
+            let resolved = max(0, size ?? (intrinsic >= 0 ? intrinsic : current.length))
+            let origin = lead ?? trail.map { $0 - resolved } ?? center.map { $0 - resolved / 2 } ?? current.origin
+            return (origin, resolved)
+        }
+        let current = frame
+        let (x, width) = axis(lead: solved[.leading], trail: solved[.trailing], center: solved[.centerX], length: solved[.width],
+                              intrinsic: intrinsic.width, current: (current.minX, current.width))
+        let (y, height) = axis(lead: solved[.top], trail: solved[.bottom], center: solved[.centerY], length: solved[.height],
+                               intrinsic: intrinsic.height, current: (current.minY, current.height))
+        let next = CGRect(x: x, y: y, width: width, height: height)
+        if next != current { frame = next }
+    }
+}
+
+extension NSLayoutConstraint {
+    /// The two axes of a layout.
+    public enum Axis: Int, Sendable { case horizontal = 0, vertical = 1 }
+}
+
+/// A key command a view answers to; kept, never sent (the page sends keys to
+/// the text views it draws, not to UIKit).
+@MainActor
+open class UIKeyCommand {
+    public let input: String?
+    public let modifierFlags: UIKeyModifierFlags
+    public let action: FoundationBridge.Selector?
+    open var title = ""
+    open var discoverabilityTitle: String?
+    open var wantsPriorityOverSystemBehavior = false
+
+    public init(input: String, modifierFlags: UIKeyModifierFlags, action: FoundationBridge.Selector) {
+        self.input = input
+        self.modifierFlags = modifierFlags
+        self.action = action
+    }
+
+    public init(title: String, action: FoundationBridge.Selector, input: String, modifierFlags: UIKeyModifierFlags = []) {
+        self.title = title
+        self.input = input
+        self.modifierFlags = modifierFlags
+        self.action = action
+    }
+
+    public static let inputEscape = "UIKeyInputEscape"
+    public static let inputUpArrow = "UIKeyInputUpArrow"
+    public static let inputDownArrow = "UIKeyInputDownArrow"
+    public static let inputLeftArrow = "UIKeyInputLeftArrow"
+    public static let inputRightArrow = "UIKeyInputRightArrow"
+    public static let inputPageUp = "UIKeyInputPageUp"
+    public static let inputPageDown = "UIKeyInputPageDown"
+}
+
+public struct UIKeyModifierFlags: OptionSet, Sendable {
+    public let rawValue: Int
+    public init(rawValue: Int) { self.rawValue = rawValue }
+    public static let alphaShift = UIKeyModifierFlags(rawValue: 1 << 16)
+    public static let shift = UIKeyModifierFlags(rawValue: 1 << 17)
+    public static let control = UIKeyModifierFlags(rawValue: 1 << 18)
+    public static let alternate = UIKeyModifierFlags(rawValue: 1 << 19)
+    public static let command = UIKeyModifierFlags(rawValue: 1 << 20)
+}
+
+/// An image view: drawn as an `image` (ViewTranslation.swift), scaled by its
+/// `contentMode`. Animation images are kept, not played; a GIF file shows its
+/// first frame, and a subclass that sets each frame as its image (Gifu's
+/// `GIFImageView`, from `display(_:)`) is drawn a frame at a time.
+@MainActor
+open class UIImageView: UIView {
+    open var image: UIImage? { didSet { _setNeedsTranslation() } }
+    open var highlightedImage: UIImage? { didSet { _setNeedsTranslation() } }
+    open var isHighlighted = false { didSet { _setNeedsTranslation() } }
+    open var animationImages: [UIImage]?
+    open var animationDuration: TimeInterval = 0
+    open var animationRepeatCount = 0
+    open var isAnimating: Bool { false }
+    open var preferredSymbolConfiguration: UIImage.SymbolConfiguration?
+
+    public override init(frame: CGRect) { super.init(frame: frame) }
+
+    public convenience init(image: UIImage?) {
+        self.init(frame: .zero)
+        self.image = image
+        if let image { frame = CGRect(origin: .zero, size: image.size) }
+    }
+
+    public convenience init(image: UIImage?, highlightedImage: UIImage?) {
+        self.init(image: image)
+        self.highlightedImage = highlightedImage
+    }
+
+    public required init?(coder: NSCoder) { super.init(coder: coder) }
+
+    open override var intrinsicContentSize: CGSize { image?.size ?? CGSize(width: -1, height: -1) }
+
+    open func startAnimating() {}
+    open func stopAnimating() {}
+}
+
+/// A spinner: drawn as a `ProgressView` while it spins (or always, when it
+/// does not hide when stopped).
+@MainActor
+open class UIActivityIndicatorView: UIView {
+    public enum Style: Int, Sendable { case medium = 100, large = 101 }
+
+    open var style: Style = .medium { didSet { _setNeedsTranslation() } }
+    open var color: UIColor! { didSet { _setNeedsTranslation() } }
+    open var hidesWhenStopped = true { didSet { _setNeedsTranslation() } }
+    public private(set) var isAnimating = false { didSet { _setNeedsTranslation() } }
+
+    public override init(frame: CGRect) { super.init(frame: frame) }
+
+    public convenience init(style: Style) {
+        self.init(frame: .zero)
+        self.style = style
+    }
+
+    public required init?(coder: NSCoder) { super.init(coder: coder) }
+
+    open override var intrinsicContentSize: CGSize { style == .large ? CGSize(width: 37, height: 37) : CGSize(width: 20, height: 20) }
+
+    open func startAnimating() { isAnimating = true }
+    open func stopAnimating() { isAnimating = false }
+}