@swiftbrowser/swift 0.1.0 → 0.3.0

package/Sources/UIKit/Graphics.swift

@@ -0,0 +1,204 @@
+// Drawing images with UIKit: `UIGraphicsImageRenderer`, the older
+// `UIGraphicsBeginImageContext` functions, `UIImage.draw(in:)`, and an
+// image's rendering mode and tint. Drawing goes into Core Graphics'
+// recording context (Sources/CoreGraphics), so the result is a recipe the
+// page draws: an image drawn into a renderer is that image scaled and placed
+// on the renderer's canvas (how apps resize images, EmojiText's emoji among
+// them). As in that context, the image drawn last is the canvas's content.
+
+import Foundation
+import SwiftUI
+
+// MARK: - Rendering mode and tint
+
+extension UIImage {
+    public enum RenderingMode: Int, Sendable {
+        case automatic, alwaysOriginal, alwaysTemplate
+    }
+
+    public var renderingMode: RenderingMode { RenderingMode(rawValue: _renderingMode) ?? .automatic }
+
+    /// SF Symbols are templates: they draw in the tint or foreground color.
+    public var isSymbolImage: Bool { _isSymbol }
+
+    public func withRenderingMode(_ renderingMode: RenderingMode) -> UIImage {
+        _copy(renderingMode: renderingMode.rawValue)
+    }
+
+    /// The image's shape filled with `color` (a bitmap's alpha, in the color).
+    /// A symbol keeps its own drawing: it takes the foreground color where shown.
+    public func withTintColor(_ color: UIColor) -> UIImage {
+        withTintColor(color, renderingMode: .alwaysOriginal)
+    }
+
+    public func withTintColor(_ color: UIColor, renderingMode: RenderingMode) -> UIImage {
+        guard let recipe = _recipe, recipe.source != nil else { return _copy(renderingMode: renderingMode.rawValue) }
+        let tinted = recipe.adding(.object([
+            "op": .string("tint"),
+            "r": .number(color.red), "g": .number(color.green), "b": .number(color.blue), "a": .number(color.alpha),
+        ]), extent: recipe.extent)
+        return _copy(recipe: tinted, renderingMode: renderingMode.rawValue)
+    }
+}
+
+// MARK: - Drawing into the current context
+
+/// The contexts pushed by renderers and `UIGraphicsPushContext`, innermost last.
+nonisolated(unsafe) private var contextStack: [CGContext] = []
+/// The contexts `UIGraphicsBeginImageContext…` made, with their scale.
+nonisolated(unsafe) private var imageContexts: [(context: CGContext, scale: CGFloat)] = []
+
+public func UIGraphicsGetCurrentContext() -> CGContext? { contextStack.last }
+public func UIGraphicsPushContext(_ context: CGContext) { contextStack.append(context) }
+public func UIGraphicsPopContext() { _ = contextStack.popLast() }
+
+public func UIGraphicsBeginImageContext(_ size: CGSize) {
+    UIGraphicsBeginImageContextWithOptions(size, false, 1)
+}
+
+/// A scale of 0 is the screen's (3).
+public func UIGraphicsBeginImageContextWithOptions(_ size: CGSize, _ opaque: Bool, _ scale: CGFloat) {
+    let factor = scale > 0 ? scale : UIScreen.main.scale
+    guard let context = _uiKitContext(size: size, scale: factor) else { return }
+    imageContexts.append((context, factor))
+    contextStack.append(context)
+}
+
+public func UIGraphicsGetImageFromCurrentImageContext() -> UIImage? {
+    guard let (context, scale) = imageContexts.last, let image = context.makeImage() else { return nil }
+    return UIImage(cgImage: image, scale: scale, orientation: .up)
+}
+
+public func UIGraphicsEndImageContext() {
+    guard let (context, _) = imageContexts.popLast() else { return }
+    if let index = contextStack.lastIndex(where: { $0 === context }) { contextStack.remove(at: index) }
+}
+
+/// A bitmap context of `size` points at `scale` pixels per point, in UIKit's
+/// coordinates: points, origin at the top left.
+func _uiKitContext(size: CGSize, scale: CGFloat) -> CGContext? {
+    let width = Int((size.width * scale).rounded(.up)), height = Int((size.height * scale).rounded(.up))
+    guard let context = CGContext(data: nil, width: width, height: height, bitsPerComponent: 8, bytesPerRow: width * 4,
+                                  space: CGColorSpaceCreateDeviceRGB(), bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue)
+    else { return nil }
+    context.translateBy(x: 0, y: CGFloat(height))
+    context.scaleBy(x: scale, y: -scale)
+    return context
+}
+
+extension UIImage {
+    /// Draws the image scaled into `rect` (points, in the current context's
+    /// coordinates). A symbol or catalog image has no bitmap here and draws nothing.
+    public func draw(in rect: CGRect) {
+        guard let context = UIGraphicsGetCurrentContext(), let cgImage else { return }
+        context.draw(cgImage, in: rect)
+    }
+
+    public func draw(in rect: CGRect, blendMode: CGBlendMode, alpha: CGFloat) { draw(in: rect) }
+
+    public func draw(at point: CGPoint) { draw(in: CGRect(origin: point, size: size)) }
+
+    public func draw(at point: CGPoint, blendMode: CGBlendMode, alpha: CGFloat) { draw(at: point) }
+}
+
+// MARK: - UIGraphicsImageRenderer
+
+public class UIGraphicsRendererFormat: @unchecked Sendable {
+    public init() {}
+    public var bounds: CGRect = .zero
+}
+
+public final class UIGraphicsImageRendererFormat: UIGraphicsRendererFormat, @unchecked Sendable {
+    /// Pixels per point: the screen's (3) by default.
+    public var scale: CGFloat = UIScreen.main.scale
+    public var opaque = false
+    public var preferredRange: Range = .automatic
+
+    public enum Range: Int, Sendable { case unspecified = -1, automatic, `default`, extended, standard }
+
+    public override init() { super.init() }
+
+    public init(for traitCollection: UITraitCollection) {
+        super.init()
+        scale = traitCollection.displayScale
+    }
+
+    public class func `default`() -> UIGraphicsImageRendererFormat { UIGraphicsImageRendererFormat() }
+    public class func preferred() -> UIGraphicsImageRendererFormat { UIGraphicsImageRendererFormat() }
+}
+
+public class UIGraphicsRendererContext: @unchecked Sendable {
+    public let cgContext: CGContext
+    init(cgContext: CGContext) { self.cgContext = cgContext }
+
+    public func fill(_ rect: CGRect) { cgContext.fill(rect) }
+    public func fill(_ rect: CGRect, blendMode: CGBlendMode) { cgContext.fill(rect) }
+    public func stroke(_ rect: CGRect) { cgContext.stroke(rect) }
+    public func stroke(_ rect: CGRect, blendMode: CGBlendMode) { cgContext.stroke(rect) }
+    public func clip(to rect: CGRect) { cgContext.clip(to: rect) }
+}
+
+public final class UIGraphicsImageRendererContext: UIGraphicsRendererContext, @unchecked Sendable {
+    public let format: UIGraphicsImageRendererFormat
+
+    init(cgContext: CGContext, format: UIGraphicsImageRendererFormat) {
+        self.format = format
+        super.init(cgContext: cgContext)
+    }
+
+    /// What has been drawn so far.
+    public var currentImage: UIImage {
+        cgContext.makeImage().map { UIImage(cgImage: $0, scale: format.scale, orientation: .up) } ?? UIImage()
+    }
+}
+
+public class UIGraphicsRenderer: @unchecked Sendable {
+    public init() {}
+}
+
+/// Makes images by drawing: `renderer.image { context in … }`.
+public final class UIGraphicsImageRenderer: UIGraphicsRenderer, @unchecked Sendable {
+    public let format: UIGraphicsImageRendererFormat
+    let size: CGSize
+
+    public init(size: CGSize) {
+        self.size = size
+        format = .default()
+        format.bounds = CGRect(origin: .zero, size: size)
+    }
+
+    public init(size: CGSize, format: UIGraphicsImageRendererFormat) {
+        self.size = size
+        self.format = format
+        format.bounds = CGRect(origin: .zero, size: size)
+    }
+
+    public init(bounds: CGRect, format: UIGraphicsImageRendererFormat = .default()) {
+        size = bounds.size
+        self.format = format
+        format.bounds = bounds
+    }
+
+    public typealias DrawingActions = (UIGraphicsImageRendererContext) -> Void
+
+    /// The image `actions` draw, `size` points at the format's scale.
+    public func image(actions: DrawingActions) -> UIImage {
+        guard let context = _uiKitContext(size: size, scale: format.scale) else { return UIImage() }
+        let rendererContext = UIGraphicsImageRendererContext(cgContext: context, format: format)
+        contextStack.append(context)
+        actions(rendererContext)
+        if let index = contextStack.lastIndex(where: { $0 === context }) { contextStack.remove(at: index) }
+        return rendererContext.currentImage
+    }
+
+    /// Nil: the browser build cannot encode images (as `UIImage.pngData()`).
+    public func pngData(actions: DrawingActions) -> Data {
+        _ = image(actions: actions)
+        return Data()
+    }
+
+    public func jpegData(withCompressionQuality compressionQuality: CGFloat, actions: DrawingActions) -> Data {
+        _ = image(actions: actions)
+        return Data()
+    }
+}

