@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/UIKit/Device.swift

@@ -0,0 +1,200 @@
+// The device and its settings, as code that reports on them reads them
+// (analytics, logging, layout tweaks): an iPhone, in light mode, with the
+// accessibility settings off, the browser's language direction and no
+// background time (a page is not suspended into the background with work in
+// flight, so a background task is just a token).
+
+import Foundation
+import FoundationBridge
+import SwiftUI
+
+public enum UIUserInterfaceIdiom: Int, Sendable {
+    case unspecified = -1, phone, pad, tv, carPlay, mac = 5, vision = 6
+}
+
+public enum UIDeviceOrientation: Int, Sendable {
+    case unknown, portrait, portraitUpsideDown, landscapeLeft, landscapeRight, faceUp, faceDown
+    public var isPortrait: Bool { self == .portrait || self == .portraitUpsideDown }
+    public var isLandscape: Bool { self == .landscapeLeft || self == .landscapeRight }
+    public var isFlat: Bool { self == .faceUp || self == .faceDown }
+    public var isValidInterfaceOrientation: Bool { isPortrait || isLandscape }
+}
+
+/// The device: an iPhone running iOS. `@preconcurrency`, as UIKit's
+/// main-actor classes are when Swift imports them from Objective-C: code in
+/// the Swift 5 language mode that reads them off the main actor gets a
+/// warning, not an error.
+@preconcurrency @MainActor
+public final class UIDevice {
+    public static let current = UIDevice()
+
+    public enum BatteryState: Int, Sendable { case unknown, unplugged, charging, full }
+
+    public var name: String { "iPhone" }
+    public var model: String { "iPhone" }
+    public var localizedModel: String { "iPhone" }
+    public var systemName: String { "iOS" }
+    public var systemVersion: String { "18.0" }
+    public var userInterfaceIdiom: UIUserInterfaceIdiom { .phone }
+    public var orientation: UIDeviceOrientation { .portrait }
+    public var isBatteryMonitoringEnabled = false
+    public var batteryLevel: Float { -1 }
+    public var batteryState: BatteryState { .unknown }
+    public var isMultitaskingSupported: Bool { false }
+    public var isGeneratingDeviceOrientationNotifications: Bool { false }
+    public func beginGeneratingDeviceOrientationNotifications() {}
+    public func endGeneratingDeviceOrientationNotifications() {}
+
+    /// The same for every launch of the app in this browser: made once and kept
+    /// in the app's defaults (`SBIdentifierForVendor`).
+    public var identifierForVendor: UUID? {
+        let key = "SBIdentifierForVendor"
+        if let text = FoundationBridge.UserDefaults.standard.string(forKey: key), let id = UUID(uuidString: text) { return id }
+        let id = UUID()
+        FoundationBridge.UserDefaults.standard.set(id.uuidString, forKey: key)
+        return id
+    }
+
+    nonisolated public static let orientationDidChangeNotification = Notification.Name("UIDeviceOrientationDidChangeNotification")
+    nonisolated public static let batteryLevelDidChangeNotification = Notification.Name("UIDeviceBatteryLevelDidChangeNotification")
+    nonisolated public static let batteryStateDidChangeNotification = Notification.Name("UIDeviceBatteryStateDidChangeNotification")
+}
+
+/// The accessibility settings: all off (the page does not read the browser's).
+public enum UIAccessibility {
+    public static var isVoiceOverRunning: Bool { false }
+    public static var isSwitchControlRunning: Bool { false }
+    public static var isReduceMotionEnabled: Bool { false }
+    public static var isReduceTransparencyEnabled: Bool { false }
+    public static var isBoldTextEnabled: Bool { false }
+    public static var isInvertColorsEnabled: Bool { false }
+    public static var isDarkerSystemColorsEnabled: Bool { false }
+    public static var isGrayscaleEnabled: Bool { false }
+    public static var isMonoAudioEnabled: Bool { false }
+    public static var isClosedCaptioningEnabled: Bool { false }
+    public static var isOnOffSwitchLabelsEnabled: Bool { false }
+    public static var isVideoAutoplayEnabled: Bool { true }
+    public static var shouldDifferentiateWithoutColor: Bool { false }
+    public static var prefersCrossFadeTransitions: Bool { false }
+    public static var buttonShapesEnabled: Bool { false }
+
+    public struct Notification: Sendable {
+        public let rawValue: UInt32
+        public init(rawValue: UInt32) { self.rawValue = rawValue }
+        public static let announcement = Notification(rawValue: 1008)
+        public static let screenChanged = Notification(rawValue: 1000)
+        public static let layoutChanged = Notification(rawValue: 1001)
+    }
+
+    /// Nothing reads it out: the page has no screen reader bridge.
+    public static func post(notification: Notification, argument: Any?) {}
+
+    public static let voiceOverStatusDidChangeNotification = Foundation.Notification.Name("UIAccessibilityVoiceOverStatusDidChangeNotification")
+    public static let reduceMotionStatusDidChangeNotification = Foundation.Notification.Name("UIAccessibilityReduceMotionStatusDidChangeNotification")
+    public static let boldTextStatusDidChangeNotification = Foundation.Notification.Name("UIAccessibilityBoldTextStatusDidChangeNotification")
+}
+
+public struct UIContentSizeCategory: RawRepresentable, Hashable, Sendable {
+    public let rawValue: String
+    public init(rawValue: String) { self.rawValue = rawValue }
+    public static let unspecified = UIContentSizeCategory(rawValue: "_UICTContentSizeCategoryUnspecified")
+    public static let extraSmall = UIContentSizeCategory(rawValue: "UICTContentSizeCategoryXS")
+    public static let small = UIContentSizeCategory(rawValue: "UICTContentSizeCategoryS")
+    public static let medium = UIContentSizeCategory(rawValue: "UICTContentSizeCategoryM")
+    public static let large = UIContentSizeCategory(rawValue: "UICTContentSizeCategoryL")
+    public static let extraLarge = UIContentSizeCategory(rawValue: "UICTContentSizeCategoryXL")
+    public static let extraExtraLarge = UIContentSizeCategory(rawValue: "UICTContentSizeCategoryXXL")
+    public static let extraExtraExtraLarge = UIContentSizeCategory(rawValue: "UICTContentSizeCategoryXXXL")
+    public static let accessibilityMedium = UIContentSizeCategory(rawValue: "UICTContentSizeCategoryAccessibilityM")
+    public static let accessibilityLarge = UIContentSizeCategory(rawValue: "UICTContentSizeCategoryAccessibilityL")
+    public static let accessibilityExtraLarge = UIContentSizeCategory(rawValue: "UICTContentSizeCategoryAccessibilityXL")
+    public static let accessibilityExtraExtraLarge = UIContentSizeCategory(rawValue: "UICTContentSizeCategoryAccessibilityXXL")
+    public static let accessibilityExtraExtraExtraLarge = UIContentSizeCategory(rawValue: "UICTContentSizeCategoryAccessibilityXXXL")
+    public var isAccessibilityCategory: Bool { rawValue.contains("Accessibility") }
+    public static let didChangeNotification = Notification.Name("UIContentSizeCategoryDidChangeNotification")
+}
+
+public enum UIUserInterfaceStyle: Int, Sendable { case unspecified, light, dark }
+public enum UIUserInterfaceLayoutDirection: Int, Sendable { case leftToRight, rightToLeft }
+public enum UIUserInterfaceSizeClass: Int, Sendable { case unspecified, compact, regular }
+
+/// The traits views and screens report: light mode, a compact-width iPhone.
+public final class UITraitCollection: @unchecked Sendable {
+    nonisolated(unsafe) public static var current = UITraitCollection()
+    public init() {}
+
+    /// Traits with the given text size (and the rest as `current`'s).
+    public convenience init(preferredContentSizeCategory: UIContentSizeCategory) {
+        self.init()
+        self.preferredContentSizeCategory = preferredContentSizeCategory
+    }
+
+    /// The traits of each collection, later ones winning (only the text size varies here).
+    public convenience init(traitsFrom traitCollections: [UITraitCollection]) {
+        self.init()
+        if let last = traitCollections.last { preferredContentSizeCategory = last.preferredContentSizeCategory }
+    }
+
+    public var userInterfaceStyle: UIUserInterfaceStyle { .light }
+    public var userInterfaceIdiom: UIUserInterfaceIdiom { .phone }
+    public var horizontalSizeClass: UIUserInterfaceSizeClass { .compact }
+    public var verticalSizeClass: UIUserInterfaceSizeClass { .regular }
+    public var displayScale: CGFloat { 3 }
+    public private(set) var preferredContentSizeCategory: UIContentSizeCategory = .large
+    public var layoutDirection: UIUserInterfaceLayoutDirection { .leftToRight }
+}
+
+extension UIScreen {
+    public var traitCollection: UITraitCollection { UITraitCollection.current }
+}
+
+/// A background task's token. The page gets no background time, so a task is just its token.
+public struct UIBackgroundTaskIdentifier: RawRepresentable, Hashable, Sendable {
+    public let rawValue: Int
+    public init(rawValue: Int) { self.rawValue = rawValue }
+    public static let invalid = UIBackgroundTaskIdentifier(rawValue: 0)
+}
+
+extension UIApplication {
+    public var preferredContentSizeCategory: UIContentSizeCategory { .large }
+    public var userInterfaceLayoutDirection: UIUserInterfaceLayoutDirection {
+        Locale.Language(identifier: Locale.current.identifier).characterDirection == .rightToLeft ? .rightToLeft : .leftToRight
+    }
+    public var backgroundTimeRemaining: TimeInterval { 0 }
+
+    public func beginBackgroundTask(withName taskName: String? = nil, expirationHandler handler: (@MainActor @Sendable () -> Void)? = nil) -> UIBackgroundTaskIdentifier {
+        _nextBackgroundTask += 1
+        return UIBackgroundTaskIdentifier(rawValue: _nextBackgroundTask)
+    }
+
+    public func beginBackgroundTask(expirationHandler handler: (@MainActor @Sendable () -> Void)? = nil) -> UIBackgroundTaskIdentifier {
+        beginBackgroundTask(withName: nil, expirationHandler: handler)
+    }
+
+    public func endBackgroundTask(_ identifier: UIBackgroundTaskIdentifier) {}
+}
+
+@MainActor private var _nextBackgroundTask = 0
+
+// MARK: - Traits bridged to SwiftUI (iOS 17)
+
+/// Traits to change, as a trait override writes them. The page's traits are
+/// fixed (an iPhone), so writes are kept but change nothing else.
+public protocol UIMutableTraits {
+    var userInterfaceIdiom: UIUserInterfaceIdiom { get set }
+    var userInterfaceStyle: UIUserInterfaceStyle { get set }
+    var horizontalSizeClass: UIUserInterfaceSizeClass { get set }
+    var verticalSizeClass: UIUserInterfaceSizeClass { get set }
+    var displayScale: CGFloat { get set }
+}
+
+/// A SwiftUI environment key that UIKit traits carry: until a view sets it,
+/// its value is `read(from:)` the current traits.
+public protocol UITraitBridgedEnvironmentKey: _BridgedEnvironmentKey {
+    static func read(from traitCollection: UITraitCollection) -> Value
+    static func write(to mutableTraits: inout UIMutableTraits, value: Value)
+}
+
+extension UITraitBridgedEnvironmentKey {
+    public static var _bridgedDefault: Any { read(from: UITraitCollection.current) }
+}

