@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/AVFoundation/PlayerView.swift

@@ -0,0 +1,117 @@
+// The views that show a player: `_AVPlayerVideo` draws one as the page's
+// `video` element (AVKit's `VideoPlayer` and `AVPlayerViewController` use it,
+// with the native controls), and `AVPlayerLayer` is a UIKit layer whose
+// drawing is that view without controls, so a UIView whose layer (or a
+// sublayer of it) is a player layer shows the video (ViewTranslation.swift).
+
+import Foundation
+import SwiftUI
+import struct SwiftUI.CGSize
+import struct SwiftUI.CGRect
+import UIKit
+
+/// How a video fits its layer: letterboxed, cropped to fill, or stretched.
+public struct AVLayerVideoGravity: RawRepresentable, Hashable, Sendable {
+    public let rawValue: String
+    public init(rawValue: String) { self.rawValue = rawValue }
+    public init(_ rawValue: String) { self.rawValue = rawValue }
+    public static let resizeAspect = AVLayerVideoGravity("AVLayerVideoGravityResizeAspect")
+    public static let resizeAspectFill = AVLayerVideoGravity("AVLayerVideoGravityResizeAspectFill")
+    public static let resize = AVLayerVideoGravity("AVLayerVideoGravityResize")
+
+    /// The `video` element's `gravity` (CSS `object-fit` contain, cover, fill).
+    var _pageName: String {
+        switch self {
+        case .resizeAspectFill: "resizeAspectFill"
+        case .resize: "resize"
+        default: "resizeAspect"
+        }
+    }
+}
+
+/// A player drawn as a `video` element: black while there is no player. Each
+/// player gets its own surface (keyed by identity), so a view that is handed
+/// another player attaches to it afresh.
+public struct _AVPlayerVideo: View {
+    let player: AVPlayer?
+    let gravity: AVLayerVideoGravity
+    let controls: Bool
+
+    nonisolated public init(player: AVPlayer?, gravity: AVLayerVideoGravity, controls: Bool) {
+        self.player = player
+        self.gravity = gravity
+        self.controls = controls
+    }
+
+    public var body: some View {
+        if let player {
+            ForEach([ObjectIdentifier(player)], id: \.self) { _ in
+                _AVPlayerSurfaceView(player: player, gravity: gravity, controls: controls)
+            }
+        } else {
+            Color.black
+        }
+    }
+}
+
+/// The identity of one view showing a player.
+final class _AVPlayerSurface {}
+
+/// One view of one player: attaches while it is on screen, and draws the
+/// element with the player's props (its body reads the player's observed
+/// state, so a change of rate, mute, item or seek draws it again).
+struct _AVPlayerSurfaceView: View {
+    let player: AVPlayer
+    let gravity: AVLayerVideoGravity
+    let controls: Bool
+    @State private var surface = _AVPlayerSurface()
+
+    var body: some View {
+        let id = ObjectIdentifier(surface)
+        let player = self.player
+        _VideoElement(props: player._videoProps(surface: id, gravity: gravity, controls: controls)) { [weak player] event in
+            player?._event(event, from: id)
+        }
+        .onAppear { player._attach(id) }
+        .onDisappear { player._detach(id) }
+    }
+}
+
+/// A layer that shows a player's video. In a UIView (as its `layerClass` or
+/// a sublayer), the view draws the player filling its bounds, with
+/// `videoGravity`, and no controls.
+open class AVPlayerLayer: CALayer, @unchecked Sendable {
+    open var player: AVPlayer? { didSet { if player !== oldValue { _changed() } } }
+    open var videoGravity: AVLayerVideoGravity = .resizeAspect { didSet { if videoGravity != oldValue { _changed() } } }
+    /// Whether the native controls show (AVKit's player view controller sets it).
+    public var _showsControls = false { didSet { if _showsControls != oldValue { _changed() } } }
+    open var pixelBufferAttributes: [String: Any]?
+
+    public convenience init(player: AVPlayer?) {
+        self.init()
+        self.player = player
+    }
+
+    /// True once the current item's first frame can show (the page read its metadata).
+    open var isReadyForDisplay: Bool { player?.currentItem?.status == .readyToPlay }
+
+    /// Where the video is drawn in the layer's bounds, for its gravity.
+    open var videoRect: CGRect {
+        guard let size = player?.currentItem?.presentationSize, size.width > 0, size.height > 0 else { return .zero }
+        let box = bounds
+        switch videoGravity {
+        case .resize:
+            return box
+        default:
+            let fit = videoGravity == .resizeAspectFill
+                ? max(box.width / size.width, box.height / size.height)
+                : min(box.width / size.width, box.height / size.height)
+            let width = size.width * fit, height = size.height * fit
+            return CGRect(x: box.midX - width / 2, y: box.midY - height / 2, width: width, height: height)
+        }
+    }
+
+    open override var _drawing: AnyView? {
+        AnyView(_AVPlayerVideo(player: player, gravity: videoGravity, controls: _showsControls))
+    }
+}

