@swiftbrowser/native 0.17.7 → 0.18.0

package/swift/Sources/SwiftBrowserProtocol/SVGPath.swift

@@ -0,0 +1,260 @@
+import Foundation
+
+/// SVG path data, as the protocol carries a custom shape's path (`M`, `L`,
+/// `H`, `V`, `C`, `S`, `Q`, `T`, `A`, `Z` and their relative forms): parsed
+/// into moves, lines, curves and closes in absolute coordinates, arcs as
+/// cubic curves, for a renderer to build its own path from. SwiftUI's
+/// `Path(_:)` reads only `Path.description`'s form, not SVG.
+public enum SVGPath {
+    public struct Point: Equatable, Sendable {
+        public var x: Double
+        public var y: Double
+        public init(x: Double, y: Double) {
+            self.x = x
+            self.y = y
+        }
+    }
+
+    public enum Element: Equatable, Sendable {
+        case move(Point)
+        case line(Point)
+        case quadCurve(to: Point, control: Point)
+        case curve(to: Point, control1: Point, control2: Point)
+        case closeSubpath
+    }
+
+    /// The elements of `data`; nil when it is not path data (an unknown
+    /// command, a number missing). Empty data is no elements.
+    public static func parse(_ data: String) -> [Element]? {
+        var scanner = PathScanner(Array(data.utf8))
+        var elements: [Element] = []
+        var current = Point(x: 0, y: 0)
+        var start = current
+        // The last curve's second control point, for `S` and `T`.
+        var lastCubic: Point?
+        var lastQuad: Point?
+        var command: UInt8?
+
+        while true {
+            scanner.skipSeparators()
+            guard let byte = scanner.peek else { break }
+            if PathScanner.isCommand(byte) {
+                command = byte
+                scanner.index += 1
+            } else if command == nil {
+                return nil
+            }
+            guard let op = command else { return nil }
+            let relative = op >= UInt8(ascii: "a")
+            let base = relative ? current : Point(x: 0, y: 0)
+            func point() -> Point? {
+                guard let x = scanner.number(), let y = scanner.number() else { return nil }
+                return Point(x: base.x + x, y: base.y + y)
+            }
+            var cubic: Point?
+            var quad: Point?
+            switch op | 0x20 {
+            case UInt8(ascii: "m"):
+                guard let to = point() else { return nil }
+                elements.append(.move(to))
+                current = to
+                start = to
+                // Pairs after a move are lines.
+                command = relative ? UInt8(ascii: "l") : UInt8(ascii: "L")
+            case UInt8(ascii: "l"):
+                guard let to = point() else { return nil }
+                elements.append(.line(to))
+                current = to
+            case UInt8(ascii: "h"):
+                guard let x = scanner.number() else { return nil }
+                current = Point(x: relative ? current.x + x : x, y: current.y)
+                elements.append(.line(current))
+            case UInt8(ascii: "v"):
+                guard let y = scanner.number() else { return nil }
+                current = Point(x: current.x, y: relative ? current.y + y : y)
+                elements.append(.line(current))
+            case UInt8(ascii: "c"):
+                guard let c1 = point(), let c2 = point(), let to = point() else { return nil }
+                elements.append(.curve(to: to, control1: c1, control2: c2))
+                current = to
+                cubic = c2
+            case UInt8(ascii: "s"):
+                guard let c2 = point(), let to = point() else { return nil }
+                let c1 = lastCubic.map { Point(x: 2 * current.x - $0.x, y: 2 * current.y - $0.y) } ?? current
+                elements.append(.curve(to: to, control1: c1, control2: c2))
+                current = to
+                cubic = c2
+            case UInt8(ascii: "q"):
+                guard let c = point(), let to = point() else { return nil }
+                elements.append(.quadCurve(to: to, control: c))
+                current = to
+                quad = c
+            case UInt8(ascii: "t"):
+                guard let to = point() else { return nil }
+                let c = lastQuad.map { Point(x: 2 * current.x - $0.x, y: 2 * current.y - $0.y) } ?? current
+                elements.append(.quadCurve(to: to, control: c))
+                current = to
+                quad = c
+            case UInt8(ascii: "a"):
+                guard let rx = scanner.number(), let ry = scanner.number(), let rotation = scanner.number(),
+                      let large = scanner.flag(), let sweep = scanner.flag(), let to = point() else { return nil }
+                elements += arc(from: current, to: to, rx: rx, ry: ry, rotation: rotation, large: large, sweep: sweep)
+                current = to
+            case UInt8(ascii: "z"):
+                elements.append(.closeSubpath)
+                current = start
+                // A close takes no numbers: the next byte must be a command.
+                command = nil
+            default:
+                return nil
+            }
+            lastCubic = cubic
+            lastQuad = quad
+        }
+        return elements
+    }
+
+    /// An SVG arc (endpoint form) as cubic curves of a quarter turn or less
+    /// (SVG 1.1, F.6.5 and F.6.6). Equal endpoints draw nothing; a zero
+    /// radius is a line.
+    static func arc(from p0: Point, to p1: Point, rx rxIn: Double, ry ryIn: Double, rotation: Double, large: Bool, sweep: Bool) -> [Element] {
+        if p0 == p1 { return [] }
+        var rx = abs(rxIn)
+        var ry = abs(ryIn)
+        if rx == 0 || ry == 0 { return [.line(p1)] }
+        let phi = rotation * .pi / 180
+        let cosPhi = cos(phi)
+        let sinPhi = sin(phi)
+        let dx = (p0.x - p1.x) / 2
+        let dy = (p0.y - p1.y) / 2
+        let x1 = cosPhi * dx + sinPhi * dy
+        let y1 = -sinPhi * dx + cosPhi * dy
+        // Radii too small for the endpoints are scaled up until they fit.
+        let lambda = (x1 * x1) / (rx * rx) + (y1 * y1) / (ry * ry)
+        if lambda > 1 {
+            rx *= lambda.squareRoot()
+            ry *= lambda.squareRoot()
+        }
+        let numerator = rx * rx * ry * ry - rx * rx * y1 * y1 - ry * ry * x1 * x1
+        let denominator = rx * rx * y1 * y1 + ry * ry * x1 * x1
+        var factor = denominator == 0 ? 0 : (max(0, numerator) / denominator).squareRoot()
+        if large == sweep { factor = -factor }
+        let cx1 = factor * rx * y1 / ry
+        let cy1 = -factor * ry * x1 / rx
+        let cx = cosPhi * cx1 - sinPhi * cy1 + (p0.x + p1.x) / 2
+        let cy = sinPhi * cx1 + cosPhi * cy1 + (p0.y + p1.y) / 2
+        func angle(_ ux: Double, _ uy: Double, _ vx: Double, _ vy: Double) -> Double {
+            let sign: Double = ux * vy - uy * vx < 0 ? -1 : 1
+            let dot = ux * vx + uy * vy
+            let length = (ux * ux + uy * uy).squareRoot() * (vx * vx + vy * vy).squareRoot()
+            return sign * acos(min(1, max(-1, dot / length)))
+        }
+        let theta1 = angle(1, 0, (x1 - cx1) / rx, (y1 - cy1) / ry)
+        var delta = angle((x1 - cx1) / rx, (y1 - cy1) / ry, (-x1 - cx1) / rx, (-y1 - cy1) / ry)
+        if !sweep && delta > 0 { delta -= 2 * .pi }
+        if sweep && delta < 0 { delta += 2 * .pi }
+
+        let segments = max(1, Int((abs(delta) / (.pi / 2)).rounded(.up)))
+        let step = delta / Double(segments)
+        let k = 4.0 / 3.0 * tan(step / 4)
+        func onEllipse(_ t: Double) -> Point {
+            let x = rx * cos(t)
+            let y = ry * sin(t)
+            return Point(x: cx + cosPhi * x - sinPhi * y, y: cy + sinPhi * x + cosPhi * y)
+        }
+        func tangent(_ t: Double) -> Point {
+            let x = -rx * sin(t)
+            let y = ry * cos(t)
+            return Point(x: cosPhi * x - sinPhi * y, y: sinPhi * x + cosPhi * y)
+        }
+        var elements: [Element] = []
+        var t = theta1
+        var from = p0
+        for index in 0..<segments {
+            let next = t + step
+            // The last end is the endpoint itself, not its recomputation.
+            let to = index == segments - 1 ? p1 : onEllipse(next)
+            let d0 = tangent(t)
+            let d1 = tangent(next)
+            elements.append(.curve(
+                to: to,
+                control1: Point(x: from.x + k * d0.x, y: from.y + k * d0.y),
+                control2: Point(x: to.x - k * d1.x, y: to.y - k * d1.y)
+            ))
+            from = to
+            t = next
+        }
+        return elements
+    }
+}
+
+/// Numbers and flags out of path data's bytes.
+private struct PathScanner {
+    let bytes: [UInt8]
+    var index = 0
+
+    init(_ bytes: [UInt8]) {
+        self.bytes = bytes
+    }
+
+    var peek: UInt8? { index < bytes.count ? bytes[index] : nil }
+
+    static func isCommand(_ byte: UInt8) -> Bool {
+        switch byte | 0x20 {
+        case UInt8(ascii: "m"), UInt8(ascii: "l"), UInt8(ascii: "h"), UInt8(ascii: "v"), UInt8(ascii: "c"), UInt8(ascii: "s"),
+             UInt8(ascii: "q"), UInt8(ascii: "t"), UInt8(ascii: "a"), UInt8(ascii: "z"):
+            return true
+        default:
+            return false
+        }
+    }
+
+    mutating func skipSeparators() {
+        while let byte = peek, byte == UInt8(ascii: " ") || byte == UInt8(ascii: ",") || byte == 0x0A || byte == 0x0D || byte == 0x09 {
+            index += 1
+        }
+    }
+
+    /// A number: sign, digits, a point, an exponent (`-1.5e-3`, `.5`; `1.5.5` is two).
+    mutating func number() -> Double? {
+        skipSeparators()
+        let begin = index
+        if let byte = peek, byte == UInt8(ascii: "-") || byte == UInt8(ascii: "+") { index += 1 }
+        var digits = false
+        var point = false
+        while let byte = peek {
+            if byte >= UInt8(ascii: "0") && byte <= UInt8(ascii: "9") {
+                digits = true
+            } else if byte == UInt8(ascii: "."), !point {
+                point = true
+            } else {
+                break
+            }
+            index += 1
+        }
+        guard digits else {
+            index = begin
+            return nil
+        }
+        if let byte = peek, byte == UInt8(ascii: "e") || byte == UInt8(ascii: "E") {
+            let mark = index
+            index += 1
+            if let sign = peek, sign == UInt8(ascii: "-") || sign == UInt8(ascii: "+") { index += 1 }
+            var exponent = false
+            while let byte = peek, byte >= UInt8(ascii: "0") && byte <= UInt8(ascii: "9") {
+                exponent = true
+                index += 1
+            }
+            if !exponent { index = mark }
+        }
+        return Double(String(decoding: bytes[begin..<index], as: UTF8.self))
+    }
+
+    /// An arc flag: one `0` or `1`, which may run into the next number (`a5 5 0 011 1`).
+    mutating func flag() -> Bool? {
+        skipSeparators()
+        guard let byte = peek, byte == UInt8(ascii: "0") || byte == UInt8(ascii: "1") else { return nil }
+        index += 1
+        return byte == UInt8(ascii: "1")
+    }
+}

