@swiftbrowser/native 0.17.0 → 0.17.1

package/package.json

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

@@ -177,18 +177,41 @@ 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
+        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 { report(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 }
         proxy.scrollTo(request.id, anchor: request.anchor)
     }
 
-    /// Tells the app the target at the anchor, once per target.
+    /// 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)) }
     }
 
     /// Whether this OS reports the settled position (`reportingSettled`) rather than the binding's every change.
@@ -199,7 +222,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 +235,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 { report(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: 49329004 bytes
+sha256: 5ce7ef4d787494787133dc374d57de7d72e0173da56ce76e22d0030644a6b5f2