package/Sources/AVKit/AVKit.swift

@@ -0,0 +1,132 @@
+// `import AVKit` for the browser: SwiftUI's `VideoPlayer` and UIKit's
+// `AVPlayerViewController`, both drawn as the page's `video` element with its
+// native controls (docs/ops-protocol.md, "Video and audio"). The player is
+// AVFoundation's `AVPlayer`, which AVKit re-exports as on iOS.
+//
+// Picture in Picture, AirPlay routes and the system's now-playing info are
+// not available: their types answer that they are unsupported.
+@_exported import AVFoundation
+import SwiftUI
+import UIKit
+
+/// A view that plays `player`'s current item with the browser's playback
+/// controls, letterboxed on black, filling the space it is offered.
+/// `videoOverlay` is drawn over the video (and over the controls where it
+/// has content, so a full-size overlay takes the taps).
+public struct VideoPlayer<VideoOverlay: View>: View {
+    let player: AVPlayer?
+    let overlay: VideoOverlay
+
+    public init(player: AVPlayer?, @ViewBuilder videoOverlay: () -> VideoOverlay) {
+        self.player = player
+        overlay = videoOverlay()
+    }
+
+    public var body: some View {
+        ZStack {
+            _AVPlayerVideo(player: player, gravity: .resizeAspect, controls: true)
+            overlay
+        }
+    }
+}
+
+extension VideoPlayer where VideoOverlay == EmptyView {
+    public init(player: AVPlayer?) {
+        self.init(player: player) { EmptyView() }
+    }
+}
+
+// MARK: - AVPlayerViewController
+
+/// What an `AVPlayerViewController` tells its owner. Every method is optional;
+/// full screen and Picture in Picture never start in the browser build.
+@MainActor
+public protocol AVPlayerViewControllerDelegate: AnyObject {
+    func playerViewControllerShouldAutomaticallyDismissAtPictureInPictureStart(_ playerViewController: AVPlayerViewController) -> Bool
+    func playerViewControllerWillStartPictureInPicture(_ playerViewController: AVPlayerViewController)
+    func playerViewControllerDidStopPictureInPicture(_ playerViewController: AVPlayerViewController)
+}
+
+extension AVPlayerViewControllerDelegate {
+    public func playerViewControllerShouldAutomaticallyDismissAtPictureInPictureStart(_ playerViewController: AVPlayerViewController) -> Bool { true }
+    public func playerViewControllerWillStartPictureInPicture(_ playerViewController: AVPlayerViewController) {}
+    public func playerViewControllerDidStopPictureInPicture(_ playerViewController: AVPlayerViewController) {}
+}
+
+/// The view of an `AVPlayerViewController`: its layer is the player layer.
+final class _AVPlayerControllerView: UIView {
+    override class var layerClass: AnyClass { AVPlayerLayer.self }
+    var playerLayer: AVPlayerLayer { layer as! AVPlayerLayer }
+}
+
+/// A controller whose view plays `player` (with the native controls unless
+/// `showsPlaybackControls` is off). Shown by a `UIViewControllerRepresentable`
+/// or as a child controller's view, it draws like `VideoPlayer`; the
+/// `contentOverlayView` is drawn over the video.
+@MainActor
+open class AVPlayerViewController: UIViewController {
+    open var player: AVPlayer? { didSet { playerLayer?.player = player } }
+    open var showsPlaybackControls = true { didSet { playerLayer?._showsControls = showsPlaybackControls } }
+    open var videoGravity: AVLayerVideoGravity = .resizeAspect { didSet { playerLayer?.videoGravity = videoGravity } }
+    open weak var delegate: (any AVPlayerViewControllerDelegate)?
+    open var allowsPictureInPicturePlayback = true
+    open var canStartPictureInPictureAutomaticallyFromInline = false
+    open var entersFullScreenWhenPlaybackBegins = false
+    open var exitsFullScreenWhenPlaybackEnds = false
+    open var updatesNowPlayingInfoCenter = true
+    open var requiresLinearPlayback = false
+    open var showsTimecodes = false
+    open var allowsVideoFrameAnalysis = false
+    open var speeds: [AVPlaybackSpeed] = AVPlaybackSpeed.systemDefaultSpeeds
+    open var isReadyForDisplay: Bool { playerLayer?.isReadyForDisplay ?? false }
+    open var videoBounds: CGRect { playerLayer?.videoRect ?? .zero }
+    /// A view over the video, below the controls.
+    public private(set) lazy var contentOverlayView: UIView? = {
+        let overlay = UIView(frame: view.bounds)
+        overlay.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        view.addSubview(overlay)
+        return overlay
+    }()
+
+    private var playerLayer: AVPlayerLayer? { (viewIfLoaded as? _AVPlayerControllerView)?.playerLayer }
+
+    open override func loadView() {
+        let playerView = _AVPlayerControllerView()
+        playerView.playerLayer.player = player
+        playerView.playerLayer._showsControls = showsPlaybackControls
+        playerView.playerLayer.videoGravity = videoGravity
+        playerView.backgroundColor = .black
+        view = playerView
+    }
+}
+
+/// A playback speed the controls offer (the browser's own menu applies).
+public struct AVPlaybackSpeed: Hashable, Sendable {
+    public let rate: Float
+    public let localizedName: String
+    public init(rate: Float, localizedName: String) {
+        self.rate = rate
+        self.localizedName = localizedName
+    }
+    public static let systemDefaultSpeeds = [0.5, 1, 1.25, 1.5, 2].map { AVPlaybackSpeed(rate: Float($0), localizedName: "\($0)×") }
+}
+
+// MARK: - Picture in Picture and routes
+
+/// Picture in Picture is not available in the browser build.
+@MainActor
+open class AVPictureInPictureController {
+    public static func isPictureInPictureSupported() -> Bool { false }
+    public let playerLayer: AVPlayerLayer
+    open var isPictureInPictureActive: Bool { false }
+    open var isPictureInPicturePossible: Bool { false }
+    open var canStartPictureInPictureAutomaticallyFromInline = false
+
+    /// Nil: Picture in Picture is not supported.
+    public init?(playerLayer: AVPlayerLayer) {
+        return nil
+    }
+
+    open func startPictureInPicture() {}
+    open func stopPictureInPicture() {}
+}