package/Sources/UIKit/Feedback.swift

@@ -0,0 +1,65 @@
+// UIKit's feedback generators (impact, selection, notification), as apps
+// call them on taps, refreshes and tab changes. They do nothing: a browser
+// cannot drive a Taptic Engine, and the Vibration API that some Android
+// browsers have only buzzes, with no lightness, sharpness or pattern to map
+// these onto. Core Haptics reports the same (`supportsHaptics` is false).
+
+import Foundation
+import SwiftUI
+
+/// The base class of the feedback generators: `prepare()` does nothing.
+@MainActor
+open class UIFeedbackGenerator {
+    public init() {}
+    /// iOS 17.5's form, which ties feedback to a view; the view is not used.
+    public init(view: UIView) {}
+    open func prepare() {}
+}
+
+/// Physical impacts. No feedback: the browser has no haptics.
+@MainActor
+open class UIImpactFeedbackGenerator: UIFeedbackGenerator {
+    public enum FeedbackStyle: Int, Sendable {
+        case light, medium, heavy, soft, rigid
+    }
+
+    public let style: FeedbackStyle
+
+    public init(style: FeedbackStyle) {
+        self.style = style
+        super.init()
+    }
+
+    public override init() {
+        style = .medium
+        super.init()
+    }
+
+    public init(style: FeedbackStyle, view: UIView) {
+        self.style = style
+        super.init(view: view)
+    }
+
+    open func impactOccurred() {}
+    open func impactOccurred(intensity: CGFloat) {}
+    open func impactOccurred(at location: CGPoint) {}
+    open func impactOccurred(intensity: CGFloat, at location: CGPoint) {}
+}
+
+/// Selection changes. No feedback: the browser has no haptics.
+@MainActor
+open class UISelectionFeedbackGenerator: UIFeedbackGenerator {
+    open func selectionChanged() {}
+    open func selectionChanged(at location: CGPoint) {}
+}
+
+/// Successes, warnings and errors. No feedback: the browser has no haptics.
+@MainActor
+open class UINotificationFeedbackGenerator: UIFeedbackGenerator {
+    public enum FeedbackType: Int, Sendable {
+        case success, warning, error
+    }
+
+    open func notificationOccurred(_ notificationType: FeedbackType) {}
+    open func notificationOccurred(_ notificationType: FeedbackType, at location: CGPoint) {}
+}

