@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/WeatherKit/WeatherKit.swift

@@ -0,0 +1,228 @@
+// `import WeatherKit` for the browser. Apple's weather service answers only
+// apps signed with the WeatherKit capability (the device asks for a token
+// on the app's behalf); a web page has no such signature, so every request
+// throws `WeatherError.permissionDenied`, as it does on a device for an app
+// without the capability. The types are here so an app compiles and takes
+// its own fallback (Apple's Food Truck keeps its placeholder forecast and a
+// clear sky) (docs/ops-protocol.md, "Weather").
+
+import CoreLocation
+import Foundation
+
+/// Why a weather request failed.
+public enum WeatherError: LocalizedError, Sendable {
+    /// The app may not use the weather service: always, in the browser.
+    case permissionDenied
+    case unknown
+
+    public var errorDescription: String? {
+        switch self {
+        case .permissionDenied: "WeatherKit is not available in the browser."
+        case .unknown: "The weather service failed."
+        }
+    }
+}
+
+/// Requests weather; in the browser every request throws (see the top of this file).
+public final class WeatherService: Sendable {
+    public static let shared = WeatherService()
+    public init() {}
+
+    public func weather(for location: CLLocation) async throws -> Weather {
+        throw WeatherError.permissionDenied
+    }
+
+    public func weather<T>(for location: CLLocation, including dataSet: WeatherQuery<T>) async throws -> T {
+        throw WeatherError.permissionDenied
+    }
+
+    public func weather<T1, T2>(for location: CLLocation, including dataSet1: WeatherQuery<T1>, _ dataSet2: WeatherQuery<T2>) async throws -> (T1, T2) {
+        throw WeatherError.permissionDenied
+    }
+
+    public func weather<T1, T2, T3>(for location: CLLocation, including dataSet1: WeatherQuery<T1>, _ dataSet2: WeatherQuery<T2>,
+                                    _ dataSet3: WeatherQuery<T3>) async throws -> (T1, T2, T3) {
+        throw WeatherError.permissionDenied
+    }
+
+    public var attribution: WeatherAttribution {
+        get async throws { throw WeatherError.permissionDenied }
+    }
+}
+
+/// A data set to request (`.current`, `.hourly`, …).
+public struct WeatherQuery<T>: @unchecked Sendable {
+    init() {}
+
+    public static var current: WeatherQuery<CurrentWeather> { WeatherQuery<CurrentWeather>() }
+    public static var minute: WeatherQuery<Forecast<MinuteWeather>?> { WeatherQuery<Forecast<MinuteWeather>?>() }
+    public static var hourly: WeatherQuery<Forecast<HourWeather>> { WeatherQuery<Forecast<HourWeather>>() }
+    public static var daily: WeatherQuery<Forecast<DayWeather>> { WeatherQuery<Forecast<DayWeather>>() }
+    public static var alerts: WeatherQuery<[WeatherAlert]?> { WeatherQuery<[WeatherAlert]?>() }
+    public static func hourly(startDate: Date, endDate: Date) -> WeatherQuery<Forecast<HourWeather>> { WeatherQuery<Forecast<HourWeather>>() }
+    public static func daily(startDate: Date, endDate: Date) -> WeatherQuery<Forecast<DayWeather>> { WeatherQuery<Forecast<DayWeather>>() }
+}
+
+/// The weather at a place: now, by the minute, the hour and the day.
+public struct Weather: Sendable {
+    public var currentWeather: CurrentWeather
+    public var minuteForecast: Forecast<MinuteWeather>?
+    public var hourlyForecast: Forecast<HourWeather>
+    public var dailyForecast: Forecast<DayWeather>
+    public var weatherAlerts: [WeatherAlert]?
+}
+
+/// A forecast: its entries, in time order.
+public struct Forecast<Element: Sendable>: RandomAccessCollection, Sendable {
+    public var forecast: [Element]
+    public var startIndex: Int { forecast.startIndex }
+    public var endIndex: Int { forecast.endIndex }
+    public subscript(position: Int) -> Element { forecast[position] }
+    public var summary: String { "" }
+}
+
+public struct CurrentWeather: Sendable {
+    public var date: Date
+    public var condition: WeatherCondition
+    public var symbolName: String
+    public var temperature: Measurement<UnitTemperature>
+    public var apparentTemperature: Measurement<UnitTemperature>
+    public var dewPoint: Measurement<UnitTemperature>
+    public var humidity: Double
+    public var cloudCover: Double
+    public var isDaylight: Bool
+    public var visibility: Measurement<UnitLength>
+    public var wind: Wind
+    public var pressure: Measurement<UnitPressure>
+    public var uvIndex: UVIndex
+}
+
+public struct MinuteWeather: Sendable {
+    public var date: Date
+    public var precipitation: Precipitation
+    public var precipitationChance: Double
+    public var precipitationIntensity: Measurement<UnitSpeed>
+}
+
+public struct HourWeather: Sendable {
+    public var date: Date
+    public var condition: WeatherCondition
+    public var symbolName: String
+    public var temperature: Measurement<UnitTemperature>
+    public var apparentTemperature: Measurement<UnitTemperature>
+    public var humidity: Double
+    public var cloudCover: Double
+    public var isDaylight: Bool
+    public var precipitation: Precipitation
+    public var precipitationChance: Double
+    public var precipitationAmount: Measurement<UnitLength>
+    public var wind: Wind
+    public var uvIndex: UVIndex
+}
+
+public struct DayWeather: Sendable {
+    public var date: Date
+    public var condition: WeatherCondition
+    public var symbolName: String
+    public var highTemperature: Measurement<UnitTemperature>
+    public var lowTemperature: Measurement<UnitTemperature>
+    public var precipitation: Precipitation
+    public var precipitationChance: Double
+    public var wind: Wind
+    public var uvIndex: UVIndex
+}
+
+public struct Wind: Sendable {
+    public var compassDirection: Direction
+    public var direction: Measurement<UnitAngle>
+    public var speed: Measurement<UnitSpeed>
+    public var gust: Measurement<UnitSpeed>?
+
+    public enum Direction: String, CaseIterable, Sendable {
+        case north, northNortheast, northeast, eastNortheast, east, eastSoutheast, southeast, southSoutheast
+        case south, southSouthwest, southwest, westSouthwest, west, westNorthwest, northwest, northNorthwest
+    }
+}
+
+public struct UVIndex: Sendable {
+    public var value: Int
+    public var category: ExposureCategory
+
+    public enum ExposureCategory: String, CaseIterable, Sendable {
+        case low, moderate, high, veryHigh, extreme
+    }
+}
+
+public enum Precipitation: String, CaseIterable, Sendable, CustomStringConvertible {
+    case none, hail, mixed, rain, sleet, snow
+
+    public var description: String { rawValue.capitalized }
+    public var accessibilityDescription: String { description }
+}
+
+public struct WeatherAlert: Sendable {
+    public var summary: String
+    public var detailsURL: URL
+    public var source: String
+    public var region: String?
+}
+
+/// The attribution an app shows with the weather (Apple's logos and legal page).
+public struct WeatherAttribution: Sendable {
+    public var serviceName: String
+    public var legalPageURL: URL
+    public var legalAttributionText: String
+    public var combinedMarkLightURL: URL
+    public var combinedMarkDarkURL: URL
+    public var squareMarkURL: URL
+}
+
+/// A description of the weather, with Apple's cases.
+public enum WeatherCondition: String, CaseIterable, Codable, Hashable, Sendable, CustomStringConvertible {
+    case blizzard
+    case blowingDust
+    case blowingSnow
+    case breezy
+    case clear
+    case cloudy
+    case drizzle
+    case flurries
+    case foggy
+    case freezingDrizzle
+    case freezingRain
+    case frigid
+    case hail
+    case haze
+    case heavyRain
+    case heavySnow
+    case hot
+    case hurricane
+    case isolatedThunderstorms
+    case mostlyClear
+    case mostlyCloudy
+    case partlyCloudy
+    case rain
+    case scatteredThunderstorms
+    case sleet
+    case smoky
+    case snow
+    case strongStorms
+    case sunFlurries
+    case sunShowers
+    case thunderstorms
+    case tropicalStorm
+    case windy
+    case wintryMix
+
+    /// The condition in words (`partlyCloudy` is "Partly Cloudy").
+    public var description: String {
+        var words = ""
+        for character in rawValue {
+            if character.isUppercase { words.append(" ") }
+            words.append(character)
+        }
+        return words.prefix(1).uppercased() + words.dropFirst()
+    }
+
+    public var accessibilityDescription: String { description }
+}