package/Sources/UIKit/HostingController.swift

@@ -0,0 +1,185 @@
+// SwiftUI inside UIKit inside SwiftUI, and the controllers representables
+// wrap. A `UIHostingController`'s view is a `_UIHostingView` holding the root
+// view; when a representable's tree contains it, the translation draws the
+// root view inline, as a subtree of the representable (ViewTranslation.swift),
+// so its state lives as long as the hosting view keeps its place. A hosting
+// controller that no representable shows (presented, pushed, or a window's
+// root) draws nothing.
+//
+// `UIImagePickerController` has no camera or library here:
+// `isSourceTypeAvailable` is false for every source, and a picker that is
+// shown anyway draws a "camera unavailable" notice whose Cancel button
+// tells the delegate, as the picker's own Cancel would. Code that presents
+// the picker with `present(_:animated:)` shows nothing.
+
+import Foundation
+import FoundationBridge
+import SwiftUI
+
+// MARK: - Hosting controllers
+
+/// What a hosting controller's view sizes itself by; kept.
+public struct UIHostingControllerSizingOptions: OptionSet, Sendable {
+    public let rawValue: Int
+    public init(rawValue: Int) { self.rawValue = rawValue }
+    public static let preferredContentSize = UIHostingControllerSizingOptions(rawValue: 1 << 0)
+    public static let intrinsicContentSize = UIHostingControllerSizingOptions(rawValue: 1 << 1)
+}
+
+/// A view controller whose view is a SwiftUI view.
+@MainActor
+open class UIHostingController<Content: View>: UIViewController {
+    /// The SwiftUI view; setting it draws the new one.
+    open var rootView: Content {
+        didSet { (viewIfLoaded as? _UIHostingView)?.rootView = AnyView(rootView) }
+    }
+    open var sizingOptions: UIHostingControllerSizingOptions = []
+    open var safeAreaRegions: SafeAreaRegions = .all
+
+    public init(rootView: Content) {
+        self.rootView = rootView
+        super.init(nibName: nil, bundle: nil)
+    }
+
+    public required init?(coder: NSCoder) { return nil }
+
+    open override func loadView() {
+        view = _UIHostingView(rootView: AnyView(rootView))
+    }
+
+    /// The root view's size for `size`, from the page's measurement of it
+    /// (`_ViewMeasurements`, SwiftUI/Runtime/Measurements.swift): zero until
+    /// the page has measured it, which a render later it has, and the code
+    /// that asked runs again.
+    open func sizeThatFits(in size: CGSize) -> CGSize {
+        _UIHostingView.measuredSize(of: AnyView(rootView), fitting: size)
+    }
+}
+
+/// A hosting controller's view: drawn as its root view.
+@MainActor
+public final class _UIHostingView: UIView {
+    var rootView: AnyView { didSet { _setNeedsTranslation() } }
+
+    init(rootView: AnyView) {
+        self.rootView = rootView
+        super.init(frame: .zero)
+    }
+
+    public required init?(coder: NSCoder) { return nil }
+
+    /// Measured by the page, like the controller's `sizeThatFits(in:)`.
+    public override func sizeThatFits(_ size: CGSize) -> CGSize {
+        Self.measuredSize(of: rootView, fitting: size)
+    }
+
+    /// The root view's ideal size, measured by the page (zero until it is).
+    public override var intrinsicContentSize: CGSize {
+        _ViewMeasurements.shared.size(of: rootView, fitting: .unspecified) ?? .zero
+    }
+
+    static func measuredSize(of view: AnyView, fitting size: CGSize) -> CGSize {
+        _ViewMeasurements.shared.size(of: view, fitting: ProposedViewSize(size)) ?? .zero
+    }
+}
+
+// MARK: - Navigation controller delegate
+
+/// What a navigation controller tells its delegate; kept (nothing calls it).
+@MainActor
+public protocol UINavigationControllerDelegate: AnyObject {
+    func navigationController(_ navigationController: UINavigationController, willShow viewController: UIViewController, animated: Bool)
+    func navigationController(_ navigationController: UINavigationController, didShow viewController: UIViewController, animated: Bool)
+}
+
+extension UINavigationControllerDelegate {
+    public func navigationController(_ navigationController: UINavigationController, willShow viewController: UIViewController, animated: Bool) {}
+    public func navigationController(_ navigationController: UINavigationController, didShow viewController: UIViewController, animated: Bool) {}
+}
+
+/// A view controller transition's coordinator (`viewWillTransition(to:with:)`); never used.
+@MainActor
+public protocol UIViewControllerTransitionCoordinator: AnyObject {}
+
+// MARK: - Image picker
+
+/// What an image picker tells its delegate. Cancelling dismisses the picker
+/// unless the delegate says otherwise, as on iOS.
+@MainActor
+public protocol UIImagePickerControllerDelegate: AnyObject {
+    func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey: Any])
+    func imagePickerControllerDidCancel(_ picker: UIImagePickerController)
+}
+
+extension UIImagePickerControllerDelegate {
+    public func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey: Any]) {}
+    public func imagePickerControllerDidCancel(_ picker: UIImagePickerController) {
+        picker.dismiss(animated: true)
+    }
+}
+
+/// The system's camera and photo picker: unavailable in the browser (see the
+/// top of the file).
+@MainActor
+open class UIImagePickerController: UINavigationController {
+    public enum SourceType: Int, Sendable { case photoLibrary, camera, savedPhotosAlbum }
+    public enum CameraDevice: Int, Sendable { case rear, front }
+    public enum CameraCaptureMode: Int, Sendable { case photo, video }
+    public enum CameraFlashMode: Int, Sendable { case off = -1, auto = 0, on = 1 }
+    public enum QualityType: Int, Sendable { case typeHigh, typeMedium, typeLow, type640x480, typeIFrame1280x720, typeIFrame960x540 }
+
+    public struct InfoKey: Hashable, RawRepresentable, Sendable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public static let mediaType = InfoKey(rawValue: "UIImagePickerControllerMediaType")
+        public static let originalImage = InfoKey(rawValue: "UIImagePickerControllerOriginalImage")
+        public static let editedImage = InfoKey(rawValue: "UIImagePickerControllerEditedImage")
+        public static let cropRect = InfoKey(rawValue: "UIImagePickerControllerCropRect")
+        public static let mediaURL = InfoKey(rawValue: "UIImagePickerControllerMediaURL")
+        public static let imageURL = InfoKey(rawValue: "UIImagePickerControllerImageURL")
+        public static let mediaMetadata = InfoKey(rawValue: "UIImagePickerControllerMediaMetadata")
+    }
+
+    open weak var delegate: (any UIImagePickerControllerDelegate & UINavigationControllerDelegate)?
+    open var sourceType: SourceType = .photoLibrary
+    open var mediaTypes: [String] = ["public.image"]
+    open var allowsEditing = false
+    open var cameraDevice: CameraDevice = .rear
+    open var cameraCaptureMode: CameraCaptureMode = .photo
+    open var cameraFlashMode: CameraFlashMode = .auto
+    open var videoQuality: QualityType = .typeMedium
+    open var videoMaximumDuration: TimeInterval = 600
+    open var showsCameraControls = true
+
+    /// False: the browser build has no camera or photo library to pick from.
+    open class func isSourceTypeAvailable(_ sourceType: SourceType) -> Bool { false }
+    open class func availableMediaTypes(for sourceType: SourceType) -> [String]? { nil }
+    open class func isCameraDeviceAvailable(_ cameraDevice: CameraDevice) -> Bool { false }
+
+    open func takePicture() {}
+
+    open override func loadView() {
+        view = _UIHostingView(rootView: AnyView(_ImagePickerUnavailableView(picker: self)))
+    }
+}
+
+/// What a shown image picker draws.
+private struct _ImagePickerUnavailableView: View {
+    let picker: UIImagePickerController
+
+    var body: some View {
+        VStack(spacing: 16) {
+            ContentUnavailableView(picker.sourceType == .camera ? "Camera Unavailable" : "Photos Unavailable",
+                                   systemImage: picker.sourceType == .camera ? "camera" : "photo",
+                                   description: Text("This app is running in a browser."))
+            Button("Cancel") {
+                if let delegate = picker.delegate {
+                    delegate.imagePickerControllerDidCancel(picker)
+                } else {
+                    picker.dismiss(animated: true)
+                }
+            }
+        }
+        .padding()
+    }
+}

