@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/Runtime/Sameness.swift

@@ -0,0 +1,152 @@
+// Whether a view value a parent re-created is the same input as the one a
+// mounted node holds, so that the node (and its subtree) can be skipped
+// instead of re-running its body. SwiftUI makes the same decision by
+// comparing a view's stored properties; here the comparison is done by
+// reflection and is conservative: anything it cannot prove equal (a closure,
+// a binding, a type it does not understand, a value too large to walk) is
+// "different", which only costs the re-run the runtime did before.
+
+/// A value the runtime re-creates on every pass that nevertheless stands for
+/// the same thing each time (a screen's dismiss action, the edit-mode binding
+/// a node owns). It compares by its identity; without one it is never equal.
+protocol _RuntimeIdentified {
+    var _runtimeIdentity: AnyHashable? { get }
+}
+
+enum _Sameness {
+    /// How many values one comparison may visit before it gives up.
+    static let budget = 256
+
+    /// Whether two values of a view (or of an environment) are the same input.
+    /// - Value types that are `Equatable` compare with `==`.
+    /// - Class instances compare by identity, never by `==`: a different
+    ///   object is a different observation even when it claims equality.
+    /// - `@State`, `@StateObject`, `@FocusState`, `@Environment`,
+    ///   `@EnvironmentObject` and `@ScaledMetric` are equal: their values belong
+    ///   to the mounted node or come from the environment, which is compared
+    ///   separately.
+    /// - Structs, tuples, enums, optionals and collections compare member by
+    ///   member, labels included.
+    /// - Anything else (closures, metatypes) is different.
+    static func same(_ a: Any, _ b: Any, budget: inout Int) -> Bool {
+        budget -= 1
+        if budget < 0 { return false }
+        let typeA = type(of: a)
+        guard typeA == type(of: b) else { return false }
+        switch kind(of: a, type: typeA) {
+        case .ignored:
+            return true
+        case .identified(let read):
+            guard let identity = read(a), let other = read(b) else { return false }
+            return identity == other
+        case .object:
+            return ObjectIdentifier(a as AnyObject) == ObjectIdentifier(b as AnyObject)
+        case .equatable(let equal):
+            return equal(a, b)
+        case .structural(let isEnum):
+            let mirrorA = Mirror(reflecting: a)
+            let mirrorB = Mirror(reflecting: b)
+            if isEnum, mirrorA.children.isEmpty, mirrorB.children.isEmpty {
+                // Two payload-less cases of an enum that is not Equatable.
+                return String(describing: a) == String(describing: b)
+            }
+            var childrenB = mirrorB.children.makeIterator()
+            for childA in mirrorA.children {
+                guard let childB = childrenB.next(), childA.label == childB.label,
+                      same(childA.value, childB.value, budget: &budget) else { return false }
+            }
+            return childrenB.next() == nil
+        case .never:
+            return false
+        }
+    }
+
+    /// How values of one type compare, worked out once per type: the dynamic
+    /// casts that decide it are the expensive part of a comparison.
+    private enum Kind {
+        case ignored
+        case identified((Any) -> AnyHashable?)
+        case object
+        case equatable((Any, Any) -> Bool)
+        case structural(isEnum: Bool)
+        case never
+    }
+
+    nonisolated(unsafe) private static var kinds: [ObjectIdentifier: Kind] = [:]
+
+    private static func kind(of value: Any, type: Any.Type) -> Kind {
+        let key = ObjectIdentifier(type)
+        if let known = kinds[key] { return known }
+        let kind: Kind
+        // A cast to a protocol looks inside an optional: `Optional<any
+        // ShapeStyle>` holding a `Color` casts to `any Equatable` as the
+        // `Color`. Its kind is cached for the optional's type, which holds
+        // other types too, so it only counts when the cast kept the type; an
+        // optional is otherwise compared by its payload (structural).
+        if value is any _StateProperty || value is any _EnvironmentProperty {
+            kind = .ignored
+        } else if let identified = value as? any _RuntimeIdentified, openedType(identified) == type {
+            kind = .identified(identity(of: identified))
+        } else if type is AnyObject.Type {
+            kind = .object
+        } else if let equatable = value as? any Equatable, openedType(equatable) == type {
+            kind = .equatable(equality(of: equatable))
+        } else {
+            switch Mirror(reflecting: value).displayStyle {
+            case .struct?, .tuple?, .optional?, .collection?, .set?, .dictionary?:
+                kind = .structural(isEnum: false)
+            case .enum?:
+                kind = .structural(isEnum: true)
+            default:
+                kind = .never
+            }
+        }
+        kinds[key] = kind
+        return kind
+    }
+
+    /// Reads the identity of values of `T` with a cast to `T`, not to the
+    /// protocol (a conformance lookup per comparison).
+    private static func identity<T: _RuntimeIdentified>(of _: T) -> (Any) -> AnyHashable? {
+        { ($0 as! T)._runtimeIdentity }
+    }
+
+    private static func openedType<T>(_: T) -> Any.Type { T.self }
+
+    private static func equality<T: Equatable>(of _: T) -> (Any, Any) -> Bool {
+        { a, b in (a as! T) == (b as! T) }
+    }
+
+    /// Whether values shaped like `value` can ever compare equal: comparing it
+    /// with itself fails only when it holds a closure, a binding without an
+    /// identity, or something else this comparison does not understand.
+    static func canEverBeSame(_ value: Any) -> Bool {
+        var budget = 4096
+        return same(value, value, budget: &budget)
+    }
+
+    /// Whether `new` is the same view as `old` (of the same type).
+    static func sameView(_ old: any View, _ new: any View) -> Bool {
+        var budget = budget
+        return same(old, new, budget: &budget)
+    }
+}
+
+extension EnvironmentValues {
+    /// Whether every entry is the same (see `_Sameness.same`) as in `other`.
+    func _isSame(as other: EnvironmentValues) -> Bool {
+        _sameStorage(as: other)
+    }
+}
+
+extension DismissAction: _RuntimeIdentified {
+    var _runtimeIdentity: AnyHashable? { identity.map(AnyHashable.init) }
+}
+
+extension Binding: _RuntimeIdentified {
+    var _runtimeIdentity: AnyHashable? { identity.map(AnyHashable.init) }
+}
+
+extension _ListSelection: _RuntimeIdentified {
+    var _runtimeIdentity: AnyHashable? { identity.map(AnyHashable.init) }
+}

