@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/UIKit/Introspectable.swift

@@ -0,0 +1,510 @@
+// UIKit's scroll views, text inputs, controls, windows, view controllers and
+// presentation controllers, as declarations. SwiftUI-Introspect (the real
+// package, built against the shim) types its closures with them: on iOS
+// SwiftUI draws a `List` with a `UICollectionView`, a `TextField` with a
+// `UITextField`, and the library finds that object next to its own probe
+// view controller and hands it to the app. In the browser no UIKit object is
+// under a SwiftUI view, so the search finds nothing and nothing is handed
+// over, but the closures, and code that customizes these classes, have to
+// compile.
+// Like the views in UIView.swift they keep their state and draw nothing.
+
+import Foundation
+import FoundationBridge
+import SwiftUI
+
+// MARK: - Scroll views
+
+// `UIScrollView` is in ScrollView.swift (a representable's is drawn).
+
+/// A table view (SwiftUI's `List` up to iOS 15).
+@MainActor
+open class UITableView: UIScrollView {
+    public enum Style: Int, Sendable { case plain, grouped, insetGrouped }
+
+    open var style: Style = .plain
+    open var rowHeight: CGFloat = 44
+    open var backgroundView: UIView?
+    open var separatorColor: UIColor?
+    open var allowsSelection = true
+
+    open func reloadData() {}
+}
+
+/// A collection view (SwiftUI's `List` from iOS 16).
+@MainActor
+open class UICollectionView: UIScrollView {
+    open var backgroundView: UIView?
+    open var allowsSelection = true
+
+    open func reloadData() {}
+}
+
+/// A table view's row.
+@MainActor
+open class UITableViewCell: UIView {
+    public let contentView = UIView()
+    open var backgroundView: UIView?
+    open var selectedBackgroundView: UIView?
+}
+
+/// A collection view's cell.
+@MainActor
+open class UICollectionViewCell: UIView {
+    public let contentView = UIView()
+    open var backgroundView: UIView?
+    open var selectedBackgroundView: UIView?
+}
+
+// MARK: - Text
+
+/// A one-line text field.
+@MainActor
+open class UITextField: UIControl {
+    open var text: String?
+    open var placeholder: String?
+    open var font: UIFont?
+    open var textColor: UIColor?
+    open var isSecureTextEntry = false
+    open var keyboardType: UIKeyboardType = .default
+    public private(set) var isFirstResponder = false
+
+    @discardableResult open func becomeFirstResponder() -> Bool {
+        isFirstResponder = true
+        return true
+    }
+
+    @discardableResult open func resignFirstResponder() -> Bool {
+        isFirstResponder = false
+        return true
+    }
+}
+
+// `UITextView` is in TextView.swift (a representable's is drawn and edited).
+
+/// A search bar (`.searchable`).
+@MainActor
+open class UISearchBar: UIView {
+    open var text: String?
+    open var placeholder: String?
+    public let searchTextField = UITextField()
+}
+
+// MARK: - Controls
+
+/// A switch (`Toggle`).
+@MainActor
+open class UISwitch: UIControl {
+    open var isOn = false
+    open var onTintColor: UIColor?
+
+    open func setOn(_ on: Bool, animated: Bool) { isOn = on }
+}
+
+/// A slider (`Slider`).
+@MainActor
+open class UISlider: UIControl {
+    open var value: Float = 0
+    open var minimumValue: Float = 0
+    open var maximumValue: Float = 1
+    open var minimumTrackTintColor: UIColor?
+    open var maximumTrackTintColor: UIColor?
+
+    open func setValue(_ value: Float, animated: Bool) { self.value = value }
+}
+
+/// A stepper (`Stepper`).
+@MainActor
+open class UIStepper: UIControl {
+    open var value: Double = 0
+    open var minimumValue: Double = 0
+    open var maximumValue: Double = 100
+    open var stepValue: Double = 1
+}
+
+/// A date picker (`DatePicker`).
+@MainActor
+open class UIDatePicker: UIControl {
+    open var date = Date()
+    open var minimumDate: Date?
+    open var maximumDate: Date?
+    open var minuteInterval = 1
+}
+
+/// A segmented control (`Picker` with the segmented style).
+@MainActor
+open class UISegmentedControl: UIControl {
+    open var selectedSegmentIndex = -1
+    open var numberOfSegments: Int { 0 }
+    open var selectedSegmentTintColor: UIColor?
+}
+
+/// A wheel picker (`Picker` with the wheel style).
+@MainActor
+open class UIPickerView: UIView {
+    open func reloadAllComponents() {}
+    open func selectedRow(inComponent component: Int) -> Int { -1 }
+}
+
+/// A progress bar (`ProgressView` with the linear style).
+@MainActor
+open class UIProgressView: UIView {
+    open var progress: Float = 0
+    open var progressTintColor: UIColor?
+    open var trackTintColor: UIColor?
+
+    open func setProgress(_ progress: Float, animated: Bool) { self.progress = progress }
+}
+
+/// A color well (`ColorPicker`).
+@MainActor
+open class UIColorWell: UIControl {
+    open var selectedColor: UIColor?
+    open var supportsAlpha = true
+    open var title: String?
+}
+
+/// A page control (the dots of a `TabView` with the page style).
+@MainActor
+open class UIPageControl: UIControl {
+    open var numberOfPages = 0
+    open var currentPage = 0
+    open var hidesForSinglePage = false
+    open var pageIndicatorTintColor: UIColor?
+    open var currentPageIndicatorTintColor: UIColor?
+}
+
+// MARK: - Bars and windows
+
+/// A navigation controller's bar.
+@MainActor
+open class UINavigationBar: UIView {
+    open var prefersLargeTitles = false
+    open var isTranslucent = true
+    open var barTintColor: UIColor?
+}
+
+/// A tab bar controller's bar.
+@MainActor
+open class UITabBar: UIView {
+    open var isTranslucent = true
+    open var barTintColor: UIColor?
+    open var unselectedItemTintColor: UIColor?
+}
+
+/// A window and its root view controller.
+@MainActor
+open class UIWindow: UIView {
+    open var rootViewController: UIViewController?
+    public private(set) var isKeyWindow = false
+    /// The scene the window belongs to; the page's one scene when made from it.
+    open weak var windowScene: UIWindowScene?
+
+    /// A window in `windowScene`. It is kept and never drawn: SwiftUI draws the page.
+    public convenience init(windowScene: UIWindowScene) {
+        self.init(frame: .zero)
+        self.windowScene = windowScene
+    }
+
+    open func makeKeyAndVisible() {
+        isKeyWindow = true
+        isHidden = false
+    }
+
+    open func makeKey() { isKeyWindow = true }
+    open func resignKey() { isKeyWindow = false }
+}
+
+// MARK: - View controllers
+
+/// The status bar's style: dark content, light content, or whichever suits the interface style.
+public enum UIStatusBarStyle: Int, Sendable {
+    case `default` = 0
+    case lightContent = 1
+    case darkContent = 3
+}
+
+/// A view controller: its view (made on first use), children and
+/// presentations, kept. Nothing reaches the screen.
+@MainActor
+open class UIViewController {
+    open var title: String?
+    open var overrideUserInterfaceStyle: UIUserInterfaceStyle = .unspecified
+    open var modalPresentationStyle: UIModalPresentationStyle = .automatic
+    open var preferredContentSize: CGSize = .zero
+    /// Kept: a representable's view is laid out in the SwiftUI safe area.
+    open var additionalSafeAreaInsets: UIEdgeInsets = .zero
+    /// The status bar is the page's (the phone frame draws its own): these are asked, and not used.
+    open var preferredStatusBarStyle: UIStatusBarStyle { .default }
+    open var prefersStatusBarHidden: Bool { false }
+    open func setNeedsStatusBarAppearanceUpdate() {}
+    /// Asked, and not used: the page stays portrait.
+    open var supportedInterfaceOrientations: UIInterfaceOrientationMask { .allButUpsideDown }
+    open var preferredInterfaceOrientationForPresentation: UIInterfaceOrientation { .portrait }
+    open var shouldAutorotate: Bool { true }
+    /// 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?) {}
+    public private(set) weak var parent: UIViewController?
+    public private(set) var children: [UIViewController] = []
+    public private(set) weak var presentingViewController: UIViewController?
+    public private(set) var presentedViewController: UIViewController?
+    private var loadedView: UIView?
+    /// Set while a `UIViewControllerRepresentable` shows the controller: its
+    /// environment's `dismiss` (Representable.swift).
+    var _representableDismiss: (() -> Void)?
+
+    public init(nibName nibNameOrNil: String?, bundle nibBundleOrNil: FoundationBridge.Bundle?) {}
+
+    public convenience init() { self.init(nibName: nil, bundle: nil) }
+
+    public required init?(coder: NSCoder) {}
+
+    /// The root view, made by `loadView()` (then `viewDidLoad()`) the first time it is read.
+    open var view: UIView! {
+        get {
+            if loadedView == nil {
+                loadView()
+                if loadedView == nil { loadedView = UIView() }
+                viewDidLoad()
+            }
+            return loadedView
+        }
+        set { loadedView = newValue }
+    }
+
+    public var viewIfLoaded: UIView? { loadedView }
+    public var isViewLoaded: Bool { loadedView != nil }
+
+    open func loadView() { loadedView = UIView() }
+    open func loadViewIfNeeded() { _ = view }
+    open func viewDidLoad() {}
+    open func viewWillAppear(_ animated: Bool) {}
+    open func viewDidAppear(_ animated: Bool) {}
+    open func viewWillDisappear(_ animated: Bool) {}
+    open func viewDidDisappear(_ animated: Bool) {}
+    open func viewWillLayoutSubviews() {}
+    open func viewDidLayoutSubviews() {}
+
+    open func addChild(_ childController: UIViewController) {
+        childController.removeFromParent()
+        children.append(childController)
+        childController.parent = self
+    }
+
+    open func removeFromParent() {
+        parent?.children.removeAll { $0 === self }
+        parent = nil
+    }
+
+    open func willMove(toParent parent: UIViewController?) {}
+    open func didMove(toParent parent: UIViewController?) {}
+
+    /// Records the presentation, and tells the presented controller it
+    /// appeared (SafariServices' controller opens its tab then); nothing is shown.
+    open func present(_ viewControllerToPresent: UIViewController, animated flag: Bool, completion: (() -> Void)? = nil) {
+        presentedViewController = viewControllerToPresent
+        viewControllerToPresent.presentingViewController = self
+        viewControllerToPresent.viewWillAppear(flag)
+        viewControllerToPresent.viewDidAppear(flag)
+        completion?()
+    }
+
+    /// Kept: the page never rotates or resizes a controller's view this way.
+    open func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {}
+
+    open func dismiss(animated flag: Bool, completion: (() -> Void)? = nil) {
+        if presentedViewController == nil, presentingViewController == nil, let dismissRepresentable = _representableDismiss {
+            // Shown by a representable: dismiss the SwiftUI presentation it is in, as on iOS.
+            dismissRepresentable()
+            completion?()
+            return
+        }
+        let dismissed: UIViewController?
+        if let presented = presentedViewController {
+            presented.presentingViewController = nil
+            presentedViewController = nil
+            dismissed = presented
+        } else {
+            presentingViewController?.presentedViewController = nil
+            presentingViewController = nil
+            dismissed = self
+        }
+        dismissed?.viewWillDisappear(flag)
+        dismissed?.viewDidDisappear(flag)
+        completion?()
+    }
+
+    private func nearest<Controller: UIViewController>(_ type: Controller.Type) -> Controller? {
+        var current = parent
+        while let controller = current {
+            if let match = controller as? Controller { return match }
+            current = controller.parent
+        }
+        return nil
+    }
+
+    open var navigationController: UINavigationController? { nearest(UINavigationController.self) }
+    open var tabBarController: UITabBarController? { nearest(UITabBarController.self) }
+    open var splitViewController: UISplitViewController? { nearest(UISplitViewController.self) }
+
+    /// Nothing is presented through a presentation controller in the browser.
+    open var presentationController: UIPresentationController? { nil }
+    open var sheetPresentationController: UISheetPresentationController? { nil }
+    open var popoverPresentationController: UIPopoverPresentationController? { nil }
+}
+
+public enum UIModalPresentationStyle: Int, Sendable {
+    case fullScreen = 0, pageSheet, formSheet, currentContext, custom, overFullScreen, overCurrentContext, popover
+    case none = -1
+    case automatic = -2
+}
+
+/// A navigation stack of view controllers.
+@MainActor
+open class UINavigationController: UIViewController {
+    public let navigationBar = UINavigationBar()
+    open var isNavigationBarHidden = false
+
+    open var viewControllers: [UIViewController] {
+        get { children }
+        set {
+            for child in children { child.removeFromParent() }
+            for controller in newValue { addChild(controller) }
+        }
+    }
+
+    open var topViewController: UIViewController? { children.last }
+    /// What is showing: a controller the top one presents, else the top one.
+    open var visibleViewController: UIViewController? { topViewController?.presentedViewController ?? topViewController }
+
+    public convenience init(rootViewController: UIViewController) {
+        self.init(nibName: nil, bundle: nil)
+        addChild(rootViewController)
+    }
+
+    open func pushViewController(_ viewController: UIViewController, animated: Bool) {
+        addChild(viewController)
+    }
+
+    @discardableResult
+    open func popViewController(animated: Bool) -> UIViewController? {
+        guard children.count > 1, let top = children.last else { return nil }
+        top.removeFromParent()
+        return top
+    }
+
+    open func setNavigationBarHidden(_ hidden: Bool, animated: Bool) { isNavigationBarHidden = hidden }
+}
+
+/// Tabs of view controllers.
+@MainActor
+open class UITabBarController: UIViewController {
+    public let tabBar = UITabBar()
+    open var selectedIndex = 0
+
+    open var viewControllers: [UIViewController]? {
+        get { children }
+        set {
+            for child in children { child.removeFromParent() }
+            for controller in newValue ?? [] { addChild(controller) }
+        }
+    }
+
+    open var selectedViewController: UIViewController? {
+        children.indices.contains(selectedIndex) ? children[selectedIndex] : nil
+    }
+}
+
+/// Columns of view controllers (`NavigationSplitView`).
+@MainActor
+open class UISplitViewController: UIViewController {
+    open var preferredPrimaryColumnWidthFraction: CGFloat = 0.4
+    open var presentsWithGesture = true
+
+    open var viewControllers: [UIViewController] {
+        get { children }
+        set {
+            for child in children { child.removeFromParent() }
+            for controller in newValue { addChild(controller) }
+        }
+    }
+}
+
+// MARK: - Presentation controllers
+
+/// What presents a view controller (a sheet, a full-screen cover, a popover).
+@MainActor
+open class UIPresentationController {
+    public let presentedViewController: UIViewController
+    public let presentingViewController: UIViewController?
+    open weak var delegate: (any UIAdaptivePresentationControllerDelegate)?
+
+    public init(presentedViewController: UIViewController, presenting presentingViewController: UIViewController?) {
+        self.presentedViewController = presentedViewController
+        self.presentingViewController = presentingViewController
+    }
+}
+
+/// A sheet's presentation controller.
+@MainActor
+open class UISheetPresentationController: UIPresentationController {
+    open var prefersGrabberVisible = false
+    open var preferredCornerRadius: CGFloat?
+    open var prefersScrollingExpandsWhenScrolledToEdge = true
+    /// The heights the sheet may rest at; kept (nothing is shown).
+    open var detents: [Detent] = [.large()]
+    open var selectedDetentIdentifier: Detent.Identifier?
+    open var largestUndimmedDetentIdentifier: Detent.Identifier?
+    open var prefersEdgeAttachedInCompactHeight = false
+    open var widthFollowsPreferredContentSizeWhenEdgeAttached = false
+
+    open func animateChanges(_ changes: () -> Void) { changes() }
+
+    /// A height a sheet rests at.
+    @MainActor
+    public final class Detent {
+        public struct Identifier: RawRepresentable, Hashable, Sendable {
+            public let rawValue: String
+            public init(rawValue: String) { self.rawValue = rawValue }
+            public init(_ rawValue: String) { self.rawValue = rawValue }
+            public static let medium = Identifier("com.apple.UIKit.medium")
+            public static let large = Identifier("com.apple.UIKit.large")
+        }
+
+        public let identifier: Identifier
+        let resolver: ((any UISheetPresentationControllerDetentResolutionContext) -> CGFloat?)?
+
+        init(identifier: Identifier, resolver: ((any UISheetPresentationControllerDetentResolutionContext) -> CGFloat?)?) {
+            self.identifier = identifier
+            self.resolver = resolver
+        }
+
+        public static func medium() -> Detent { Detent(identifier: .medium, resolver: nil) }
+        public static func large() -> Detent { Detent(identifier: .large, resolver: nil) }
+
+        public static func custom(identifier: Identifier? = nil, resolver: @escaping (any UISheetPresentationControllerDetentResolutionContext) -> CGFloat?) -> Detent {
+            Detent(identifier: identifier ?? Identifier(UUID().uuidString), resolver: resolver)
+        }
+
+        /// The height of a detent that is not custom: nil (resolved by the system).
+        public static let systemDetentValue: CGFloat? = nil
+    }
+}
+
+/// What a custom detent's resolver is told: the largest height a sheet may have.
+@MainActor
+public protocol UISheetPresentationControllerDetentResolutionContext {
+    var containerTraitCollection: UITraitCollection { get }
+    var maximumDetentValue: CGFloat { get }
+}
+
+/// A popover's presentation controller.
+@MainActor
+open class UIPopoverPresentationController: UIPresentationController {
+    open var sourceView: UIView?
+    open var sourceRect: CGRect = .zero
+    open var backgroundColor: UIColor?
+}