@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/LocalAuthentication/LAContext.swift

@@ -0,0 +1,86 @@
+// LocalAuthentication as a stand-in: the browser has no Face ID or Touch ID
+// to ask, so every policy can be evaluated and every evaluation succeeds at
+// once. Apps that lock content behind biometrics open as if the viewer had
+// authenticated; keep anything that must stay locked behind `#if !SWIFTBROWSER`.
+
+import Foundation
+
+public enum LAPolicy: Int, Sendable {
+    case deviceOwnerAuthenticationWithBiometrics = 1
+    case deviceOwnerAuthentication = 2
+}
+
+public enum LABiometryType: Int, Sendable {
+    case none = 0
+    case touchID = 1
+    case faceID = 2
+    case opticID = 4
+}
+
+/// Errors an evaluation can fail with. The stand-in never fails, but apps
+/// match on these codes.
+public struct LAError: Error, Hashable, Sendable {
+    public enum Code: Int, Sendable {
+        case authenticationFailed = -1
+        case userCancel = -2
+        case userFallback = -3
+        case systemCancel = -4
+        case passcodeNotSet = -5
+        case appCancel = -9
+        case invalidContext = -10
+        case biometryNotAvailable = -6
+        case biometryNotEnrolled = -7
+        case biometryLockout = -8
+        case notInteractive = -1004
+    }
+
+    public let code: Code
+
+    public init(_ code: Code) { self.code = code }
+
+    public static let authenticationFailed = Code.authenticationFailed
+    public static let userCancel = Code.userCancel
+    public static let userFallback = Code.userFallback
+    public static let systemCancel = Code.systemCancel
+    public static let passcodeNotSet = Code.passcodeNotSet
+    public static let appCancel = Code.appCancel
+    public static let invalidContext = Code.invalidContext
+    public static let biometryNotAvailable = Code.biometryNotAvailable
+    public static let biometryNotEnrolled = Code.biometryNotEnrolled
+    public static let biometryLockout = Code.biometryLockout
+    public static let notInteractive = Code.notInteractive
+}
+
+/// `@unchecked Sendable`: the stand-in keeps no state between calls, and an app
+/// awaiting `evaluatePolicy` from the main actor must be able to pass it along.
+open class LAContext: NSObject, @unchecked Sendable {
+    open var localizedReason: String = ""
+    open var localizedCancelTitle: String?
+    open var localizedFallbackTitle: String?
+
+    /// Face ID, so an app that names the biometry it asks for reads naturally.
+    open var biometryType: LABiometryType { .faceID }
+
+    public override init() {
+        super.init()
+    }
+
+    /// Always `true`; `error` is left untouched. (Apple's `NSErrorPointer`
+    /// spelled out: callers pass `&error` or `nil` either way.)
+    open func canEvaluatePolicy(_ policy: LAPolicy, error: UnsafeMutablePointer<NSError?>?) -> Bool {
+        true
+    }
+
+    /// Calls `reply(true, nil)` at once.
+    open func evaluatePolicy(_ policy: LAPolicy, localizedReason: String,
+                             reply: @escaping (Bool, (any Error)?) -> Void) {
+        reply(true, nil)
+    }
+
+    /// Returns `true`.
+    open func evaluatePolicy(_ policy: LAPolicy, localizedReason: String) async throws -> Bool {
+        true
+    }
+
+    open func invalidate() {}
+}

package/Sources/MapKit/Geometry.swift