package/Sources/SwiftUI/Runtime/ViewPath.swift

@@ -0,0 +1,89 @@
+// A node's position from the root, `Type/index:Type/key:Type/...`: it keys
+// state snapshots (hot reload) and the root-level sheets and alerts, and a
+// node whose parent passes the same path and context may skip its body.
+//
+// Every child gets one on every pass. As text, each was its parent's text
+// copied and appended to (a tenth of the reconciler's time in Ice Cubes);
+// here it is a link to the parent's path plus this step, with a hash for
+// comparing, and the text is made only when something asks for it.
+
+@MainActor
+final class _ViewPath {
+    enum Step: Hashable {
+        case root
+        case index(Int)
+        case key(AnyHashable)
+    }
+
+    let parent: _ViewPath?
+    let step: Step
+    let type: Any.Type
+    private let hash: Int
+    private var cachedText: String?
+
+    init(root type: Any.Type) {
+        parent = nil
+        step = .root
+        self.type = type
+        var hasher = Hasher()
+        hasher.combine(ObjectIdentifier(type))
+        hash = hasher.finalize()
+    }
+
+    private init(parent: _ViewPath, step: Step, type: Any.Type) {
+        self.parent = parent
+        self.step = step
+        self.type = type
+        var hasher = Hasher()
+        hasher.combine(parent.hash)
+        hasher.combine(step)
+        hasher.combine(ObjectIdentifier(type))
+        hash = hasher.finalize()
+    }
+
+    func child(_ step: Step, _ type: Any.Type) -> _ViewPath {
+        _ViewPath(parent: self, step: step, type: type)
+    }
+
+    /// `Type/index:Type/key:Type/...`, the type names without generic arguments.
+    var text: String {
+        if let cachedText { return cachedText }
+        let name = Self.name(of: type)
+        let text: String
+        switch step {
+        case .root: text = name
+        case .index(let index): text = "\(parent?.text ?? "")/\(index):\(name)"
+        case .key(let key): text = "\(parent?.text ?? "")/\(key.base):\(name)"
+        }
+        cachedText = text
+        return text
+    }
+
+    /// The same steps through the same types from the root.
+    func matches(_ other: _ViewPath) -> Bool {
+        var a = self, b = other
+        while a !== b {
+            guard a.hash == b.hash, a.step == b.step, a.type == b.type else { return false }
+            switch (a.parent, b.parent) {
+            case (nil, nil): return true
+            case (let pa?, let pb?): a = pa; b = pb
+            default: return false
+            }
+        }
+        return true
+    }
+
+    private static var names: [ObjectIdentifier: String] = [:]
+
+    /// A type's name without its generic arguments.
+    private static func name(of type: Any.Type) -> String {
+        let key = ObjectIdentifier(type)
+        if let cached = names[key] { return cached }
+        // `String(describing:)` would first look up three printing protocols
+        // for the metatype (ViewTraits.swift: lookups are slow in WebAssembly).
+        let full = Swift._typeName(type, qualified: false)
+        let name = if let angle = full.firstIndex(of: "<") { String(full[..<angle]) } else { full }
+        names[key] = name
+        return name
+    }
+}

