@swiftbrowser/swift 0.1.0 → 0.3.0

package/Sources/UIKit/Representable.swift

@@ -0,0 +1,288 @@
+// `UIViewRepresentable` and `UIViewControllerRepresentable`: UIKit views in
+// a SwiftUI tree. On Apple platforms they are SwiftUI API that needs UIKit's
+// types; here they live in UIKit (which `import SwiftUI` brings along), built
+// from public SwiftUI alone, so the reconciler has no special case for them:
+//
+// - A representable's `body` is a `_UIViewRepresentableHost` (or the
+//   controller host), a view with `@State` storage: the runtime keeps it for
+//   as long as the node is mounted, as it keeps any view's state. Its body
+//   makes the coordinator and the view the first time, calls
+//   `updateUIView` on every pass (the parent re-ran with a new
+//   representable, as SwiftUI calls it when the representable's inputs
+//   change), and `.onDisappear` dismantles the view.
+// - The UIKit view tree is drawn by a second view, `_UIKitTranslationHost`,
+//   whose body translates it into SwiftUI views (ViewTranslation.swift).
+//   Its own `@State` revision is bumped when something drawn in the tree
+//   changes outside a pass (a delegate callback, a timer: UIView.swift's
+//   `_setNeedsTranslation`), which renders that node again without calling
+//   `updateUIView`. Changes made while the representable runs (in
+//   `makeUIView` / `updateUIView` or the translation itself) need no bump.
+// - The translation sits in a custom `Layout`, `_UIKitViewLayout`, which the
+//   page measures like any other: it answers the representable's
+//   `sizeThatFits` when that gives a size, else the translated content's
+//   own size (a label or image its natural size, a plain view, scroll view
+//   or text area the proposal). Placing it sets the root view's frame and
+//   lays the tree out (constraints, autoresizing, `layoutSubviews`), so the
+//   UIKit code sees the size SwiftUI gave it.
+
+import Foundation
+import SwiftUI
+
+// MARK: - UIViewRepresentable
+
+/// A UIKit view in a SwiftUI view tree.
+@MainActor @preconcurrency
+public protocol UIViewRepresentable: View {
+    associatedtype UIViewType: UIView
+    associatedtype Coordinator = Void
+    typealias Context = UIViewRepresentableContext<Self>
+
+    /// Makes the view, once per mounted representable.
+    func makeUIView(context: Context) -> UIViewType
+    /// Brings the view up to date with the representable; called after
+    /// `makeUIView` and whenever the parent passes a new representable.
+    func updateUIView(_ uiView: UIViewType, context: Context)
+    /// Called when the representable leaves the tree.
+    static func dismantleUIView(_ uiView: UIViewType, coordinator: Coordinator)
+    /// Makes the object `context.coordinator` is, before `makeUIView`.
+    func makeCoordinator() -> Coordinator
+    /// The size for a proposal, or nil for the view's own (see the top of the file).
+    func sizeThatFits(_ proposal: ProposedViewSize, uiView: UIViewType, context: Context) -> CGSize?
+}
+
+extension UIViewRepresentable where Coordinator == Void {
+    public func makeCoordinator() {}
+}
+
+extension UIViewRepresentable {
+    public static func dismantleUIView(_ uiView: UIViewType, coordinator: Coordinator) {}
+    public func sizeThatFits(_ proposal: ProposedViewSize, uiView: UIViewType, context: Context) -> CGSize? { nil }
+    public var body: _UIViewRepresentableHost<Self> { _UIViewRepresentableHost(representable: self) }
+}
+
+/// What a representable's methods get: its coordinator and the environment.
+@MainActor
+public struct UIViewRepresentableContext<Representable: UIViewRepresentable> {
+    public let coordinator: Representable.Coordinator
+    public var transaction: Transaction
+    public var environment: EnvironmentValues
+}
+
+/// A representable's body: makes, updates and dismantles its view, and
+/// draws it through `_UIKitTranslationHost`.
+@MainActor
+public struct _UIViewRepresentableHost<Representable: UIViewRepresentable>: View {
+    let representable: Representable
+    @State private var storage = _RepresentableStorage<Representable.UIViewType, Representable.Coordinator>()
+    @Environment(\.self) private var environment
+
+    public var body: some View {
+        let storage = self.storage
+        let representable = self.representable
+        storage.box.busy += 1
+        defer { storage.box.busy -= 1 }
+        if storage.view == nil {
+            let coordinator = representable.makeCoordinator()
+            storage.coordinator = coordinator
+            let context = UIViewRepresentableContext<Representable>(coordinator: coordinator, transaction: Transaction(),
+                                                                    environment: environment)
+            let view = representable.makeUIView(context: context)
+            storage.view = view
+            storage.box.root = view
+        }
+        let view = storage.view!
+        let context = UIViewRepresentableContext<Representable>(coordinator: storage.coordinator!, transaction: Transaction(),
+                                                                environment: environment)
+        representable.updateUIView(view, context: context)
+        storage.box.sizeThatFits = { proposal in representable.sizeThatFits(proposal, uiView: view, context: context) }
+        storage.box.pass += 1
+        return _UIKitTranslationHost(box: storage.box, pass: storage.box.pass)
+            .onDisappear {
+                guard let view = storage.view, let coordinator = storage.coordinator else { return }
+                storage.box.detach()
+                storage.view = nil
+                storage.coordinator = nil
+                Representable.dismantleUIView(view, coordinator: coordinator)
+            }
+    }
+}
+
+/// A mounted representable's view and coordinator.
+@MainActor
+final class _RepresentableStorage<ViewType, Coordinator> {
+    var view: ViewType?
+    var coordinator: Coordinator?
+    let box = _UIKitHostBox()
+}
+
+// MARK: - UIViewControllerRepresentable
+
+/// A UIKit view controller in a SwiftUI view tree: its `view` is drawn as a
+/// representable's is. The controller hears `viewWillAppear` /
+/// `viewDidAppear` when it is first drawn and the disappear pair when it
+/// leaves the tree; `dismiss(animated:)` on it (or on a controller it
+/// presents nothing from) dismisses the SwiftUI presentation it is in.
+@MainActor @preconcurrency
+public protocol UIViewControllerRepresentable: View {
+    associatedtype UIViewControllerType: UIViewController
+    associatedtype Coordinator = Void
+    typealias Context = UIViewControllerRepresentableContext<Self>
+
+    func makeUIViewController(context: Context) -> UIViewControllerType
+    func updateUIViewController(_ uiViewController: UIViewControllerType, context: Context)
+    static func dismantleUIViewController(_ uiViewController: UIViewControllerType, coordinator: Coordinator)
+    func makeCoordinator() -> Coordinator
+    func sizeThatFits(_ proposal: ProposedViewSize, uiViewController: UIViewControllerType, context: Context) -> CGSize?
+}
+
+extension UIViewControllerRepresentable where Coordinator == Void {
+    public func makeCoordinator() {}
+}
+
+extension UIViewControllerRepresentable {
+    public static func dismantleUIViewController(_ uiViewController: UIViewControllerType, coordinator: Coordinator) {}
+    public func sizeThatFits(_ proposal: ProposedViewSize, uiViewController: UIViewControllerType, context: Context) -> CGSize? { nil }
+    public var body: _UIViewControllerRepresentableHost<Self> { _UIViewControllerRepresentableHost(representable: self) }
+}
+
+@MainActor
+public struct UIViewControllerRepresentableContext<Representable: UIViewControllerRepresentable> {
+    public let coordinator: Representable.Coordinator
+    public var transaction: Transaction
+    public var environment: EnvironmentValues
+}
+
+/// A controller representable's body, like `_UIViewRepresentableHost`.
+@MainActor
+public struct _UIViewControllerRepresentableHost<Representable: UIViewControllerRepresentable>: View {
+    let representable: Representable
+    @State private var storage = _RepresentableStorage<Representable.UIViewControllerType, Representable.Coordinator>()
+    @Environment(\.self) private var environment
+
+    public var body: some View {
+        let storage = self.storage
+        let representable = self.representable
+        storage.box.busy += 1
+        defer { storage.box.busy -= 1 }
+        var appearing = false
+        if storage.view == nil {
+            let coordinator = representable.makeCoordinator()
+            storage.coordinator = coordinator
+            let context = UIViewControllerRepresentableContext<Representable>(coordinator: coordinator, transaction: Transaction(),
+                                                                              environment: environment)
+            let controller = representable.makeUIViewController(context: context)
+            storage.view = controller
+            storage.box.root = controller.view
+            storage.box.controller = controller
+            appearing = true
+        }
+        let controller = storage.view!
+        let dismiss = environment.dismiss
+        controller._representableDismiss = { dismiss() }
+        let context = UIViewControllerRepresentableContext<Representable>(coordinator: storage.coordinator!, transaction: Transaction(),
+                                                                          environment: environment)
+        representable.updateUIViewController(controller, context: context)
+        if appearing { controller.viewWillAppear(false) }
+        storage.box.sizeThatFits = { proposal in representable.sizeThatFits(proposal, uiViewController: controller, context: context) }
+        storage.box.pass += 1
+        return _UIKitTranslationHost(box: storage.box, pass: storage.box.pass)
+            .onAppear { controller.viewDidAppear(false) }
+            .onDisappear {
+                guard let controller = storage.view, let coordinator = storage.coordinator else { return }
+                controller.viewWillDisappear(false)
+                storage.box.detach()
+                storage.view = nil
+                storage.coordinator = nil
+                controller._representableDismiss = nil
+                controller.viewDidDisappear(false)
+                Representable.dismantleUIViewController(controller, coordinator: coordinator)
+            }
+    }
+}
+
+// MARK: - Drawing
+
+/// What the two halves of a representable share: the root view, whether a
+/// representable is running (changes then need no render), how to render the
+/// translation again, and the representable's own `sizeThatFits`.
+@MainActor
+final class _UIKitHostBox {
+    var root: UIView? {
+        didSet {
+            oldValue?._translationHook = nil
+            root?._translationHook = { [weak self] in self?.changed() }
+        }
+    }
+    /// The controller whose view `root` is, told about layout.
+    weak var controller: UIViewController?
+    /// Above zero while the representable or the translation runs.
+    var busy = 0
+    /// Counts the representable's passes, so the translation host's value
+    /// differs on each and re-runs with it.
+    var pass = 0
+    var sizeThatFits: (ProposedViewSize) -> CGSize? = { _ in nil }
+    /// Bumps the translation host's revision (set by its body).
+    var invalidate: (() -> Void)?
+
+    func changed() {
+        guard busy == 0 else { return }
+        invalidate?()
+    }
+
+    func detach() {
+        root?._translationHook = nil
+        invalidate = nil
+    }
+
+    /// The layout placed the root at `size`: lay the tree out at that size
+    /// and draw it again if it changed.
+    func placed(size: CGSize) {
+        guard let root, root.bounds.size != size || root.frame.origin != .zero else { return }
+        busy += 1
+        controller?.viewWillLayoutSubviews()
+        root.frame = CGRect(origin: .zero, size: size)
+        root._layoutTree()
+        controller?.viewDidLayoutSubviews()
+        busy -= 1
+        changed()
+    }
+}
+
+/// Draws a representable's view tree: lays it out and translates it. Its
+/// revision is what a change outside a pass bumps.
+struct _UIKitTranslationHost: View {
+    let box: _UIKitHostBox
+    let pass: Int
+    @State private var revision = 0
+
+    var body: some View {
+        let box = self.box
+        let revision = $revision
+        box.invalidate = { revision.wrappedValue &+= 1 }
+        box.busy += 1
+        defer { box.busy -= 1 }
+        guard let root = box.root else { return AnyView(EmptyView()) }
+        root._layoutTree()
+        return AnyView(_UIKitViewLayout(box: box) { _UIViewTranslator.view(for: root, isRoot: true) })
+    }
+}
+
+/// Sizes and places a representable's drawing (see the top of the file).
+struct _UIKitViewLayout: Layout {
+    let box: _UIKitHostBox
+
+    // The layout runs on the main actor (the page's event handler), but
+    // `Layout`'s requirements are nonisolated, as SwiftUI's are.
+    func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
+        let box = self.box
+        if let size = MainActor.assumeIsolated({ box.sizeThatFits(proposal) }) { return size }
+        guard let content = subviews.first else { return proposal.replacingUnspecifiedDimensions(by: .zero) }
+        return content.sizeThatFits(proposal)
+    }
+
+    func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {
+        subviews.first?.place(at: bounds.origin, anchor: .topLeading, proposal: ProposedViewSize(bounds.size))
+        let box = self.box
+        MainActor.assumeIsolated { box.placed(size: bounds.size) }
+    }
+}