package/Sources/UIKit/Identity.swift

@@ -0,0 +1,24 @@
+// On iOS UIKit's views, view controllers and presentation controllers are
+// NSObjects, and NSObject is Equatable and Hashable: two objects are equal
+// when they are the same object (`isEqual:`'s default) and hash by address.
+// Code relies on it: `controllers.contains(controller)`, a `Set<UIView>`, a
+// dictionary keyed by view (SwiftUI-Introspect walks ancestors that way).
+// The shim's classes are not NSObjects, so they get the same identity
+// conformances here.
+
+import Foundation
+
+extension UIView: Hashable {
+    nonisolated public static func == (lhs: UIView, rhs: UIView) -> Bool { lhs === rhs }
+    nonisolated public func hash(into hasher: inout Hasher) { hasher.combine(ObjectIdentifier(self)) }
+}
+
+extension UIViewController: Hashable {
+    nonisolated public static func == (lhs: UIViewController, rhs: UIViewController) -> Bool { lhs === rhs }
+    nonisolated public func hash(into hasher: inout Hasher) { hasher.combine(ObjectIdentifier(self)) }
+}
+
+extension UIPresentationController: Hashable {
+    nonisolated public static func == (lhs: UIPresentationController, rhs: UIPresentationController) -> Bool { lhs === rhs }
+    nonisolated public func hash(into hasher: inout Hasher) { hasher.combine(ObjectIdentifier(self)) }
+}