package/Sources/SwiftUI/Runtime/ViewTraits.swift

@@ -0,0 +1,175 @@
+// Which of the runtime's protocols a view type conforms to, worked out once
+// per type. The reconciler asks each node's view about two dozen of them, and
+// a dynamic cast to a protocol existential is a conformance lookup each time;
+// a node's answers are now a bit test. The casts that remain (to read the
+// view's values) run only for the protocols the type conforms to.
+//
+// The answers come from the type, not the value: a cast of an `Optional`
+// value unwraps it, so `Optional<SomeSheetView>.some(...)` used to answer
+// "sheet" as well as "group" (running its `onAppear` twice, once per node).
+// An optional is a group and nothing else.
+
+/// Refined by every protocol `_ViewTraits` asks about, so that one lookup
+/// answers "none of them" for a type that conforms to none: an app's own
+/// views, most of a tree's types. In WebAssembly the first lookup of each
+/// type and protocol scans every conformance record in the module (tens of
+/// thousands in a large app), which made trait discovery a seventh of Ice
+/// Cubes' Swift time at startup.
+protocol _TraitBearing {}
+
+/// Refined by the property protocols the runtime looks for in a view's
+/// stored properties (`_reflectedProperties`), for the same reason.
+public protocol _RuntimeProperty {}
+
+/// A view that stores a `ViewModifier` or `ButtonStyle` whose own `@State`
+/// and `@Environment` properties the runtime manages like the view's:
+/// `ModifiedContent` and `_ButtonStyleBody`.
+protocol _HoldsModifier: _TraitBearing {}
+
+struct _ViewTraits: OptionSet {
+    let rawValue: UInt64
+
+    static let environmentModifying = _ViewTraits(rawValue: 1 << 0)
+    static let preferredColorScheme = _ViewTraits(rawValue: 1 << 1)
+    static let scrollTargetContainer = _ViewTraits(rawValue: 1 << 2)
+    static let navigationTitle = _ViewTraits(rawValue: 1 << 3)
+    static let onAppearing = _ViewTraits(rawValue: 1 << 4)
+    static let detents = _ViewTraits(rawValue: 1 << 5)
+    static let animated = _ViewTraits(rawValue: 1 << 6)
+    static let destinationRegistering = _ViewTraits(rawValue: 1 << 7)
+    static let splitSidebar = _ViewTraits(rawValue: 1 << 8)
+    static let listSelection = _ViewTraits(rawValue: 1 << 9)
+    static let taskStarting = _ViewTraits(rawValue: 1 << 10)
+    static let navigationSplit = _ViewTraits(rawValue: 1 << 11)
+    static let navigationStack = _ViewTraits(rawValue: 1 << 12)
+    static let navScreen = _ViewTraits(rawValue: 1 << 13)
+    static let navigationLink = _ViewTraits(rawValue: 1 << 14)
+    static let navigationValueLink = _ViewTraits(rawValue: 1 << 15)
+    static let tabView = _ViewTraits(rawValue: 1 << 16)
+    static let tabScreen = _ViewTraits(rawValue: 1 << 17)
+    static let picker = _ViewTraits(rawValue: 1 << 18)
+    static let geometryReading = _ViewTraits(rawValue: 1 << 19)
+    static let sheet = _ViewTraits(rawValue: 1 << 20)
+    static let alert = _ViewTraits(rawValue: 1 << 21)
+    static let group = _ViewTraits(rawValue: 1 << 22)
+    static let host = _ViewTraits(rawValue: 1 << 23)
+    static let refreshing = _ViewTraits(rawValue: 1 << 24)
+    static let environmentHandling = _ViewTraits(rawValue: 1 << 25)
+    static let tagProviding = _ViewTraits(rawValue: 1 << 26)
+    static let rowEditingDisabling = _ViewTraits(rawValue: 1 << 27)
+    static let deletableGroup = _ViewTraits(rawValue: 1 << 28)
+    static let accessibilityProviding = _ViewTraits(rawValue: 1 << 29)
+    static let onDisappearing = _ViewTraits(rawValue: 1 << 30)
+    static let preferenceWriting = _ViewTraits(rawValue: 1 << 31)
+    static let preferenceReading = _ViewTraits(rawValue: 1 << 32)
+    static let preferenceDecorating = _ViewTraits(rawValue: 1 << 33)
+    static let sizeReporting = _ViewTraits(rawValue: 1 << 34)
+    static let lazyRows = _ViewTraits(rawValue: 1 << 35)
+    static let section = _ViewTraits(rawValue: 1 << 36)
+    static let lazyMenu = _ViewTraits(rawValue: 1 << 37)
+    static let holdsModifier = _ViewTraits(rawValue: 1 << 38)
+    static let pathDrawing = _ViewTraits(rawValue: 1 << 39)
+    static let layoutValueProviding = _ViewTraits(rawValue: 1 << 40)
+
+    /// Views without a body of their own: the shim's containers and primitives.
+    static let bodiless: _ViewTraits = [.group, .host, .geometryReading, .sheet, .alert, .picker, .navigationLink]
+
+    /// Views that set something on an ancestor while reconciled.
+    static let contextWriting: _ViewTraits = [
+        .navigationTitle, .destinationRegistering, .detents, .listSelection, .navigationSplit,
+        .navigationStack, .navScreen, .splitSidebar, .tabView, .tabScreen,
+    ]
+
+    nonisolated(unsafe) private static var known: [ObjectIdentifier: _ViewTraits] = [:]
+
+    nonisolated(unsafe) private static var knownDeclarations: [UnsafeRawPointer: _ViewTraits] = [:]
+
+    static func of(_ view: any View) -> _ViewTraits {
+        let type = type(of: view)
+        let key = ObjectIdentifier(type)
+        if let traits = known[key] { return traits }
+        // Every instantiation of a generic view (`ModifiedContent<A, B>`, a
+        // stack of some content) is a type of its own to the runtime, with
+        // lookups of its own; most of a tree's types are such instantiations
+        // of the shim's views. Their conformances to these protocols do not
+        // depend on the arguments (the only conditional ones, `Optional` and
+        // `ForEach`, require `View`, which a view's arguments satisfy), so
+        // the answers are kept per declaration too.
+        let declaration = nominalDescriptor(of: type)
+        if let declaration, let traits = knownDeclarations[declaration] {
+            known[key] = traits
+            return traits
+        }
+        let traits = compute(type)
+        known[key] = traits
+        if let declaration { knownDeclarations[declaration] = traits }
+        return traits
+    }
+
+    /// Whether `type` is a struct (`MetadataKind` 0x200).
+    static func isStruct(_ type: Any.Type) -> Bool {
+        unsafeBitCast(type, to: UnsafeRawPointer.self).load(as: UInt.self) == 0x200
+    }
+
+    /// The declaration a struct or enum type instantiates: the nominal type
+    /// descriptor in the second word of its metadata (ABI-stable layout). Nil
+    /// for other kinds of types (classes, tuples, functions).
+    private static func nominalDescriptor(of type: Any.Type) -> UnsafeRawPointer? {
+        let metadata = unsafeBitCast(type, to: UnsafeRawPointer.self)
+        // MetadataKind: struct 0x200, enum 0x201, optional 0x202.
+        switch metadata.load(as: UInt.self) {
+        case 0x200, 0x201, 0x202:
+            return metadata.load(fromByteOffset: MemoryLayout<UInt>.size, as: UnsafeRawPointer?.self)
+        default:
+            return nil
+        }
+    }
+
+    private static func compute(_ type: Any.Type) -> _ViewTraits {
+        var traits: _ViewTraits = []
+        func add(_ trait: _ViewTraits, _ conforms: Bool) { if conforms { traits.insert(trait) } }
+        add(.splitSidebar, type == _SplitSidebarView.self)
+        add(.navScreen, type == _NavScreenView.self)
+        add(.tabScreen, type == _TabScreenView.self)
+        guard type is any _TraitBearing.Type else { return traits }
+        add(.environmentModifying, type is any _EnvironmentModifying.Type)
+        add(.preferredColorScheme, type is any _PreferredColorSchemeModifying.Type)
+        add(.scrollTargetContainer, type is any _ScrollTargetContainer.Type)
+        add(.navigationTitle, type is any _NavigationTitleModifying.Type)
+        add(.onAppearing, type is any _OnAppearing.Type)
+        add(.onDisappearing, type is any _OnDisappearing.Type)
+        add(.detents, type is any _DetentsModifying.Type)
+        add(.animated, type is any _AnimatedView.Type)
+        add(.destinationRegistering, type is any _DestinationRegistering.Type)
+        add(.listSelection, type is any _ListSelectionProviding.Type)
+        add(.taskStarting, type is any _TaskStarting.Type)
+        add(.navigationSplit, type is any _NavigationSplitHost.Type)
+        add(.navigationStack, type is any _NavigationStackView.Type)
+        add(.navigationLink, type is any _NavigationLinkView.Type)
+        add(.navigationValueLink, type is any _NavigationValueLinkView.Type)
+        add(.tabView, type is any _TabViewHost.Type)
+        add(.picker, type is any _PickerHost.Type)
+        add(.geometryReading, type is any _GeometryReading.Type)
+        add(.sheet, type is any _SheetPresenting.Type)
+        add(.alert, type is any _AlertPresenting.Type)
+        add(.group, type is any _GroupView.Type)
+        add(.host, type is any _HostView.Type)
+        add(.refreshing, type is any _Refreshing.Type)
+        add(.environmentHandling, type is any _EnvironmentHandling.Type)
+        add(.tagProviding, type is any _TagProviding.Type)
+        add(.rowEditingDisabling, type is any _RowEditingDisabling.Type)
+        add(.accessibilityProviding, type is any _AccessibilityProviding.Type)
+        add(.deletableGroup, type is any _DeletableGroup.Type)
+        add(.preferenceWriting, type is any _PreferenceWriting.Type)
+        add(.preferenceReading, type is any _PreferenceReading.Type)
+        add(.preferenceDecorating, type is any _PreferenceValueDecorating.Type)
+        add(.sizeReporting, type is any _SizeReporting.Type)
+        add(.lazyRows, type is any _LazyRowsContainer.Type)
+        add(.section, type is any _SectionView.Type)
+        add(.lazyMenu, type is any _LazyMenuHost.Type)
+        add(.holdsModifier, type is any _HoldsModifier.Type)
+        add(.pathDrawing, type is any _PathDrawing.Type)
+        add(.layoutValueProviding, type is any _LayoutValueProviding.Type)
+        return traits
+    }
+}