package/Sources/UIKit/SafeArea.swift

@@ -0,0 +1,12 @@
+// The safe area of UIKit views. A view is in no window on the page
+// ("UIKit views in SwiftUI"), and SwiftUI lays the page out inside the
+// device's safe area itself, so a view's safe-area insets are zero (a
+// window's too: the page does not report its insets to Swift).
+
+import Foundation
+import SwiftUI
+
+extension UIView {
+    /// Zero (see the file comment).
+    public var safeAreaInsets: UIEdgeInsets { .zero }
+}

package/Sources/UIKit/SceneDelegates.swift

@@ -0,0 +1,132 @@
+// Scene delegates, as apps declare them (`UIWindowSceneDelegate`, its
+// session and connection options). The page is the app's one scene: after
+// launching, `@UIApplicationDelegateAdaptor` connects it, making the delegate
+// class the app delegate's configuration names and calling
+// `scene(_:willConnectTo:options:)`, `sceneWillEnterForeground` and
+// `sceneDidBecomeActive` (`_SceneConnection` below). The later lifecycle
+// (background, disconnect) is not reported.
+
+import Foundation
+import Observation
+import SwiftUI
+
+/// What a scene tells its delegate. Every method has a default that does nothing.
+@MainActor
+public protocol UISceneDelegate: AnyObject {
+    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions)
+    func sceneDidDisconnect(_ scene: UIScene)
+    func sceneDidBecomeActive(_ scene: UIScene)
+    func sceneWillResignActive(_ scene: UIScene)
+    func sceneWillEnterForeground(_ scene: UIScene)
+    func sceneDidEnterBackground(_ scene: UIScene)
+}
+
+extension UISceneDelegate {
+    public func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {}
+    public func sceneDidDisconnect(_ scene: UIScene) {}
+    public func sceneDidBecomeActive(_ scene: UIScene) {}
+    public func sceneWillResignActive(_ scene: UIScene) {}
+    public func sceneWillEnterForeground(_ scene: UIScene) {}
+    public func sceneDidEnterBackground(_ scene: UIScene) {}
+}
+
+/// A scene delegate with a window (none in the browser).
+@MainActor
+public protocol UIWindowSceneDelegate: UISceneDelegate {
+    var window: UIWindow? { get set }
+}
+
+extension UIWindowSceneDelegate {
+    public var window: UIWindow? {
+        get { nil }
+        set {}
+    }
+}
+
+/// A scene's session: its role and configuration, kept.
+@MainActor
+open class UISceneSession {
+    public struct Role: RawRepresentable, Hashable, Sendable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public static let windowApplication = Role(rawValue: "UIWindowSceneSessionRoleApplication")
+    }
+
+    public let role: Role
+    public let persistentIdentifier: String
+    public var userInfo: [String: Any]?
+
+    public init(role: Role = .windowApplication) {
+        self.role = role
+        persistentIdentifier = UUID().uuidString
+    }
+}
+
+/// How a scene configuration names its delegate class, kept.
+@MainActor
+open class UISceneConfiguration {
+    public let name: String?
+    public let role: UISceneSession.Role
+    public var delegateClass: AnyClass?
+    /// Makes an instance of `delegateClass`. UIKit makes one through the
+    /// Objective-C runtime; Swift without it cannot call a class's `init()`
+    /// through a metatype unless the initializer is `required`, so the
+    /// staging rewrites `configuration.delegateClass = SceneDelegate.self`
+    /// into `_setDelegateClass(SceneDelegate.self) { SceneDelegate() }`.
+    public private(set) var _makeDelegate: (() -> AnyObject)?
+
+    public init(name: String?, sessionRole: UISceneSession.Role) {
+        self.name = name
+        role = sessionRole
+    }
+
+    /// `delegateClass = type`, with the way to make one (see `_makeDelegate`).
+    public func _setDelegateClass<T: AnyObject>(_ type: T.Type, make: @escaping () -> T) {
+        delegateClass = type
+        _makeDelegate = make
+    }
+}
+
+extension UIScene {
+    /// What the scene connected with: no URLs, activities or shortcut items in the browser.
+    @MainActor
+    open class ConnectionOptions {
+        public init() {}
+        open var urlContexts: Set<AnyHashable> { [] }
+        open var shortcutItem: UIApplicationShortcutItem? { nil }
+        open var sourceApplication: String? { nil }
+    }
+}
+
+// MARK: - Connecting the page's scene
+
+@MainActor
+enum _SceneConnection {
+    /// The page's scene delegate, made once (strongly held, as `UIScene.delegate` is).
+    static var delegate: AnyObject?
+
+    /// Connects the page's scene as UIKit does after launching: asks the app
+    /// delegate for the scene's configuration, makes its delegate class, and
+    /// tells the delegate the scene connected, entered the foreground and
+    /// became active. SwiftUI puts a scene delegate that is `Observable` or an
+    /// `ObservableObject` in the environment, so `@Environment(SceneDelegate.self)`
+    /// finds it.
+    static func connect(_ appDelegate: any UIApplicationDelegate) {
+        guard delegate == nil else { return }
+        let session = UISceneSession(role: .windowApplication)
+        let configuration = appDelegate.application(UIApplication.shared, configurationForConnecting: session, options: UIScene.ConnectionOptions())
+        guard let make = configuration._makeDelegate else { return }
+        let sceneDelegate = make()
+        delegate = sceneDelegate
+        let scene = UIApplication.pageScene
+        scene.delegate = sceneDelegate as? any UISceneDelegate
+        if let sceneDelegate = sceneDelegate as? any UISceneDelegate {
+            sceneDelegate.scene(scene, willConnectTo: session, options: UIScene.ConnectionOptions())
+            sceneDelegate.sceneWillEnterForeground(scene)
+            sceneDelegate.sceneDidBecomeActive(scene)
+        }
+        if sceneDelegate is any Observable || sceneDelegate is any ObservableObject {
+            _Runtime.shared._addRootEnvironmentObject(sceneDelegate)
+        }
+    }
+}