package/Sources/WebKit/WebKit.swift

@@ -0,0 +1,245 @@
+// `import WebKit` for the browser: `WKWebView` and the types around it, as
+// declarations that keep their state. A web view inside the page would be an
+// iframe, and most sites refuse to be framed (X-Frame-Options, CSP's
+// frame-ancestors), so the shim has no renderer for one; and since there is
+// no `UIViewRepresentable`, a UIKit view never reaches the screen anyway.
+// What compiles: configuring a web view, `load` (the URL is recorded, nothing
+// is fetched, no navigation delegate method is called), the history and
+// progress properties (empty, finished), and `evaluateJavaScript`, which
+// fails. Ice Cubes imports WebKit and uses none of it; code that does use it
+// compiles and shows nothing.
+
+import Foundation
+import FoundationBridge
+import SwiftUI
+import UIKit
+
+/// WebKit's errors, with Apple's codes.
+public struct WKError: Error, Hashable, Sendable {
+    public enum Code: Int, Sendable {
+        case unknown = 1
+        case webContentProcessTerminated = 2
+        case webViewInvalidated = 3
+        case javaScriptExceptionOccurred = 4
+        case javaScriptResultTypeIsUnsupported = 5
+    }
+
+    public let code: Code
+    public init(_ code: Code) { self.code = code }
+
+    public static let unknown = Code.unknown
+    public static let javaScriptExceptionOccurred = Code.javaScriptExceptionOccurred
+}
+
+// MARK: - Configuration
+
+/// Website data (cookies, storage): the browser's own, so both stores are the same.
+@MainActor
+open class WKWebsiteDataStore {
+    public let isPersistent: Bool
+    init(persistent: Bool) { isPersistent = persistent }
+    public static func `default`() -> WKWebsiteDataStore { WKWebsiteDataStore(persistent: true) }
+    public static func nonPersistent() -> WKWebsiteDataStore { WKWebsiteDataStore(persistent: false) }
+    public static func allWebsiteDataTypes() -> Set<String> { [] }
+    /// Nothing to remove: the page cannot reach another site's data.
+    open func removeData(ofTypes dataTypes: Set<String>, modifiedSince date: Date, completionHandler: @escaping @MainActor () -> Void) {
+        completionHandler()
+    }
+}
+
+@MainActor
+open class WKPreferences {
+    open var javaScriptCanOpenWindowsAutomatically = false
+    open var isFraudulentWebsiteWarningEnabled = true
+    open var minimumFontSize: CGFloat = 0
+    public init() {}
+}
+
+@MainActor
+open class WKWebpagePreferences {
+    open var allowsContentJavaScript = true
+    public init() {}
+}
+
+/// A message a page's script posts to the app; none ever arrives.
+@MainActor
+open class WKScriptMessage {
+    public let name: String
+    public let body: Any
+    init(name: String, body: Any) {
+        self.name = name
+        self.body = body
+    }
+}
+
+@MainActor
+public protocol WKScriptMessageHandler: AnyObject {
+    func userContentController(_ userContentController: WKUserContentController, didReceive message: WKScriptMessage)
+}
+
+/// A script to inject into pages; kept.
+@MainActor
+open class WKUserScript {
+    public enum InjectionTime: Int, Sendable { case atDocumentStart, atDocumentEnd }
+    public let source: String
+    public let injectionTime: InjectionTime
+    public let isForMainFrameOnly: Bool
+    public init(source: String, injectionTime: InjectionTime, forMainFrameOnly: Bool) {
+        self.source = source
+        self.injectionTime = injectionTime
+        self.isForMainFrameOnly = forMainFrameOnly
+    }
+}
+
+/// Scripts and message handlers; kept.
+@MainActor
+open class WKUserContentController {
+    public private(set) var userScripts: [WKUserScript] = []
+    private var handlers: [String: any WKScriptMessageHandler] = [:]
+    public init() {}
+    open func addUserScript(_ userScript: WKUserScript) { userScripts.append(userScript) }
+    open func removeAllUserScripts() { userScripts.removeAll() }
+    open func add(_ scriptMessageHandler: any WKScriptMessageHandler, name: String) { handlers[name] = scriptMessageHandler }
+    open func removeScriptMessageHandler(forName name: String) { handlers[name] = nil }
+    open func removeAllScriptMessageHandlers() { handlers.removeAll() }
+}
+
+@MainActor
+open class WKWebViewConfiguration {
+    open var websiteDataStore = WKWebsiteDataStore.default()
+    open var preferences = WKPreferences()
+    open var defaultWebpagePreferences = WKWebpagePreferences()
+    open var userContentController = WKUserContentController()
+    open var allowsInlineMediaPlayback = false
+    open var mediaTypesRequiringUserActionForPlayback: WKAudiovisualMediaTypes = .all
+    open var applicationNameForUserAgent: String?
+    public init() {}
+}
+
+public struct WKAudiovisualMediaTypes: OptionSet, Sendable {
+    public let rawValue: UInt
+    public init(rawValue: UInt) { self.rawValue = rawValue }
+    public static let audio = WKAudiovisualMediaTypes(rawValue: 1 << 0)
+    public static let video = WKAudiovisualMediaTypes(rawValue: 1 << 1)
+    public static let all: WKAudiovisualMediaTypes = [.audio, .video]
+}
+
+// MARK: - Navigation
+
+/// One load; returned by `load` and never reported on.
+@MainActor
+open class WKNavigation {}
+
+public enum WKNavigationType: Int, Sendable {
+    case linkActivated, formSubmitted, backForward, reload, formResubmitted
+    case other = -1
+}
+
+public enum WKNavigationActionPolicy: Int, Sendable { case cancel, allow, download }
+public enum WKNavigationResponsePolicy: Int, Sendable { case cancel, allow, download }
+
+@MainActor
+open class WKNavigationAction {
+    public let request: URLRequest
+    public let navigationType: WKNavigationType
+    init(request: URLRequest, navigationType: WKNavigationType) {
+        self.request = request
+        self.navigationType = navigationType
+    }
+}
+
+/// What a web view tells about its loads. Every method is optional; none is
+/// called, since nothing loads.
+@MainActor
+public protocol WKNavigationDelegate: AnyObject {
+    func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction, decisionHandler: @escaping @MainActor (WKNavigationActionPolicy) -> Void)
+    func webView(_ webView: WKWebView, didStartProvisionalNavigation navigation: WKNavigation!)
+    func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!)
+    func webView(_ webView: WKWebView, didFail navigation: WKNavigation!, withError error: any Error)
+    func webView(_ webView: WKWebView, didFailProvisionalNavigation navigation: WKNavigation!, withError error: any Error)
+}
+
+extension WKNavigationDelegate {
+    public func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction, decisionHandler: @escaping @MainActor (WKNavigationActionPolicy) -> Void) {
+        decisionHandler(.allow)
+    }
+    public func webView(_ webView: WKWebView, didStartProvisionalNavigation navigation: WKNavigation!) {}
+    public func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {}
+    public func webView(_ webView: WKWebView, didFail navigation: WKNavigation!, withError error: any Error) {}
+    public func webView(_ webView: WKWebView, didFailProvisionalNavigation navigation: WKNavigation!, withError error: any Error) {}
+}
+
+/// Windows, alerts and panels a page's script asks for; never asked.
+@MainActor
+public protocol WKUIDelegate: AnyObject {}
+
+// MARK: - The web view
+
+/// A web view that keeps its state and shows nothing (see the top of this file).
+@MainActor
+open class WKWebView: UIView {
+    public let configuration: WKWebViewConfiguration
+    open weak var navigationDelegate: (any WKNavigationDelegate)?
+    open weak var uiDelegate: (any WKUIDelegate)?
+    open var allowsBackForwardNavigationGestures = false
+    open var allowsLinkPreview = true
+    open var customUserAgent: String?
+    open var isInspectable = false
+    /// The last URL given to `load`.
+    public private(set) var url: URL?
+    public private(set) var title: String?
+    /// Never loading: nothing is fetched.
+    public var isLoading: Bool { false }
+    public var estimatedProgress: Double { url == nil ? 0 : 1 }
+    public var canGoBack: Bool { false }
+    public var canGoForward: Bool { false }
+    public var hasOnlySecureContent: Bool { url?.scheme?.lowercased() == "https" }
+
+    public init(frame: CGRect, configuration: WKWebViewConfiguration) {
+        self.configuration = configuration
+        super.init(frame: frame)
+    }
+
+    public convenience override init(frame: CGRect) {
+        self.init(frame: frame, configuration: WKWebViewConfiguration())
+    }
+
+    public required init?(coder: NSCoder) {
+        configuration = WKWebViewConfiguration()
+        super.init(coder: coder)
+    }
+
+    /// Records the URL; nothing is fetched or shown.
+    @discardableResult
+    open func load(_ request: URLRequest) -> WKNavigation? {
+        url = request.url
+        return WKNavigation()
+    }
+
+    @discardableResult
+    open func loadHTMLString(_ string: String, baseURL: URL?) -> WKNavigation? {
+        url = baseURL
+        return WKNavigation()
+    }
+
+    @discardableResult
+    open func loadFileURL(_ URL: URL, allowingReadAccessTo readAccessURL: URL) -> WKNavigation? {
+        url = URL
+        return WKNavigation()
+    }
+
+    @discardableResult open func reload() -> WKNavigation? { url == nil ? nil : WKNavigation() }
+    @discardableResult open func goBack() -> WKNavigation? { nil }
+    @discardableResult open func goForward() -> WKNavigation? { nil }
+    open func stopLoading() {}
+
+    /// Fails: there is no page to run the script in.
+    open func evaluateJavaScript(_ javaScriptString: String, completionHandler: (@MainActor (Any?, (any Error)?) -> Void)? = nil) {
+        completionHandler?(nil, WKError(.javaScriptExceptionOccurred))
+    }
+
+    /// Throws `WKError.javaScriptExceptionOccurred`: there is no page to run the script in.
+    open func evaluateJavaScript(_ javaScriptString: String) async throws -> Any? {
+        throw WKError(.javaScriptExceptionOccurred)
+    }
+}