package/Sources/SwiftUI/Runtime/WebAuthHeadless.swift

@@ -0,0 +1,49 @@
+// Headless answers to `webAuth` requests (AuthenticationServices' sign-in
+// window; docs/ops-protocol.md, "Signing in"). No page opens a window, so an
+// `SB_RESPONSES` entry plays the provider: one whose `url` (exact) or
+// `prefix` matches the authorize URL and that carries either
+//
+// - `callback`: the URL the window ends at, as is (the callback page's URL,
+//   or the app's own `myapp://?code=…`), or
+// - `code`: the provider's usual answer, a redirect to the authorize URL's
+//   `redirect_uri` with `code` (and the request's `state`, if any) added.
+//
+// Without such an entry the viewer "closed the window": the request fails
+// with `cancelled: …`, which the session reports as a cancelled login.
+
+import Foundation
+
+extension _Runtime {
+    /// The `response` fields (`value` or `error`) for a headless `webAuth` request.
+    nonisolated static func _headlessWebAuth(params: _JSON, fixtures: [_JSON]) -> [String: _JSON] {
+        guard case .object(let request) = params else { return ["error": .string("malformed request")] }
+        if case .string("cancel")? = request["action"] { return ["value": .object([:])] }
+        guard case .string(let url)? = request["url"] else { return ["error": .string("malformed request")] }
+        let fixture = fixtures.first { item in
+            guard case .object(let fields) = item, fields["callback"] != nil || fields["code"] != nil else { return false }
+            if case .string(let exact)? = fields["url"], exact == url { return true }
+            if case .string(let prefix)? = fields["prefix"], url.hasPrefix(prefix) { return true }
+            return false
+        }
+        guard case .object(let fields)? = fixture else {
+            return ["error": .string("cancelled: headless, no SB_RESPONSES entry with a callback for \(url)")]
+        }
+        if case .string(let callback)? = fields["callback"] {
+            return ["value": .object(["url": .string(callback)])]
+        }
+        guard case .string(let code)? = fields["code"] else { return ["error": .string("malformed fixture")] }
+        let items = URLComponents(string: url)?.queryItems ?? []
+        guard let redirect = items.first(where: { $0.name == "redirect_uri" })?.value else {
+            return ["error": .string("headless: \(url) has no redirect_uri to send the code to")]
+        }
+        var added = "code=\(_queryEncoded(code))"
+        if let state = items.first(where: { $0.name == "state" })?.value { added += "&state=\(_queryEncoded(state))" }
+        let separator = redirect.contains("?") ? "&" : "?"
+        return ["value": .object(["url": .string(redirect + separator + added)])]
+    }
+}
+
+/// Percent-encodes everything but RFC 3986's unreserved characters.
+private func _queryEncoded(_ text: String) -> String {
+    text.addingPercentEncoding(withAllowedCharacters: CharacterSet(charactersIn: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~")) ?? text
+}

package/Sources/Symbols/Symbols.swift

@@ -0,0 +1,25 @@
+// `import Symbols` for the browser: SF Symbols' effect types. They are
+// declared in the SwiftUI shim (API/SymbolEffects.swift), which re-exports
+// them on iOS and whose `.symbolEffect` modifiers take them; this module
+// re-exports them for files that import Symbols on its own. The page draws
+// symbols as still glyphs, so effects keep their options and do not animate.
+
+@_exported import protocol SwiftUI.SymbolEffect
+@_exported import protocol SwiftUI.DiscreteSymbolEffect
+@_exported import protocol SwiftUI.IndefiniteSymbolEffect
+@_exported import protocol SwiftUI.TransitionSymbolEffect
+@_exported import protocol SwiftUI.ContentTransitionSymbolEffect
+@_exported import struct SwiftUI.SymbolEffectOptions
+@_exported import struct SwiftUI.BounceSymbolEffect
+@_exported import struct SwiftUI.PulseSymbolEffect
+@_exported import struct SwiftUI.VariableColorSymbolEffect
+@_exported import struct SwiftUI.ScaleSymbolEffect
+@_exported import struct SwiftUI.AppearSymbolEffect
+@_exported import struct SwiftUI.DisappearSymbolEffect
+@_exported import struct SwiftUI.ReplaceSymbolEffect
+@_exported import struct SwiftUI.AutomaticSymbolEffect
+@_exported import struct SwiftUI.BreatheSymbolEffect
+@_exported import struct SwiftUI.RotateSymbolEffect
+@_exported import struct SwiftUI.WiggleSymbolEffect
+@_exported import struct SwiftUI.DrawOnSymbolEffect
+@_exported import struct SwiftUI.DrawOffSymbolEffect