package/Sources/UIKit/Scenes.swift

@@ -0,0 +1,40 @@
+// UIKit's scenes, as code that looks for "the current window scene" uses
+// them (to present StoreKit's sheets near it, say). The page is the app's
+// one scene: `UIApplication.shared.connectedScenes` holds a single
+// `UIWindowScene`, always foreground-active. It has no `UIWindow`s, since
+// SwiftUI draws the page, so `windows` is empty and `keyWindow` nil.
+
+import SwiftUI
+
+/// A scene: one instance of the app's interface.
+@MainActor
+open class UIScene: Hashable {
+    public enum ActivationState: Int, Sendable {
+        case unattached = -1, foregroundActive = 0, foregroundInactive = 1, background = 2
+    }
+
+    public init() {}
+
+    open var activationState: ActivationState { .foregroundActive }
+    /// The scene's delegate: the app delegate's configuration names its class (SceneDelegates.swift).
+    open var delegate: (any UISceneDelegate)?
+    open var title: String! = ""
+
+    nonisolated public static func == (lhs: UIScene, rhs: UIScene) -> Bool { lhs === rhs }
+    nonisolated public func hash(into hasher: inout Hasher) { hasher.combine(ObjectIdentifier(self)) }
+}
+
+/// A scene with windows: in the browser, the page.
+@MainActor
+open class UIWindowScene: UIScene {
+    open var windows: [UIWindow] { [] }
+    open var keyWindow: UIWindow? { nil }
+    open var screen: UIScreen { .main }
+}
+
+extension UIApplication {
+    static let pageScene = UIWindowScene()
+
+    /// The page, the app's only scene.
+    public var connectedScenes: Set<UIScene> { [UIApplication.pageScene] }
+}

