@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/UIKit/UIKit.swift

@@ -0,0 +1,292 @@
+// `import UIKit` for the browser: the part of UIKit that code shared with
+// SwiftUI apps leans on. `UIImage` is the SwiftUI shim's (re-exported, as on
+// iOS SwiftUI uses UIKit's), with `UIColor`, `UIScreen`, and
+// `UIApplication`'s lifecycle notifications. Views, view controllers and
+// the rest are not here: code that needs them is a compile error in the
+// browser build (keep it behind `#if !SWIFTBROWSER`).
+
+// On iOS, UIKit brings Foundation, Core Graphics and Image I/O along.
+@_exported import Foundation
+@_exported import CoreGraphics
+@_exported import ImageIO
+// As on iOS, where UIKit brings Core Image along (CIImage, CIFilter).
+@_exported import CoreImage
+// iOS's UIKit brings UserNotifications along (`UNUserNotificationCenter` with `import UIKit`).
+@_exported import UserNotifications
+@_exported import class SwiftUI.UIImage
+// UIKit tracks `@Observable` objects (iOS 18), so `@Observable` comes with it.
+@_exported import Observation
+import FoundationBridge
+import SwiftUI
+
+// MARK: - Colors
+
+/// A color: RGBA in 0…1 (extended sRGB).
+public final class UIColor: Hashable, @unchecked Sendable {
+    public let red: CGFloat
+    public let green: CGFloat
+    public let blue: CGFloat
+    public let alpha: CGFloat
+    /// For a semantic color (`label`, `systemGroupedBackground`…), its name and
+    /// the opacity applied on top of it: `Color(uiColor:)` hands the name to
+    /// the page, which draws it in the color scheme's appearance. The
+    /// components are its light appearance.
+    let semantic: (name: String, opacity: CGFloat)?
+
+    public init(red: CGFloat, green: CGFloat, blue: CGFloat, alpha: CGFloat) {
+        (self.red, self.green, self.blue, self.alpha) = (red, green, blue, alpha)
+        semantic = nil
+    }
+
+    init(semantic name: String, opacity: CGFloat = 1, red: CGFloat, green: CGFloat, blue: CGFloat, alpha: CGFloat) {
+        (self.red, self.green, self.blue, self.alpha) = (red, green, blue, alpha)
+        semantic = (name, opacity)
+    }
+
+    /// The semantic color `name` with the components of its light appearance.
+    private static func named(_ name: String, _ red: CGFloat, _ green: CGFloat, _ blue: CGFloat, _ alpha: CGFloat = 1) -> UIColor {
+        UIColor(semantic: name, red: red, green: green, blue: blue, alpha: alpha)
+    }
+
+    public convenience init(white: CGFloat, alpha: CGFloat) {
+        self.init(red: white, green: white, blue: white, alpha: alpha)
+    }
+
+    public convenience init(displayP3Red red: CGFloat, green: CGFloat, blue: CGFloat, alpha: CGFloat) {
+        self.init(red: red, green: green, blue: blue, alpha: alpha)
+    }
+
+    /// A color that depends on the traits. The provider is asked once, with
+    /// the current traits; a semantic color it returns stays semantic, so the
+    /// page still draws it in the color scheme's appearance.
+    public convenience init(dynamicProvider: @escaping (UITraitCollection) -> UIColor) {
+        let color = dynamicProvider(UITraitCollection.current)
+        if let semantic = color.semantic {
+            self.init(semantic: semantic.name, opacity: semantic.opacity, red: color.red, green: color.green, blue: color.blue, alpha: color.alpha)
+        } else {
+            self.init(red: color.red, green: color.green, blue: color.blue, alpha: color.alpha)
+        }
+    }
+
+    /// The color for `traitCollection`: this one (the page has one appearance).
+    public func resolvedColor(with traitCollection: UITraitCollection) -> UIColor { self }
+
+    public convenience init(cgColor: CGColor) {
+        let c = cgColor.components ?? [0, 0, 0, 1]
+        self.init(red: c[0], green: c.count > 1 ? c[1] : c[0], blue: c.count > 2 ? c[2] : c[0], alpha: c.last ?? 1)
+    }
+
+    /// Hue, saturation and brightness in 0…1.
+    public convenience init(hue: CGFloat, saturation: CGFloat, brightness: CGFloat, alpha: CGFloat) {
+        let h = (hue - hue.rounded(.down)) * 6
+        let c = brightness * saturation
+        let x = c * (1 - abs(h.truncatingRemainder(dividingBy: 2) - 1))
+        let m = brightness - c
+        let (r, g, b): (CGFloat, CGFloat, CGFloat) = switch Int(h) {
+        case 0: (c, x, 0)
+        case 1: (x, c, 0)
+        case 2: (0, c, x)
+        case 3: (0, x, c)
+        case 4: (x, 0, c)
+        default: (c, 0, x)
+        }
+        self.init(red: r + m, green: g + m, blue: b + m, alpha: alpha)
+    }
+
+    public var cgColor: CGColor { CGColor(red: red, green: green, blue: blue, alpha: alpha) }
+
+    public func withAlphaComponent(_ alpha: CGFloat) -> UIColor {
+        guard let semantic, self.alpha > 0 else { return UIColor(red: red, green: green, blue: blue, alpha: alpha) }
+        // The semantic color's own alpha is the token's; the new one scales it.
+        return UIColor(semantic: semantic.name, opacity: semantic.opacity * alpha / self.alpha, red: red, green: green, blue: blue, alpha: alpha)
+    }
+
+    @discardableResult
+    public func getRed(_ red: UnsafeMutablePointer<CGFloat>?, green: UnsafeMutablePointer<CGFloat>?, blue: UnsafeMutablePointer<CGFloat>?, alpha: UnsafeMutablePointer<CGFloat>?) -> Bool {
+        red?.pointee = self.red
+        green?.pointee = self.green
+        blue?.pointee = self.blue
+        alpha?.pointee = self.alpha
+        return true
+    }
+
+    public static func == (lhs: UIColor, rhs: UIColor) -> Bool {
+        (lhs.red, lhs.green, lhs.blue, lhs.alpha) == (rhs.red, rhs.green, rhs.blue, rhs.alpha)
+            && lhs.semantic?.name == rhs.semantic?.name
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(red); hasher.combine(green); hasher.combine(blue); hasher.combine(alpha)
+        hasher.combine(semantic?.name)
+    }
+
+    public static let black = UIColor(white: 0, alpha: 1)
+    public static let darkGray = UIColor(white: 1.0 / 3, alpha: 1)
+    public static let lightGray = UIColor(white: 2.0 / 3, alpha: 1)
+    public static let white = UIColor(white: 1, alpha: 1)
+    public static let gray = UIColor(white: 0.5, alpha: 1)
+    public static let clear = UIColor(white: 0, alpha: 0)
+    public static let red = UIColor(red: 1, green: 0, blue: 0, alpha: 1)
+    public static let green = UIColor(red: 0, green: 1, blue: 0, alpha: 1)
+    public static let blue = UIColor(red: 0, green: 0, blue: 1, alpha: 1)
+    public static let cyan = UIColor(red: 0, green: 1, blue: 1, alpha: 1)
+    public static let yellow = UIColor(red: 1, green: 1, blue: 0, alpha: 1)
+    public static let magenta = UIColor(red: 1, green: 0, blue: 1, alpha: 1)
+    public static let orange = UIColor(red: 1, green: 0.5, blue: 0, alpha: 1)
+    public static let purple = UIColor(red: 0.5, green: 0, blue: 0.5, alpha: 1)
+    public static let brown = UIColor(red: 0.6, green: 0.4, blue: 0.2, alpha: 1)
+
+    // The light-mode system colors.
+    public static let systemBackground = named("systemBackground", 1, 1, 1)
+    public static let secondarySystemBackground = named("secondarySystemBackground", 0.949, 0.949, 0.969)
+    public static let tertiarySystemBackground = named("tertiarySystemBackground", 1, 1, 1)
+    public static let systemGroupedBackground = named("systemGroupedBackground", 0.949, 0.949, 0.969)
+    public static let label = named("label", 0, 0, 0)
+    public static let secondaryLabel = named("secondaryLabel", 0.235, 0.235, 0.263, 0.6)
+    public static let separator = named("separator", 0.235, 0.235, 0.263, 0.29)
+    public static let systemGray = named("gray", 0.557, 0.557, 0.576)
+    public static let systemBlue = named("blue", 0, 0.478, 1)
+    public static let systemRed = named("red", 1, 0.231, 0.188)
+    public static let systemGreen = named("green", 0.204, 0.78, 0.349)
+    public static let tintColor = UIColor.systemBlue
+
+    // The rest of iOS's semantic and system colors (components: light mode).
+    public static let secondarySystemGroupedBackground = named("secondarySystemGroupedBackground", 1, 1, 1)
+    public static let tertiarySystemGroupedBackground = named("tertiarySystemGroupedBackground", 0.949, 0.949, 0.969)
+    public static let tertiaryLabel = named("tertiaryLabel", 0.235, 0.235, 0.263, 0.3)
+    public static let quaternaryLabel = named("quaternaryLabel", 0.235, 0.235, 0.263, 0.18)
+    public static let placeholderText = named("placeholderText", 0.235, 0.235, 0.263, 0.3)
+    public static let opaqueSeparator = named("opaqueSeparator", 0.776, 0.776, 0.784)
+    public static let link = UIColor.systemBlue
+    public static let systemFill = named("systemFill", 0.471, 0.471, 0.502, 0.2)
+    public static let secondarySystemFill = named("secondarySystemFill", 0.471, 0.471, 0.502, 0.16)
+    public static let tertiarySystemFill = named("tertiarySystemFill", 0.463, 0.463, 0.502, 0.12)
+    public static let quaternarySystemFill = named("quaternarySystemFill", 0.455, 0.455, 0.502, 0.08)
+    public static let systemGray2 = named("systemGray2", 0.682, 0.682, 0.698)
+    public static let systemGray3 = named("systemGray3", 0.78, 0.78, 0.8)
+    public static let systemGray4 = named("systemGray4", 0.82, 0.82, 0.839)
+    public static let systemGray5 = named("systemGray5", 0.898, 0.898, 0.918)
+    public static let systemGray6 = named("systemGray6", 0.949, 0.949, 0.969)
+    public static let systemOrange = named("orange", 1, 0.584, 0)
+    public static let systemYellow = named("yellow", 1, 0.8, 0)
+    public static let systemPink = named("pink", 1, 0.176, 0.333)
+    public static let systemPurple = named("purple", 0.686, 0.322, 0.871)
+    public static let systemTeal = named("teal", 0.188, 0.69, 0.78)
+    public static let systemIndigo = named("indigo", 0.345, 0.337, 0.839)
+    public static let systemMint = named("mint", 0, 0.78, 0.745)
+    public static let systemCyan = named("cyan", 0.196, 0.678, 0.902)
+    public static let systemBrown = named("brown", 0.635, 0.518, 0.369)
+    public static let lightText = UIColor(white: 1, alpha: 0.6)
+    public static let darkText = UIColor.black
+}
+
+extension Color {
+    /// A SwiftUI color from a `UIColor`.
+    public init(uiColor: UIColor) {
+        if let semantic = uiColor.semantic {
+            self.init(_semantic: semantic.name, opacity: semantic.opacity)
+        } else {
+            self.init(red: uiColor.red, green: uiColor.green, blue: uiColor.blue, opacity: uiColor.alpha)
+        }
+    }
+
+    public init(_ color: UIColor) {
+        self.init(uiColor: color)
+    }
+}
+
+// MARK: - Screen and application
+
+/// The screen the page stands for: an iPhone's (3x).
+public final class UIScreen: @unchecked Sendable {
+    nonisolated(unsafe) public static let main = UIScreen()
+    public var scale: CGFloat { 3 }
+    public var nativeScale: CGFloat { 3 }
+    public var bounds: CGRect { CGRect(x: 0, y: 0, width: 393, height: 852) }
+}
+
+/// The application, as code that observes its lifecycle uses it. The page
+/// posts no lifecycle notifications (use SwiftUI's `scenePhase`).
+/// `@preconcurrency`, like `UIDevice`.
+@preconcurrency @MainActor
+public final class UIApplication {
+    public static let shared = UIApplication()
+
+    /// Key-value coding on the class, as SDKs that may run in an app
+    /// extension reach the application (`value(forKey: "sharedApplication")`,
+    /// where `UIApplication.shared` is unavailable): the shared application
+    /// for that key, else nil.
+    public nonisolated static func value(forKey key: String) -> Any? {
+        key == "sharedApplication" ? MainActor.assumeIsolated { shared } : nil
+    }
+
+    public enum State: Int, Sendable { case active, inactive, background }
+
+    public var applicationState: State { .active }
+    public var applicationIconBadgeNumber = 0
+    public var isIdleTimerDisabled = false
+
+    /// Opens a web or mail URL on the page, in a new tab (as SwiftUI's
+    /// `openURL` does). Other schemes (another app's, the settings') have
+    /// nothing to open them, so the handler is told they did not open.
+    public func open(_ url: URL, options: [OpenExternalURLOptionsKey: Any] = [:], completionHandler: (@MainActor @Sendable (Bool) -> Void)? = nil) {
+        // The app's own scheme goes to its `onOpenURL` handlers (FoundationBridge).
+        if _OpenURLHandlers.deliver(url) {
+            completionHandler?(true)
+            return
+        }
+        guard canOpenURL(url) else {
+            completionHandler?(false)
+            return
+        }
+        _Runtime.shared._openLinkOnPage(url.absoluteString)
+        completionHandler?(true)
+    }
+
+    public func open(_ url: URL, options: [OpenExternalURLOptionsKey: Any] = [:]) async -> Bool {
+        if _OpenURLHandlers.deliver(url) { return true }
+        guard canOpenURL(url) else { return false }
+        _Runtime.shared._openLinkOnPage(url.absoluteString)
+        return true
+    }
+
+    /// Whether `open` can open it: web and mail URLs.
+    public func canOpenURL(_ url: URL) -> Bool {
+        ["http", "https", "mailto", "tel", "sms"].contains(url.scheme?.lowercased() ?? "")
+    }
+
+    public struct OpenExternalURLOptionsKey: Hashable, RawRepresentable, Sendable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public static let universalLinksOnly = OpenExternalURLOptionsKey(rawValue: "UIApplicationOpenURLOptionUniversalLinksOnly")
+    }
+
+    public static let openSettingsURLString = "app-settings:"
+
+    nonisolated public static let didEnterBackgroundNotification = Notification.Name("UIApplicationDidEnterBackgroundNotification")
+    nonisolated public static let willEnterForegroundNotification = Notification.Name("UIApplicationWillEnterForegroundNotification")
+    nonisolated public static let didBecomeActiveNotification = Notification.Name("UIApplicationDidBecomeActiveNotification")
+    nonisolated public static let willResignActiveNotification = Notification.Name("UIApplicationWillResignActiveNotification")
+    nonisolated public static let willTerminateNotification = Notification.Name("UIApplicationWillTerminateNotification")
+    nonisolated public static let didReceiveMemoryWarningNotification = Notification.Name("UIApplicationDidReceiveMemoryWarningNotification")
+    nonisolated public static let significantTimeChangeNotification = Notification.Name("UIApplicationSignificantTimeChangeNotification")
+}
+
+// MARK: - Images
+
+extension UIImage {
+    /// Nil: the browser build cannot encode images.
+    public func pngData() -> Data? { nil }
+
+    /// Nil: the browser build cannot encode images.
+    public func jpegData(compressionQuality: CGFloat) -> Data? { nil }
+
+    /// The image ready to draw (iOS 15): the page decodes images itself, so it is the image.
+    public func preparingForDisplay() -> UIImage? { self }
+    public func byPreparingForDisplay() async -> UIImage? { self }
+    public func prepareForDisplay(completionHandler: @escaping @Sendable (UIImage?) -> Void) { completionHandler(self) }
+
+    /// Not animated: an animated file is one image the page animates by itself.
+    public var images: [UIImage]? { nil }
+    public var duration: TimeInterval { 0 }
+}