@swiftbrowser/native 0.17.0 → 0.17.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swiftbrowser/native",
-  "version": "0.17.0",
+  "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.0",
-    "@swiftbrowser/web": "0.17.0",
+    "@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/Lists.swift

@@ -13,23 +13,7 @@ struct ListElement: View {
 
     var body: some View {
         let props = ListProps(props: node.props)
-        // Selectable rows are the list's selection, as `List(selection:)`
-        // makes them: the whole cell takes the tap and shows the system's
-        // highlight, and choosing a row sends its `tap`. In edit mode a row
-        // keeps its own tap (several may be chosen).
-        let rows = Self.selectableRows(in: node)
-        let selects = !rows.isEmpty && props.editing != true
-        let list: AnyView = selects
-            ? AnyView(List(selection: Binding<Int?>(
-                get: { rows.first { ListRowProps(props: $0.props).selected }?.id },
-                set: { id in if let id { app?.dispatch(.tap(id)) } }
-            )) {
-                ListRowsView(children: node.children)
-            }
-            .environment(\.listSelectsRows, true))
-            : AnyView(List {
-                ListRowsView(children: node.children)
-            })
+        let list = selectionList(props)
         let styled: AnyView = {
             switch props.style {
             case "plain": return AnyView(list.listStyle(.plain))
@@ -56,6 +40,51 @@ struct ListElement: View {
         #endif
     }
 
+    /// The `List`, with the selection its selectable rows make: as
+    /// `List(selection:)` makes them, the whole cell takes the tap and shows
+    /// the system's highlight, and a row the selection gains or loses sends
+    /// its `tap` (the app toggles or sets it). In edit mode a `Set`
+    /// selection is the system's multiple selection, with the checkmark
+    /// circles. Under the shim (the round trip) the shim's own list makes
+    /// rows of tags, so the rows keep their own taps there.
+    private func selectionList(_ props: ListProps) -> AnyView {
+        #if canImport(FoundationBridge)
+        return AnyView(List { ListRowsView(children: node.children) })
+        #else
+        let rows = Self.selectableRows(in: node)
+        let selected = rows.filter { ListRowProps(props: $0.props).selected }.map(\.id)
+        let editing = props.editing == true
+        if rows.isEmpty {
+            return AnyView(List { ListRowsView(children: node.children) })
+        }
+        if editing, props.multiSelect {
+            return AnyView(List(selection: Binding<Set<Int>>(
+                get: { Set(selected) },
+                set: { next in
+                    for id in Set(selected).symmetricDifference(next) { app?.dispatch(.tap(id)) }
+                }
+            )) {
+                ListRowsView(children: node.children)
+            }
+            .environment(\.listSelectsRows, true))
+        }
+        return AnyView(List(selection: Binding<Int?>(
+            get: { selected.first },
+            set: { id in
+                if let id {
+                    app?.dispatch(.tap(id))
+                } else if editing, let current = selected.first {
+                    // Edit mode deselects a chosen row: the app clears it.
+                    app?.dispatch(.tap(current))
+                }
+            }
+        )) {
+            ListRowsView(children: node.children)
+        }
+        .environment(\.listSelectsRows, true))
+        #endif
+    }
+
     /// The list's selectable rows (not those of a list inside it).
     static func selectableRows(in node: ElementNode) -> [ElementNode] {
         var rows: [ElementNode] = []
@@ -166,8 +195,8 @@ struct SectionElement: View {
 }
 
 /// `listrow`: the row's content with its edit-mode hints; a selectable
-/// row is the list's selection's tag (`ListElement`), or in edit mode sends
-/// `tap` itself.
+/// row is the list's selection's tag (`ListElement`), or under the shim
+/// sends `tap` itself.
 struct ListRowElement: View {
     let node: ElementNode
     @Environment(\.nativeApp) private var app

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) }
         }
     }
@@ -177,18 +189,58 @@ struct ScrollViewElement: View {
     private func perform(_ request: ScrollRequest?, props: ScrollViewProps, with proxy: ScrollViewProxy) {
         guard let request, request.serial > served else { return }
         served = request.serial
-        position = request.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 position == request.id {
+            // Already its position (the app, having put content in front,
+            // asks for the target again): the binding only scrolls on a
+            // change, so it lets go and takes the target back next turn.
+            position = nil
+            let id = request.id
+            Task { @MainActor in position = id }
+        } else {
+            position = request.id
+        }
+        if props.reportsPosition, Self.reportsSettled, request.id != reported {
+            // Where the request lands is the app's to hear once the scroll is
+            // over: an animated one ends in an idle phase (which reports);
+            // one without animation has no phase, so it is reported here.
+            let id = request.id
+            Task { @MainActor in
+                try? await Task.sleep(for: .milliseconds(450))
+                if idle { reportSettled(id) }
+            }
+        }
+        if Self.positionServes(request, props: props) { return }
         proxy.scrollTo(request.id, anchor: request.anchor)
     }
 
-    /// Tells the app the target at the anchor, once per target.
+    /// 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
+    /// GeometryElement's reports wait).
     private func report(_ id: Int?) {
         guard let id, id != reported else { return }
         reported = id
-        app?.dispatch(.scrollPosition(id))
+        let app = app
+        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.
@@ -199,7 +251,12 @@ struct ScrollViewElement: View {
         return false
     }
 
-    /// The visible target at the anchor, reported when the view is idle.
+    /// The visible target at the anchor, reported when a scroll ends (the
+    /// phase goes from a drag, its deceleration or an animation to idle).
+    /// A change of what is visible while idle is not a scroll of the
+    /// viewer's: the first layout, before a requested position applies, or
+    /// content the app put in front, which it scrolls back itself. Reporting
+    /// those would send the app after them, in a loop.
     private func reportingSettled(_ view: AnyView, anchor: UnitPoint?) -> AnyView {
         #if !canImport(FoundationBridge)
         if #available(iOS 18, macOS 15, *) {
@@ -207,11 +264,10 @@ struct ScrollViewElement: View {
             return AnyView(view
                 .onScrollTargetVisibilityChange(idType: Int.self, threshold: 0.5) { ids in
                     visible = ids.sorted { (order[$0] ?? .max) < (order[$1] ?? .max) }
-                    if idle { report(Self.target(at: anchor, among: visible)) }
                 }
-                .onScrollPhaseChange { _, phase in
+                .onScrollPhaseChange { old, phase in
                     idle = phase == .idle
-                    if idle { report(Self.target(at: anchor, among: visible)) }
+                    if idle, old != .idle { reportSettled(Self.target(at: anchor, among: visible)) }
                 })
         }
         #endif

package/swift/Sources/SwiftBrowserProtocol/Props.swift

@@ -141,10 +141,13 @@ public struct ListProps: Equatable, Sendable {
     public var style: String
     public var refreshable: Bool
     public var editing: Bool?
+    /// `List(selection:)` over a `Set`: several rows may be selected.
+    public var multiSelect: Bool
     public init(props: JSONObject) {
         style = props.string("style") ?? "insetGrouped"
         refreshable = props.bool("refreshable") ?? false
         editing = props.bool("editing")
+        multiSelect = props.bool("multiSelect") ?? false
     }
 }
 

package/wasm/SwiftBrowserNative.wasm

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