package/Sources/UIKit/ScrollView.swift

@@ -0,0 +1,157 @@
+// `UIScrollView` and its delegate. A representable's scroll view is drawn as
+// a SwiftUI `ScrollView` over its subviews when its content is larger than
+// its bounds, else as a plain container (ViewTranslation.swift). Zooming is
+// state: `setZoomScale` and `zoom(to:animated:)` set the scale and offset and
+// tell the delegate at once, and the page draws the delegate's
+// `viewForZooming` scaled about the visible rectangle's center. Pinching,
+// panning a zoomed view and reading the user's scroll offset back are not
+// there (`contentOffset` only changes when the app sets it).
+
+import Foundation
+import SwiftUI
+
+/// Distances inside a rectangle's edges.
+public struct UIEdgeInsets: Hashable, Sendable {
+    public var top: CGFloat
+    public var left: CGFloat
+    public var bottom: CGFloat
+    public var right: CGFloat
+
+    public init(top: CGFloat, left: CGFloat, bottom: CGFloat, right: CGFloat) {
+        (self.top, self.left, self.bottom, self.right) = (top, left, bottom, right)
+    }
+
+    public init() { self.init(top: 0, left: 0, bottom: 0, right: 0) }
+
+    public static let zero = UIEdgeInsets()
+}
+
+/// What a scroll view tells its delegate. Every method has a default (they
+/// are `@objc optional` on iOS).
+@MainActor
+public protocol UIScrollViewDelegate: AnyObject {
+    func scrollViewDidScroll(_ scrollView: UIScrollView)
+    func scrollViewDidZoom(_ scrollView: UIScrollView)
+    func scrollViewWillBeginDragging(_ scrollView: UIScrollView)
+    func scrollViewDidEndDragging(_ scrollView: UIScrollView, willDecelerate decelerate: Bool)
+    func scrollViewDidEndDecelerating(_ scrollView: UIScrollView)
+    func scrollViewDidEndScrollingAnimation(_ scrollView: UIScrollView)
+    func viewForZooming(in scrollView: UIScrollView) -> UIView?
+    func scrollViewWillBeginZooming(_ scrollView: UIScrollView, with view: UIView?)
+    func scrollViewDidEndZooming(_ scrollView: UIScrollView, with view: UIView?, atScale scale: CGFloat)
+    func scrollViewShouldScrollToTop(_ scrollView: UIScrollView) -> Bool
+    func scrollViewDidScrollToTop(_ scrollView: UIScrollView)
+}
+
+extension UIScrollViewDelegate {
+    public func scrollViewDidScroll(_ scrollView: UIScrollView) {}
+    public func scrollViewDidZoom(_ scrollView: UIScrollView) {}
+    public func scrollViewWillBeginDragging(_ scrollView: UIScrollView) {}
+    public func scrollViewDidEndDragging(_ scrollView: UIScrollView, willDecelerate decelerate: Bool) {}
+    public func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {}
+    public func scrollViewDidEndScrollingAnimation(_ scrollView: UIScrollView) {}
+    public func viewForZooming(in scrollView: UIScrollView) -> UIView? { nil }
+    public func scrollViewWillBeginZooming(_ scrollView: UIScrollView, with view: UIView?) {}
+    public func scrollViewDidEndZooming(_ scrollView: UIScrollView, with view: UIView?, atScale scale: CGFloat) {}
+    public func scrollViewShouldScrollToTop(_ scrollView: UIScrollView) -> Bool { true }
+    public func scrollViewDidScrollToTop(_ scrollView: UIScrollView) {}
+}
+
+/// Gives `UIScrollView` its `delegate` from a protocol extension, so that
+/// `UITextView` can declare a `delegate` of its own delegate type (Swift
+/// cannot override a property with another type, as Objective-C UIKit does).
+@MainActor
+public protocol _UIScrollViewDelegating: AnyObject {}
+
+extension _UIScrollViewDelegating where Self: UIScrollView {
+    public var delegate: UIScrollViewDelegate? {
+        get { _scrollDelegate }
+        set { _scrollDelegate = newValue }
+    }
+}
+
+/// A scroll view: drawn as a `ScrollView` when a representable shows it;
+/// offset, insets and zoom kept (see the top of the file).
+@MainActor
+open class UIScrollView: UIView, _UIScrollViewDelegating {
+    public enum KeyboardDismissMode: Int, Sendable { case none, onDrag, interactive, onDragWithAccessory, interactiveWithAccessory }
+    public enum ContentInsetAdjustmentBehavior: Int, Sendable { case automatic, scrollableAxes, never, always }
+    public enum IndicatorStyle: Int, Sendable { case `default`, black, white }
+
+    /// The delegate (`delegate`, from `_UIScrollViewDelegating`).
+    weak var _scrollDelegate: UIScrollViewDelegate?
+    open var contentOffset: CGPoint = .zero {
+        didSet {
+            guard contentOffset != oldValue else { return }
+            _setNeedsTranslation()
+            _scrollDelegate?.scrollViewDidScroll(self)
+        }
+    }
+    open var contentSize: CGSize = .zero { didSet { _setNeedsTranslation() } }
+    open var contentInset: UIEdgeInsets = .zero { didSet { _setNeedsTranslation() } }
+    open var adjustedContentInset: UIEdgeInsets { contentInset }
+    open var contentInsetAdjustmentBehavior: ContentInsetAdjustmentBehavior = .automatic
+    open var scrollIndicatorInsets: UIEdgeInsets = .zero
+    open var verticalScrollIndicatorInsets: UIEdgeInsets = .zero
+    open var horizontalScrollIndicatorInsets: UIEdgeInsets = .zero
+    open var indicatorStyle: IndicatorStyle = .default
+    open var isScrollEnabled = true { didSet { _setNeedsTranslation() } }
+    open var isPagingEnabled = false
+    open var isDirectionalLockEnabled = false
+    open var bounces = true
+    open var alwaysBounceVertical = false
+    open var alwaysBounceHorizontal = false
+    open var showsVerticalScrollIndicator = true { didSet { _setNeedsTranslation() } }
+    open var showsHorizontalScrollIndicator = true { didSet { _setNeedsTranslation() } }
+    open var scrollsToTop = true
+    open var keyboardDismissMode: KeyboardDismissMode = .none
+    open var decelerationRate: CGFloat = 0.998
+    open var minimumZoomScale: CGFloat = 1
+    open var maximumZoomScale: CGFloat = 1
+    open var bouncesZoom = true
+    open var zoomScale: CGFloat {
+        get { storedZoomScale }
+        set { setZoomScale(newValue, animated: false) }
+    }
+    public var isTracking: Bool { false }
+    public var isDragging: Bool { false }
+    public var isDecelerating: Bool { false }
+    public var isZooming: Bool { false }
+    public var isZoomBouncing: Bool { false }
+    private var storedZoomScale: CGFloat = 1
+
+    open func setContentOffset(_ contentOffset: CGPoint, animated: Bool) {
+        self.contentOffset = contentOffset
+    }
+
+    open func scrollRectToVisible(_ rect: CGRect, animated: Bool) {
+        var offset = contentOffset
+        if rect.minX < offset.x { offset.x = rect.minX } else if rect.maxX > offset.x + bounds.width { offset.x = rect.maxX - bounds.width }
+        if rect.minY < offset.y { offset.y = rect.minY } else if rect.maxY > offset.y + bounds.height { offset.y = rect.maxY - bounds.height }
+        contentOffset = offset
+    }
+
+    /// Sets the scale (within the minimum and maximum) and tells the delegate
+    /// it zoomed and ended zooming, as a finished gesture would.
+    open func setZoomScale(_ scale: CGFloat, animated: Bool) {
+        let clamped = min(max(scale, minimumZoomScale), max(minimumZoomScale, maximumZoomScale))
+        guard clamped != storedZoomScale else { return }
+        let zoomed = _scrollDelegate?.viewForZooming(in: self)
+        _scrollDelegate?.scrollViewWillBeginZooming(self, with: zoomed)
+        storedZoomScale = clamped
+        _setNeedsTranslation()
+        _scrollDelegate?.scrollViewDidZoom(self)
+        _scrollDelegate?.scrollViewDidEndZooming(self, with: zoomed, atScale: clamped)
+    }
+
+    /// Zooms so that `rect` (in the zoomed view's unscaled coordinates) fills the bounds.
+    open func zoom(to rect: CGRect, animated: Bool) {
+        guard rect.width > 0, rect.height > 0 else { return }
+        let scale = min(bounds.width / rect.width, bounds.height / rect.height)
+        setZoomScale(scale, animated: animated)
+        contentOffset = CGPoint(x: max(0, rect.midX * zoomScale - bounds.width / 2),
+                                y: max(0, rect.midY * zoomScale - bounds.height / 2))
+    }
+
+    open func flashScrollIndicators() {}
+}