package/Sources/Accelerate/Accelerate.swift

@@ -0,0 +1,122 @@
+// `import Accelerate` for the browser: vImage's buffers and box convolutions,
+// as image code calls them (Nuke's Gaussian blur runs three box passes over
+// a Core Graphics context's memory). A buffer over a `CGContext`'s `data` has
+// no pixels here (the page draws them), so a convolution between two contexts
+// becomes a recipe step on the destination (`CGContext._boxConvolve`), and
+// the page blurs. A buffer of real memory is convolved on the spot.
+
+import CoreGraphics
+import SwiftUI
+
+public typealias vImagePixelCount = UInt
+public typealias vImage_Flags = UInt32
+public typealias vImage_Error = Int
+
+public let kvImageNoFlags: Int = 0
+public let kvImageLeaveAlphaUnchanged: Int = 1
+public let kvImageCopyInPlace: Int = 2
+public let kvImageBackgroundColorFill: Int = 4
+public let kvImageEdgeExtend: Int = 8
+public let kvImageDoNotTile: Int = 16
+public let kvImageHighQualityResampling: Int = 32
+public let kvImageTruncateKernel: Int = 64
+public let kvImageGetTempBufferSize: Int = 128
+
+public let kvImageNoError: Int = 0
+public let kvImageRoiLargerThanInputBuffer: Int = -21766
+public let kvImageInvalidKernelSize: Int = -21767
+public let kvImageNullPointerArgument: Int = -21772
+
+/// A bitmap in memory: `height` rows of `rowBytes` bytes at `data`.
+public struct vImage_Buffer {
+    public var data: UnsafeMutableRawPointer!
+    public var height: vImagePixelCount
+    public var width: vImagePixelCount
+    public var rowBytes: Int
+
+    public init() {
+        data = nil
+        height = 0
+        width = 0
+        rowBytes = 0
+    }
+
+    public init(data: UnsafeMutableRawPointer!, height: vImagePixelCount, width: vImagePixelCount, rowBytes: Int) {
+        self.data = data
+        self.height = height
+        self.width = width
+        self.rowBytes = rowBytes
+    }
+}
+
+/// A box blur of a four-channel, eight-bit image: each pixel becomes the mean
+/// of the `kernel_width` × `kernel_height` box around it.
+public func vImageBoxConvolve_ARGB8888(_ src: UnsafePointer<vImage_Buffer>, _ dest: UnsafePointer<vImage_Buffer>, _ tempBuffer: UnsafeMutableRawPointer?,
+                                       _ srcOffsetToROI_X: vImagePixelCount, _ srcOffsetToROI_Y: vImagePixelCount,
+                                       _ kernel_height: UInt32, _ kernel_width: UInt32, _ backgroundColor: UnsafePointer<UInt8>?, _ flags: vImage_Flags) -> vImage_Error {
+    _boxConvolve(src.pointee, dest.pointee, channels: 4, offset: (Int(srcOffsetToROI_X), Int(srcOffsetToROI_Y)),
+                 kernel: (Int(kernel_width), Int(kernel_height)), background: backgroundColor, flags: flags)
+}
+
+/// The same for one eight-bit channel.
+public func vImageBoxConvolve_Planar8(_ src: UnsafePointer<vImage_Buffer>, _ dest: UnsafePointer<vImage_Buffer>, _ tempBuffer: UnsafeMutableRawPointer?,
+                                      _ srcOffsetToROI_X: vImagePixelCount, _ srcOffsetToROI_Y: vImagePixelCount,
+                                      _ kernel_height: UInt32, _ kernel_width: UInt32, _ backgroundColor: UInt8, _ flags: vImage_Flags) -> vImage_Error {
+    var background = backgroundColor
+    return _boxConvolve(src.pointee, dest.pointee, channels: 1, offset: (Int(srcOffsetToROI_X), Int(srcOffsetToROI_Y)),
+                        kernel: (Int(kernel_width), Int(kernel_height)), background: &background, flags: flags)
+}
+
+func _boxConvolve(_ src: vImage_Buffer, _ dest: vImage_Buffer, channels: Int, offset: (Int, Int), kernel: (Int, Int),
+                  background: UnsafePointer<UInt8>?, flags: vImage_Flags) -> vImage_Error {
+    guard kernel.0 > 0, kernel.1 > 0, kernel.0 % 2 == 1, kernel.1 % 2 == 1 else { return kvImageInvalidKernelSize }
+    if Int(flags) & kvImageGetTempBufferSize != 0 { return 0 }
+    guard let srcData = src.data, let destData = dest.data else { return kvImageNullPointerArgument }
+    let extend = Int(flags) & kvImageEdgeExtend != 0
+    // Contexts: the page has the pixels; record the blur.
+    if let from = CGContext._context(withData: srcData), let to = CGContext._context(withData: destData) {
+        to._boxConvolve(from: from, kernelWidth: kernel.0, kernelHeight: kernel.1, extendEdges: extend)
+        return kvImageNoError
+    }
+    let width = Int(dest.width), height = Int(dest.height)
+    guard offset.0 + width <= Int(src.width), offset.1 + height <= Int(src.height) else { return kvImageRoiLargerThanInputBuffer }
+    let input = srcData.assumingMemoryBound(to: UInt8.self)
+    let output = destData.assumingMemoryBound(to: UInt8.self)
+    let rx = kernel.0 / 2, ry = kernel.1 / 2
+    let area = kernel.0 * kernel.1
+    let copyAlpha = Int(flags) & kvImageLeaveAlphaUnchanged != 0 && channels == 4
+    // Into a separate buffer first, so the source and destination may be the same memory.
+    var result = [UInt8](repeating: 0, count: width * height * channels)
+    for y in 0..<height {
+        for x in 0..<width {
+            for c in 0..<channels {
+                var sum = 0
+                for ky in -ry...ry {
+                    for kx in -rx...rx {
+                        var sx = offset.0 + x + kx, sy = offset.1 + y + ky
+                        if sx < 0 || sy < 0 || sx >= Int(src.width) || sy >= Int(src.height) {
+                            if extend {
+                                sx = min(max(sx, 0), Int(src.width) - 1)
+                                sy = min(max(sy, 0), Int(src.height) - 1)
+                            } else {
+                                sum += Int(background?[c] ?? 0)
+                                continue
+                            }
+                        }
+                        sum += Int(input[sy * src.rowBytes + sx * channels + c])
+                    }
+                }
+                result[(y * width + x) * channels + c] = UInt8((sum + area / 2) / area)
+            }
+        }
+    }
+    for y in 0..<height {
+        for x in 0..<width {
+            for c in 0..<channels {
+                if copyAlpha && c == 0 { continue }
+                output[y * dest.rowBytes + x * channels + c] = result[(y * width + x) * channels + c]
+            }
+        }
+    }
+    return kvImageNoError
+}