@@ -0,0 +1,223 @@
+// MapKit for the browser: a stand-in with MapKit's SwiftUI API and value
+// types, drawn without map data (Map.swift). A map shows its region as a
+// plain surface with a grid of latitude and longitude lines, and places its
+// annotations, markers and overlays where they are on that region (Web
+// Mercator, as MapKit projects); it does not pan or zoom. See
+// docs/ops-protocol.md, "MapKit".
+
+@_exported import CoreLocation
+#if canImport(WASILibc)
+import WASILibc
+#elseif canImport(Glibc)
+import Glibc
+#elseif canImport(Musl)
+import Musl
+#elseif canImport(Darwin)
+import Darwin
+#endif
+import SwiftUI
+
+// MARK: - Regions
+
+/// A latitude and longitude extent, in degrees.
+public struct MKCoordinateSpan: Sendable {
+    public var latitudeDelta: CLLocationDegrees
+    public var longitudeDelta: CLLocationDegrees
+
+    public init() {
+        latitudeDelta = 0
+        longitudeDelta = 0
+    }
+
+    public init(latitudeDelta: CLLocationDegrees, longitudeDelta: CLLocationDegrees) {
+        self.latitudeDelta = latitudeDelta
+        self.longitudeDelta = longitudeDelta
+    }
+}
+
+/// A rectangular part of the map: a center and a span.
+public struct MKCoordinateRegion: Sendable {
+    public var center: CLLocationCoordinate2D
+    public var span: MKCoordinateSpan
+
+    public init() {
+        center = CLLocationCoordinate2D()
+        span = MKCoordinateSpan()
+    }
+
+    public init(center: CLLocationCoordinate2D, span: MKCoordinateSpan) {
+        self.center = center
+        self.span = span
+    }
+
+    /// The region around `center` this many meters tall and wide.
+    public init(center: CLLocationCoordinate2D, latitudinalMeters: CLLocationDistance, longitudinalMeters: CLLocationDistance) {
+        let metersPerDegree = 111_320.0
+        let latitude = latitudinalMeters / metersPerDegree
+        let longitude = longitudinalMeters / (metersPerDegree * max(0.01, cos(center.latitude * .pi / 180)))
+        self.init(center: center, span: MKCoordinateSpan(latitudeDelta: latitude, longitudeDelta: longitude))
+    }
+
+    /// The whole world, as a map that shows no particular place opens.
+    static let world = MKCoordinateRegion(center: CLLocationCoordinate2D(latitude: 20, longitude: 0),
+                                          span: MKCoordinateSpan(latitudeDelta: 140, longitudeDelta: 360))
+}
+
+// MARK: - Camera
+
+/// Where a map looks from: a center coordinate and a distance (in meters).
+public struct MapCamera: Sendable {
+    public var centerCoordinate: CLLocationCoordinate2D
+    public var distance: Double
+    public var heading: Double
+    public var pitch: Double
+
+    public init(centerCoordinate: CLLocationCoordinate2D, distance: Double, heading: Double = 0, pitch: Double = 0) {
+        self.centerCoordinate = centerCoordinate
+        self.distance = distance
+        self.heading = heading
+        self.pitch = pitch
+    }
+
+    /// The region the camera shows (its distance as the region's height).
+    var region: MKCoordinateRegion {
+        MKCoordinateRegion(center: centerCoordinate, latitudinalMeters: distance, longitudinalMeters: distance)
+    }
+}
+
+/// What a map shows: a region, a camera, the user's location, or what fits
+/// its content (`automatic`).
+public struct MapCameraPosition: Sendable {
+    enum Kind: Sendable {
+        case automatic
+        case region(MKCoordinateRegion)
+        case camera(MapCamera)
+        case userLocation(fallback: MKCoordinateRegion?)
+    }
+
+    let kind: Kind
+
+    public static var automatic: MapCameraPosition { MapCameraPosition(kind: .automatic) }
+
+    public static func region(_ region: MKCoordinateRegion) -> MapCameraPosition {
+        MapCameraPosition(kind: .region(region))
+    }
+
+    public static func camera(_ camera: MapCamera) -> MapCameraPosition {
+        MapCameraPosition(kind: .camera(camera))
+    }
+
+    /// The user's location; the browser has none, so the fallback is shown.
+    public static func userLocation(followsHeading: Bool = false, fallback: MapCameraPosition) -> MapCameraPosition {
+        MapCameraPosition(kind: .userLocation(fallback: fallback.shownRegion))
+    }
+
+    public var region: MKCoordinateRegion? {
+        if case .region(let region) = kind { return region }
+        return nil
+    }
+
+    public var camera: MapCamera? {
+        if case .camera(let camera) = kind { return camera }
+        return nil
+    }
+
+    public var positionedByUser: Bool { false }
+    public var followsUserLocation: Bool {
+        if case .userLocation = kind { return true }
+        return false
+    }
+
+    /// The region shown for this position.
+    var shownRegion: MKCoordinateRegion? {
+        switch kind {
+        case .automatic: nil
+        case .region(let region): region
+        case .camera(let camera): camera.region
+        case .userLocation(let fallback): fallback
+        }
+    }
+}
+
+/// The limits of a map's camera; accepted for source compatibility.
+public struct MapCameraBounds: Sendable {
+    public init(centerCoordinateBounds: MKCoordinateRegion? = nil, minimumDistance: Double? = nil, maximumDistance: Double? = nil) {}
+    public init(minimumDistance: Double? = nil, maximumDistance: Double? = nil) {}
+}
+
+/// How the user may move a map; accepted (the browser's map does not move).
+public struct MapInteractionModes: OptionSet, Sendable {
+    public let rawValue: Int
+    public init(rawValue: Int) { self.rawValue = rawValue }
+    public static let pan = MapInteractionModes(rawValue: 1)
+    public static let zoom = MapInteractionModes(rawValue: 2)
+    public static let rotate = MapInteractionModes(rawValue: 4)
+    public static let pitch = MapInteractionModes(rawValue: 8)
+    public static let all: MapInteractionModes = [.pan, .zoom, .rotate, .pitch]
+}
+
+/// Whether a map follows the user (iOS 14 `Map`); accepted.
+public enum MapUserTrackingMode: Sendable {
+    case none, follow
+}
+
+// MARK: - Projection
+
+/// Places coordinates in a map view of `size` showing `region`: Web
+/// Mercator, scaled so that the whole region fits and centered on it.
+public struct _MapProjection: Sendable {
+    let size: CGSize
+    let center: CLLocationCoordinate2D
+    /// Points per radian of longitude (and of Mercator y).
+    let scale: Double
+
+    init(region: MKCoordinateRegion, size: CGSize) {
+        self.size = size
+        center = region.center
+        let half = (lat: region.span.latitudeDelta / 2, lon: region.span.longitudeDelta / 2)
+        let width = max(1e-9, Self.radians(2 * half.lon))
+        let height = max(1e-9, Self.mercator(region.center.latitude + half.lat) - Self.mercator(region.center.latitude - half.lat))
+        scale = min(size.width / width, size.height / height)
+    }
+
+    /// Where `coordinate` is in the view.
+    public func point(for coordinate: CLLocationCoordinate2D) -> CGPoint {
+        CGPoint(x: size.width / 2 + Self.radians(coordinate.longitude - center.longitude) * scale,
+                y: size.height / 2 - (Self.mercator(coordinate.latitude) - Self.mercator(center.latitude)) * scale)
+    }
+
+    /// The coordinate at `point` in the view.
+    public func coordinate(at point: CGPoint) -> CLLocationCoordinate2D {
+        let longitude = center.longitude + (point.x - size.width / 2) / scale * 180 / .pi
+        let y = Self.mercator(center.latitude) - (point.y - size.height / 2) / scale
+        let latitude = (2 * atan(exp(y)) - .pi / 2) * 180 / .pi
+        return CLLocationCoordinate2D(latitude: latitude, longitude: longitude)
+    }
+
+    /// The visible extent: (south, west) to (north, east).
+    var visible: (south: Double, west: Double, north: Double, east: Double) {
+        let topLeft = coordinate(at: .zero)
+        let bottomRight = coordinate(at: CGPoint(x: size.width, y: size.height))
+        return (bottomRight.latitude, topLeft.longitude, topLeft.latitude, bottomRight.longitude)
+    }
+
+    static func radians(_ degrees: Double) -> Double { degrees * .pi / 180 }
+
+    /// Mercator y of a latitude (clamped short of the poles).
+    static func mercator(_ latitude: Double) -> Double {
+        let phi = radians(max(-85, min(85, latitude)))
+        return log(tan(.pi / 4 + phi / 2))
+    }
+}
+
+struct _MapProjectionKey: EnvironmentKey {
+    static let defaultValue: _MapProjection? = nil
+}
+
+extension EnvironmentValues {
+    /// The projection of the map a piece of map content is drawn in.
+    public var _mapProjection: _MapProjection? {
+        get { self[_MapProjectionKey.self] }
+        set { self[_MapProjectionKey.self] = newValue }
+    }
+}