package/Sources/UIKit/Font.swift

@@ -0,0 +1,307 @@
+// `UIFont`, as code that sizes things by the text uses it: a point size and a
+// name, with the system font's metrics (ascender, cap height, line height)
+// for that size. Text styles follow Dynamic Type with the same table the page
+// lays text out with (Web/src/layout/typography.ts), so a size computed here
+// matches what the page draws. The page draws every family as the system
+// font (`Font.custom`), so a font is its size, weight and design.
+
+import Foundation
+import SwiftUI
+
+open class UIFont: NSObject, NSSecureCoding, @unchecked Sendable {
+    public let pointSize: CGFloat
+    public let fontName: String
+    let weight: Weight
+    let design: UIFontDescriptor.SystemDesign
+
+    public init(name: String, size: CGFloat, weight: Weight = .regular, design: UIFontDescriptor.SystemDesign = .default) {
+        pointSize = size
+        fontName = name
+        self.weight = weight
+        self.design = design
+        super.init()
+    }
+
+    /// A font by name. Never nil: the page draws every family as the system font.
+    public convenience init?(name fontName: String, size fontSize: CGFloat) {
+        self.init(name: fontName, size: fontSize, weight: .regular, design: .default)
+    }
+
+    public convenience init(descriptor: UIFontDescriptor, size pointSize: CGFloat) {
+        self.init(name: descriptor.fontName, size: pointSize > 0 ? pointSize : descriptor.pointSize, weight: descriptor.weight, design: descriptor.design)
+    }
+
+    // MARK: Metrics (SF Pro's, per point)
+
+    public var familyName: String { design == .rounded ? ".AppleSystemUIFontRounded" : ".AppleSystemUIFont" }
+    public var ascender: CGFloat { pointSize * 0.952 }
+    public var descender: CGFloat { -pointSize * 0.241 }
+    public var capHeight: CGFloat { pointSize * 0.705 }
+    public var xHeight: CGFloat { pointSize * 0.53 }
+    public var leading: CGFloat { 0 }
+    /// The line height iOS uses for the standard sizes (17 → 22), else 1.2 × the size.
+    public var lineHeight: CGFloat { UIFont.standardLineHeights[pointSize] ?? (pointSize * 1.2).rounded() }
+
+    public var fontDescriptor: UIFontDescriptor {
+        UIFontDescriptor(fontName: fontName, pointSize: pointSize, weight: weight, design: design)
+    }
+
+    public func withSize(_ fontSize: CGFloat) -> UIFont {
+        UIFont(name: fontName, size: fontSize, weight: weight, design: design)
+    }
+
+    // MARK: System fonts
+
+    public class func systemFont(ofSize fontSize: CGFloat) -> UIFont {
+        systemFont(ofSize: fontSize, weight: .regular)
+    }
+
+    public class func systemFont(ofSize fontSize: CGFloat, weight: Weight) -> UIFont {
+        UIFont(name: ".SFUI-Regular", size: fontSize, weight: weight, design: .default)
+    }
+
+    public class func systemFont(ofSize fontSize: CGFloat, weight: Weight, width: Width) -> UIFont {
+        systemFont(ofSize: fontSize, weight: weight)
+    }
+
+    public class func boldSystemFont(ofSize fontSize: CGFloat) -> UIFont { systemFont(ofSize: fontSize, weight: .bold) }
+    public class func italicSystemFont(ofSize fontSize: CGFloat) -> UIFont { systemFont(ofSize: fontSize) }
+
+    public class func monospacedSystemFont(ofSize fontSize: CGFloat, weight: Weight) -> UIFont {
+        UIFont(name: ".SFMono-Regular", size: fontSize, weight: weight, design: .monospaced)
+    }
+
+    public class func monospacedDigitSystemFont(ofSize fontSize: CGFloat, weight: Weight) -> UIFont {
+        systemFont(ofSize: fontSize, weight: weight)
+    }
+
+    public class var labelFontSize: CGFloat { 17 }
+    public class var buttonFontSize: CGFloat { 18 }
+    public class var smallSystemFontSize: CGFloat { 12 }
+    public class var systemFontSize: CGFloat { 14 }
+
+    public class var familyNames: [String] { [] }
+    public class func fontNames(forFamilyName familyName: String) -> [String] { [] }
+
+    /// The font of a text style at the viewer's text size (Large unless
+    /// `traitCollection` says otherwise).
+    public class func preferredFont(forTextStyle style: TextStyle) -> UIFont {
+        preferredFont(forTextStyle: style, compatibleWith: nil)
+    }
+
+    public class func preferredFont(forTextStyle style: TextStyle, compatibleWith traitCollection: UITraitCollection?) -> UIFont {
+        let category = traitCollection?.preferredContentSizeCategory ?? .large
+        let size = style.sizes[category.dynamicTypeIndex]
+        let weight: Weight = style == .headline ? .semibold : .regular
+        return UIFont(name: ".SFUI-Regular", size: size, weight: weight, design: .default)
+    }
+
+    // MARK: Equality and coding
+
+    open override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? UIFont else { return false }
+        return pointSize == other.pointSize && fontName == other.fontName && weight == other.weight && design == other.design
+    }
+
+    open override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(pointSize)
+        hasher.combine(fontName)
+        return hasher.finalize()
+    }
+
+    public static var supportsSecureCoding: Bool { true }
+
+    public func encode(with coder: NSCoder) {
+        coder.encode(fontName, forKey: "UIFontName")
+        coder.encode(Double(pointSize), forKey: "UIFontPointSize")
+        coder.encode(Double(weight.rawValue), forKey: "UIFontWeight")
+        coder.encode(design.rawValue, forKey: "UIFontDesign")
+    }
+
+    public required init?(coder: NSCoder) {
+        guard let name = coder.decodeObject(forKey: "UIFontName") as? String else { return nil }
+        fontName = name
+        pointSize = CGFloat(coder.decodeDouble(forKey: "UIFontPointSize"))
+        weight = Weight(rawValue: CGFloat(coder.decodeDouble(forKey: "UIFontWeight")))
+        design = (coder.decodeObject(forKey: "UIFontDesign") as? String).map(UIFontDescriptor.SystemDesign.init(rawValue:)) ?? .default
+        super.init()
+    }
+
+    static let standardLineHeights: [CGFloat: CGFloat] = [34: 41, 28: 34, 22: 28, 20: 25, 17: 22, 16: 21, 15: 20, 13: 18, 12: 16, 11: 13]
+
+    // MARK: Nested types
+
+    public struct Weight: RawRepresentable, Hashable, Sendable {
+        public let rawValue: CGFloat
+        public init(rawValue: CGFloat) { self.rawValue = rawValue }
+        public init(_ rawValue: CGFloat) { self.rawValue = rawValue }
+        public static let ultraLight = Weight(rawValue: -0.8)
+        public static let thin = Weight(rawValue: -0.6)
+        public static let light = Weight(rawValue: -0.4)
+        public static let regular = Weight(rawValue: 0)
+        public static let medium = Weight(rawValue: 0.23)
+        public static let semibold = Weight(rawValue: 0.3)
+        public static let bold = Weight(rawValue: 0.4)
+        public static let heavy = Weight(rawValue: 0.56)
+        public static let black = Weight(rawValue: 0.62)
+
+        /// SwiftUI's weight of the same name (the nearest for another value).
+        var swiftUI: Font.Weight {
+            let ladder: [(CGFloat, Font.Weight)] = [(-0.8, .ultraLight), (-0.6, .thin), (-0.4, .light), (0, .regular), (0.23, .medium),
+                                                    (0.3, .semibold), (0.4, .bold), (0.56, .heavy), (0.62, .black)]
+            return ladder.min { abs($0.0 - rawValue) < abs($1.0 - rawValue) }!.1
+        }
+    }
+
+    public struct Width: RawRepresentable, Hashable, Sendable {
+        public let rawValue: CGFloat
+        public init(rawValue: CGFloat) { self.rawValue = rawValue }
+        public static let compressed = Width(rawValue: -0.3)
+        public static let condensed = Width(rawValue: -0.2)
+        public static let standard = Width(rawValue: 0)
+        public static let expanded = Width(rawValue: 0.2)
+    }
+
+    public struct TextStyle: RawRepresentable, Hashable, Sendable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public static let extraLargeTitle = TextStyle(rawValue: "UICTFontTextStyleExtraLargeTitle")
+        public static let extraLargeTitle2 = TextStyle(rawValue: "UICTFontTextStyleExtraLargeTitle2")
+        public static let largeTitle = TextStyle(rawValue: "UICTFontTextStyleTitle0")
+        public static let title1 = TextStyle(rawValue: "UICTFontTextStyleTitle1")
+        public static let title2 = TextStyle(rawValue: "UICTFontTextStyleTitle2")
+        public static let title3 = TextStyle(rawValue: "UICTFontTextStyleTitle3")
+        public static let headline = TextStyle(rawValue: "UICTFontTextStyleHeadline")
+        public static let subheadline = TextStyle(rawValue: "UICTFontTextStyleSubhead")
+        public static let body = TextStyle(rawValue: "UICTFontTextStyleBody")
+        public static let callout = TextStyle(rawValue: "UICTFontTextStyleCallout")
+        public static let footnote = TextStyle(rawValue: "UICTFontTextStyleFootnote")
+        public static let caption1 = TextStyle(rawValue: "UICTFontTextStyleCaption1")
+        public static let caption2 = TextStyle(rawValue: "UICTFontTextStyleCaption2")
+
+        /// Point sizes from xSmall to accessibility5 (Web/src/layout/typography.ts).
+        var sizes: [CGFloat] {
+            switch self {
+            case .largeTitle, .extraLargeTitle, .extraLargeTitle2: [31, 32, 33, 34, 36, 38, 40, 44, 48, 52, 56, 60]
+            case .title1: [25, 26, 27, 28, 30, 32, 34, 38, 43, 48, 53, 58]
+            case .title2: [19, 20, 21, 22, 24, 26, 28, 34, 39, 44, 50, 56]
+            case .title3: [17, 18, 19, 20, 22, 24, 26, 31, 37, 43, 49, 55]
+            case .callout: [13, 14, 15, 16, 18, 20, 22, 26, 32, 38, 44, 51]
+            case .subheadline: [12, 13, 14, 15, 17, 19, 21, 25, 30, 36, 42, 49]
+            case .footnote: [12, 12, 12, 13, 15, 17, 19, 23, 27, 33, 38, 44]
+            case .caption1: [11, 11, 11, 12, 14, 16, 18, 22, 26, 32, 37, 43]
+            case .caption2: [11, 11, 11, 11, 13, 15, 17, 20, 24, 29, 34, 40]
+            default: [14, 15, 16, 17, 19, 21, 23, 28, 33, 40, 47, 53] // body, headline
+            }
+        }
+    }
+}
+
+/// A font's attributes: what `UIFont(descriptor:size:)` makes a font from.
+public final class UIFontDescriptor: NSObject, @unchecked Sendable {
+    public let fontName: String
+    public let pointSize: CGFloat
+    let weight: UIFont.Weight
+    let design: SystemDesign
+
+    init(fontName: String, pointSize: CGFloat, weight: UIFont.Weight, design: SystemDesign) {
+        self.fontName = fontName
+        self.pointSize = pointSize
+        self.weight = weight
+        self.design = design
+    }
+
+    public struct SystemDesign: RawRepresentable, Hashable, Sendable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public static let `default` = SystemDesign(rawValue: "NSCTFontUIFontDesignDefault")
+        public static let rounded = SystemDesign(rawValue: "NSCTFontUIFontDesignRounded")
+        public static let serif = SystemDesign(rawValue: "NSCTFontUIFontDesignSerif")
+        public static let monospaced = SystemDesign(rawValue: "NSCTFontUIFontDesignMonospaced")
+    }
+
+    public func withDesign(_ design: SystemDesign) -> UIFontDescriptor? {
+        UIFontDescriptor(fontName: design == .rounded ? ".AppleSystemUIFontRounded-Regular" : fontName, pointSize: pointSize, weight: weight, design: design)
+    }
+
+    public func withSize(_ newPointSize: CGFloat) -> UIFontDescriptor {
+        UIFontDescriptor(fontName: fontName, pointSize: newPointSize, weight: weight, design: design)
+    }
+
+    public class func preferredFontDescriptor(withTextStyle style: UIFont.TextStyle) -> UIFontDescriptor {
+        UIFont.preferredFont(forTextStyle: style).fontDescriptor
+    }
+}
+
+/// Scales sizes the way Dynamic Type scales a text style: by the ratio of the
+/// style's size at the viewer's setting to its size at Large.
+public struct UIFontMetrics: Sendable {
+    let style: UIFont.TextStyle
+
+    public init(forTextStyle textStyle: UIFont.TextStyle) { style = textStyle }
+
+    public static let `default` = UIFontMetrics(forTextStyle: .body)
+
+    public func scaledValue(for value: CGFloat) -> CGFloat {
+        scaledValue(for: value, compatibleWith: nil)
+    }
+
+    public func scaledValue(for value: CGFloat, compatibleWith traitCollection: UITraitCollection?) -> CGFloat {
+        let category = traitCollection?.preferredContentSizeCategory ?? UITraitCollection.current.preferredContentSizeCategory
+        let sizes = style.sizes
+        return value * sizes[category.dynamicTypeIndex] / sizes[3]
+    }
+
+    public func scaledFont(for font: UIFont) -> UIFont {
+        font.withSize(scaledValue(for: font.pointSize))
+    }
+
+    public func scaledFont(for font: UIFont, maximumPointSize: CGFloat) -> UIFont {
+        font.withSize(min(maximumPointSize, scaledValue(for: font.pointSize)))
+    }
+
+    public func scaledFont(for font: UIFont, compatibleWith traitCollection: UITraitCollection?) -> UIFont {
+        font.withSize(scaledValue(for: font.pointSize, compatibleWith: traitCollection))
+    }
+}
+
+extension UIContentSizeCategory {
+    /// The column of the size tables: xSmall 0 … accessibility5 11 (Large 3).
+    var dynamicTypeIndex: Int {
+        let order: [UIContentSizeCategory] = [.extraSmall, .small, .medium, .large, .extraLarge, .extraExtraLarge, .extraExtraExtraLarge,
+                                              .accessibilityMedium, .accessibilityLarge, .accessibilityExtraLarge,
+                                              .accessibilityExtraExtraLarge, .accessibilityExtraExtraExtraLarge]
+        return order.firstIndex(of: self) ?? 3
+    }
+}
+
+extension Font {
+    /// The font a `UIFont` stands for: its size, weight and design.
+    public init(_ font: UIFont) {
+        let design: Font.Design = switch font.design {
+        case .rounded: .rounded
+        case .serif: .serif
+        case .monospaced: .monospaced
+        default: .default
+        }
+        self = .system(size: font.pointSize, weight: font.weight.swiftUI, design: design)
+    }
+}
+
+extension UIContentSizeCategory {
+    /// The UIKit name of a SwiftUI Dynamic Type size.
+    public init(_ dynamicTypeSize: DynamicTypeSize) {
+        let order: [UIContentSizeCategory] = [.extraSmall, .small, .medium, .large, .extraLarge, .extraExtraLarge, .extraExtraExtraLarge,
+                                              .accessibilityMedium, .accessibilityLarge, .accessibilityExtraLarge,
+                                              .accessibilityExtraExtraLarge, .accessibilityExtraExtraExtraLarge]
+        self = order[dynamicTypeSize.rawValue]
+    }
+}
+
+extension DynamicTypeSize {
+    /// The SwiftUI size of a UIKit content size category (Large for one it has no size for).
+    public init?(_ uiSizeCategory: UIContentSizeCategory) {
+        self.init(rawValue: uiSizeCategory.dynamicTypeIndex)
+    }
+}