package/Sources/AppIntents/AppIntents.swift

@@ -0,0 +1,144 @@
+// `import AppIntents` for the browser: the types apps declare their intents,
+// entities, enums and App Shortcuts with, and SwiftUI's `Button(intent:)`.
+//
+// Nothing outside the app runs an intent here: the browser has no Shortcuts,
+// Siri, Spotlight, widgets or Action button, so an `AppShortcutsProvider`'s
+// shortcuts, an intent's title, description and phrases, and an entity's
+// queries are declarations nobody reads. What the app does with its own
+// intents still happens: a `Button(intent:)` (and ButtonKit's
+// `AsyncButton(intent:)`) runs the intent's `perform()` when tapped, as on
+// iOS, with the parameters the app set on it. A parameter the app left unset
+// has no Shortcuts to ask for it: an optional one reads nil, any other one
+// stops the app with a message naming it.
+
+import Foundation
+import FoundationBridge
+import SwiftUI
+import UIKit
+import UniformTypeIdentifiers
+
+// MARK: - Intents
+
+/// An action of the app's. In the browser only the app itself performs one
+/// (through `Button(intent:)`); `title`, `openAppWhenRun` and the rest are kept
+/// for the declarations to compile.
+public protocol AppIntent: Sendable {
+    associatedtype PerformResult: IntentResult
+    static var title: LocalizedStringResource { get }
+    /// Whether Shortcuts opens the app first: the app is always open in the browser.
+    static var openAppWhenRun: Bool { get }
+    static var isDiscoverable: Bool { get }
+    static var authenticationPolicy: IntentAuthenticationPolicy { get }
+    init()
+    func perform() async throws -> PerformResult
+}
+
+extension AppIntent {
+    public static var openAppWhenRun: Bool { false }
+    public static var isDiscoverable: Bool { true }
+    public static var authenticationPolicy: IntentAuthenticationPolicy { .alwaysAllowed }
+}
+
+/// Intents that continue in the app, play audio, drive a Live Activity or
+/// configure a widget: markers here, as nothing outside the app runs them.
+public protocol ForegroundContinuableIntent: AppIntent {}
+public protocol AudioPlaybackIntent: AppIntent {}
+public protocol LiveActivityIntent: AppIntent {}
+public protocol WidgetConfigurationIntent: AppIntent {}
+public protocol SystemIntent: AppIntent {}
+
+public enum IntentAuthenticationPolicy: Sendable {
+    case alwaysAllowed, requiresAuthentication, requiresLocalDeviceAuthentication
+}
+
+/// How an intent describes itself to Shortcuts (kept, not shown).
+public struct IntentDescription: Sendable, ExpressibleByStringInterpolation {
+    public var descriptionText: LocalizedStringResource
+    public var categoryName: LocalizedStringResource?
+    public var searchKeywords: [LocalizedStringResource]
+    public var resultValueName: LocalizedStringResource?
+
+    public init(_ descriptionText: LocalizedStringResource, categoryName: LocalizedStringResource? = nil,
+                searchKeywords: [LocalizedStringResource] = [], resultValueName: LocalizedStringResource? = nil) {
+        self.descriptionText = descriptionText
+        self.categoryName = categoryName
+        self.searchKeywords = searchKeywords
+        self.resultValueName = resultValueName
+    }
+
+    public init(stringLiteral value: String) { self.init(LocalizedStringResource(stringLiteral: value)) }
+    public init(stringInterpolation: LocalizedStringResource.StringInterpolation) {
+        self.init(LocalizedStringResource(stringInterpolation: stringInterpolation))
+    }
+}
+
+/// What Siri would say. `perform()` results keep it; nothing speaks it.
+public struct IntentDialog: Sendable, ExpressibleByStringInterpolation {
+    public var full: LocalizedStringResource
+    public var supporting: LocalizedStringResource
+    public var systemImageName: String?
+
+    public init(_ resource: LocalizedStringResource) {
+        full = resource
+        supporting = resource
+    }
+
+    public init(full: LocalizedStringResource, supporting: LocalizedStringResource, systemImageName: String? = nil) {
+        self.full = full
+        self.supporting = supporting
+        self.systemImageName = systemImageName
+    }
+
+    public init(stringLiteral value: String) { self.init(LocalizedStringResource(stringLiteral: value)) }
+    public init(stringInterpolation: LocalizedStringResource.StringInterpolation) {
+        self.init(LocalizedStringResource(stringInterpolation: stringInterpolation))
+    }
+}
+
+// MARK: - Results
+
+/// What `perform()` returns. Results are made with `.result(…)`.
+public protocol IntentResult: Sendable {}
+public protocol ProvidesDialog: IntentResult {}
+public protocol ShowsSnippetView: IntentResult {}
+public protocol OpensIntent: IntentResult {}
+public protocol ReturnsValue<Value>: IntentResult {
+    associatedtype Value
+}
+
+/// Every result: its value, dialog, snippet view and the intent it opens, as given.
+public struct IntentResultContainer<Value>: IntentResult, ProvidesDialog, ShowsSnippetView, OpensIntent, ReturnsValue, @unchecked Sendable {
+    public let value: Value?
+    public let dialog: IntentDialog?
+    /// The snippet view, which nothing shows.
+    public let view: (any View)?
+    /// The intent to run next, which nothing runs.
+    public let opensIntent: (any AppIntent)?
+}
+
+extension IntentResult where Self == IntentResultContainer<Never> {
+    public static func result() -> Self { .init(value: nil, dialog: nil, view: nil, opensIntent: nil) }
+    public static func result(dialog: IntentDialog) -> Self { .init(value: nil, dialog: dialog, view: nil, opensIntent: nil) }
+    public static func result(view: some View) -> Self { .init(value: nil, dialog: nil, view: view, opensIntent: nil) }
+    public static func result(dialog: IntentDialog, view: some View) -> Self { .init(value: nil, dialog: dialog, view: view, opensIntent: nil) }
+    public static func result(dialog: IntentDialog, @ViewBuilder content: () -> some View) -> Self {
+        .init(value: nil, dialog: dialog, view: content(), opensIntent: nil)
+    }
+    public static func result(opensIntent: some AppIntent, dialog: IntentDialog? = nil) -> Self {
+        .init(value: nil, dialog: dialog, view: nil, opensIntent: opensIntent)
+    }
+    public static func result<Value>(value: Value, dialog: IntentDialog? = nil) -> IntentResultContainer<Value> {
+        .init(value: value, dialog: dialog, view: nil, opensIntent: nil)
+    }
+    public static func result<Value>(value: Value, dialog: IntentDialog? = nil, view: some View) -> IntentResultContainer<Value> {
+        .init(value: value, dialog: dialog, view: view, opensIntent: nil)
+    }
+    public static func result<Value>(value: Value, opensIntent: some AppIntent, dialog: IntentDialog? = nil) -> IntentResultContainer<Value> {
+        .init(value: value, dialog: dialog, view: nil, opensIntent: opensIntent)
+    }
+}
+
+/// An intent's error that carries a message for Siri (kept in `localizedStringResource`).
+public protocol CustomLocalizedStringResourceConvertible {
+    var localizedStringResource: LocalizedStringResource { get }
+}