package/swift/Sources/SwiftBrowserProtocol/Style.swift

@@ -48,6 +48,8 @@ public struct Style: Equatable, Sendable {
     public var hidden: Bool
     public var mask: ShapeStyleSpec?
     public var hitTesting: Bool?
+    /// `.contentShape(Rectangle())`: `rectangle`.
+    public var contentShape: String?
     public var blendMode: String?
     public var zIndex: Double?
     public var blur: Double?
@@ -73,6 +75,8 @@ public struct Style: Equatable, Sendable {
     public var scrollID: Bool
     /// `proxy.scrollTo(x)`: the request (its serial is new each time) on the element it names.
     public var scrollTo: ScrollToSpec?
+    /// `.scrollTransition`: the effects in its three phases.
+    public var scrollTransition: ScrollTransitionSpec?
 
     public init(json: JSONValue) {
         let fields = json.object ?? [:]
@@ -121,6 +125,7 @@ public struct Style: Equatable, Sendable {
         hidden = fields.bool("hidden") ?? false
         mask = ShapeStyleSpec(json: fields.value("mask"))
         hitTesting = fields.bool("hitTesting")
+        contentShape = fields.string("contentShape")
         blendMode = fields.string("blendMode")
         zIndex = fields.double("zIndex")
         blur = fields.double("blur")
@@ -146,6 +151,7 @@ public struct Style: Equatable, Sendable {
         containerRelativeFrame = ContainerRelativeFrameSpec(json: fields.value("containerRelativeFrame"))
         scrollID = fields.bool("scrollID") ?? false
         scrollTo = ScrollToSpec(json: fields.value("scrollTo"))
+        scrollTransition = ScrollTransitionSpec(json: fields.value("scrollTransition"))
     }
 
     public init() {
@@ -187,3 +193,55 @@ public struct ScrollToSpec: Equatable, Sendable {
         axes = fields.string("axes") ?? "both"
     }
 }
+
+/// `.scrollTransition(_:axis:transition:)` as the app sends it: its closure's
+/// effects in each phase, drawn by SwiftUI's own as the view scrolls.
+public struct ScrollTransitionSpec: Equatable, Sendable {
+    /// `interactive`, `animated` or `identity`.
+    public var configuration: String
+    /// `horizontal` or `vertical`; the scroll view's own axis when nil.
+    public var axis: String?
+    public var identity: EffectSpec
+    public var topLeading: EffectSpec
+    public var bottomTrailing: EffectSpec
+    public init?(json: JSONValue) {
+        guard let fields = json.object else { return nil }
+        configuration = fields.string("configuration") ?? "interactive"
+        axis = fields.string("axis")
+        identity = EffectSpec(json: fields.value("identity"))
+        topLeading = EffectSpec(json: fields.value("topLeading"))
+        bottomTrailing = EffectSpec(json: fields.value("bottomTrailing"))
+    }
+}
+
+/// The visual effects of one scroll-transition phase (the `Style` fields of
+/// the same names); absent fields are the identity's.
+public struct EffectSpec: Equatable, Sendable {
+    public var offset: PointSpec?
+    public var scale: PointSpec?
+    public var scaleAnchor: UnitPointSpec?
+    public var rotation: Double?
+    public var rotationAnchor: UnitPointSpec?
+    public var opacity: Double?
+    public var blur: Double?
+    public var brightness: Double?
+    public var contrast: Double?
+    public var saturation: Double?
+    public var grayscale: Double?
+    public var hueRotation: Double?
+    public init(json: JSONValue) {
+        let fields = json.object ?? [:]
+        offset = PointSpec(json: fields.value("offset"))
+        scale = PointSpec(json: fields.value("scale"))
+        scaleAnchor = UnitPointSpec(json: fields.value("scaleAnchor"))
+        rotation = fields.double("rotation")
+        rotationAnchor = UnitPointSpec(json: fields.value("rotationAnchor"))
+        opacity = fields.double("opacity")
+        blur = fields.double("blur")
+        brightness = fields.double("brightness")
+        contrast = fields.double("contrast")
+        saturation = fields.double("saturation")
+        grayscale = fields.double("grayscale")
+        hueRotation = fields.double("hueRotation")
+    }
+}

package/swift/Sources/SwiftBrowserTree/OpTree.swift

@@ -35,6 +35,13 @@ public final class OpTree {
 
     /// Runs the body of a pass, animated as the commit asks (`withAnimation` on a SwiftUI host).
     public var animate: (AnimationSpec?, () -> Void) -> Void = { _, body in body() }
+    /// Runs the body of a pass whose commit wants a completion: the host calls
+    /// the last closure once the pass has finished animating (SwiftUI's
+    /// `withAnimation(_:completionCriteria:_:completion:)`), from any task;
+    /// the tree then sends `animationcomplete` on the main actor, a turn
+    /// later. Without a host hook the tree runs `animate` and sends it right
+    /// after the pass.
+    public var animateWithCompletion: ((AnimationSpec?, CommitCompletionSpec, () -> Void, @escaping @Sendable () -> Void) -> Void)?
     /// Called after every committed pass.
     public var onCommit: ((AnimationSpec?) -> Void)?
     /// Where the renderer's events go (the app's `dispatch`).
@@ -65,17 +72,30 @@ public final class OpTree {
     /// id, an insert into a missing parent); the ops before it have applied.
     public func apply(_ ops: [Op]) throws {
         for op in ops {
-            if case .commit(let animation) = op {
+            if case .commit(let animation, let completion) = op {
                 let pass = pending
                 pending.removeAll()
                 var failure: Error?
-                animate(animation) {
+                let body = {
                     do {
                         for each in pass { try self.applyOne(each) }
                     } catch {
                         failure = error
                     }
                 }
+                if let completion {
+                    if let animateWithCompletion {
+                        let serial = completion.serial
+                        animateWithCompletion(animation, completion, body) { [weak self] in
+                            Task { @MainActor in self?.send(.animationComplete(serial: serial)) }
+                        }
+                    } else {
+                        animate(animation, body)
+                        send(.animationComplete(serial: completion.serial))
+                    }
+                } else {
+                    animate(animation, body)
+                }
                 if let failure { throw failure }
                 commits += 1
                 onCommit?(animation)

package/wasm/SwiftBrowserNative.wasm

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/wasm/SwiftBrowserNative.wasm
-size: 49658341 bytes
-sha256: 9aa09e4a1125c88786c07b9293dd9eec6264583717cd1f8227808596da2d911a
+size: 49982707 bytes
+sha256: 1f02220b4e3d7e74ce3afb42d5336ba9254bb1cd1cb591409c878548c4a6f6c4