@swiftbrowser/native 0.17.1 → 0.17.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swiftbrowser/native",
-  "version": "0.17.1",
+  "version": "0.17.2",
   "type": "module",
   "description": "Run a @swiftbrowser/react app natively: the runtime a JavaScriptCore-hosted app needs (timers, console, fetch and the other web globals over the SwiftBrowser Native bridge), the `run` entry that renders into the native SwiftUI renderer, and the bundler that builds app.js for the Xcode target.",
   "repository": {
@@ -59,8 +59,8 @@
   },
   "dependencies": {
     "@babel/core": "^7.29.7",
-    "@swiftbrowser/react": "0.17.1",
-    "@swiftbrowser/web": "0.17.1",
+    "@swiftbrowser/react": "0.17.2",
+    "@swiftbrowser/web": "0.17.2",
     "esbuild": "^0.28.2",
     "react-refresh": "^0.17.0"
   },

package/swift/Sources/SwiftBrowserNative/Views/Kinds/Stacks.swift

@@ -147,12 +147,21 @@ struct ScrollViewElement: View {
     @State private var visible: [Int] = []
     @State private var idle = true
     @State private var reported: Int?
+    @State private var appeared = false
 
     var body: some View {
         let props = ScrollViewProps(props: node.props)
         let axes: Axis.Set = props.axes == "horizontal" ? .horizontal : props.axes == "both" ? [.horizontal, .vertical] : .vertical
         let request = Self.scrollRequest(in: node)
         let anchor = props.positionAnchor.map(UnitPoint.init(spec:))
+        // A request not yet served is the position already in this pass, the
+        // one that draws the content it came with (the app may have changed
+        // the content around its target): served in `onChange`, a pass later,
+        // the pass between would draw the new content at the old offset. Not
+        // before the view appears: the first pass has no size to scroll in,
+        // and the position the request then sets in `onAppear` would be no
+        // change, so nothing would scroll.
+        let ahead = request.flatMap { appeared && $0.serial > served && Self.positionServes($0, props: props) ? $0.id : nil }
         ScrollViewReader { proxy in
             let scroll = ScrollView(axes, showsIndicators: props.showsIndicators) {
                 ChildrenView(node: node)
@@ -161,7 +170,7 @@ struct ScrollViewElement: View {
             let snapped: AnyView = props.snap == "paging" ? AnyView(refreshed.scrollTargetBehavior(.paging))
                 : props.snap == "viewAligned" ? AnyView(refreshed.scrollTargetBehavior(.viewAligned)) : refreshed
             let positioned: AnyView = props.reportsPosition
-                ? reportingSettled(AnyView(snapped.scrollPosition(id: Binding(get: { position }, set: { next in
+                ? reportingSettled(AnyView(snapped.scrollPosition(id: Binding(get: { ahead ?? position }, set: { next in
                     guard next != position else { return }
                     position = next
                     // Where the settled position is reported, the binding only follows the view.
@@ -169,7 +178,10 @@ struct ScrollViewElement: View {
                 }), anchor: anchor)), anchor: anchor)
                 : snapped
             positioned
-                .onAppear { perform(request, props: props, with: proxy) }
+                .onAppear {
+                    perform(request, props: props, with: proxy)
+                    appeared = true
+                }
                 .onChange(of: request?.serial) { _, _ in perform(request, props: props, with: proxy) }
         }
     }
@@ -194,15 +206,19 @@ struct ScrollViewElement: View {
             let id = request.id
             Task { @MainActor in
                 try? await Task.sleep(for: .milliseconds(450))
-                if idle { report(id) }
+                if idle { reportSettled(id) }
             }
         }
-        // On its own axes, at its own anchor, the position binding scrolls this view alone; else the proxy, which scrolls every scroll view around the target.
-        let ownAxes = request.axes == props.axes && props.axes != "both"
-        if props.reportsPosition, ownAxes, request.anchor == nil || request.anchor == props.positionAnchor.map(UnitPoint.init(spec:)) { return }
+        if Self.positionServes(request, props: props) { return }
         proxy.scrollTo(request.id, anchor: request.anchor)
     }
 
+    /// On its own axes, at its own anchor, the position binding scrolls this view alone; else the proxy, which scrolls every scroll view around the target.
+    static func positionServes(_ request: ScrollRequest, props: ScrollViewProps) -> Bool {
+        let ownAxes = request.axes == props.axes && props.axes != "both"
+        return props.reportsPosition && ownAxes && (request.anchor == nil || request.anchor == props.positionAnchor.map(UnitPoint.init(spec:)))
+    }
+
     /// Tells the app the target at the anchor, once per target, after the
     /// pass that found it: the app answers synchronously, with a pass of its
     /// own, which must not land in the middle of SwiftUI's update (as
@@ -214,6 +230,19 @@ struct ScrollViewElement: View {
         Task { @MainActor in app?.dispatch(.scrollPosition(id)) }
     }
 
+    /// Reports where a scroll settled, and lets go of the position: the app
+    /// may answer by changing the content around the target (Amindia's
+    /// calendar loads the weeks either side of the day it hears of) and
+    /// asking for the target again. Held, the position would have to let go
+    /// then and take the target back a pass later, and the pass between would
+    /// draw the new content at the old offset (a frame of the wrong week).
+    /// Let go now, nothing moves, and the request lands with the content.
+    private func reportSettled(_ id: Int?) {
+        guard let id else { return }
+        report(id)
+        if position == id { position = nil }
+    }
+
     /// Whether this OS reports the settled position (`reportingSettled`) rather than the binding's every change.
     static var reportsSettled: Bool {
         #if !canImport(FoundationBridge)
@@ -238,7 +267,7 @@ struct ScrollViewElement: View {
                 }
                 .onScrollPhaseChange { old, phase in
                     idle = phase == .idle
-                    if idle, old != .idle { report(Self.target(at: anchor, among: visible)) }
+                    if idle, old != .idle { reportSettled(Self.target(at: anchor, among: visible)) }
                 })
         }
         #endif

package/wasm/SwiftBrowserNative.wasm

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/wasm/SwiftBrowserNative.wasm
-size: 49329004 bytes
-sha256: 5ce7ef4d787494787133dc374d57de7d72e0173da56ce76e22d0030644a6b5f2
+size: 49330000 bytes
+sha256: e1e3caa6b59f0db479d22e2969623ed0609ecda85225d254b534cf952a6ca929