@swiftbrowser/native 0.19.0 → 0.23.0

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

@@ -224,7 +224,10 @@ struct TextEditorElement: View {
 #if !canImport(FoundationBridge)
 /// The plain `texteditor` with `selection` (iOS 18, `TextEditor(text:selection:)`):
 /// the viewer's selection reported in UTF-16 offsets, and the caret moved
-/// to one the app sets, as the rich editor does.
+/// to one the app sets, as the rich editor does. A text that arrives from
+/// outside (not the echo of what the viewer typed) keeps the caret: the
+/// app's selection is applied even when its numbers did not change, else
+/// the caret is moved past the change (`caretAfterChange`).
 @available(iOS 18, macOS 15, *)
 struct PlainTextEditorElement: View {
     let node: ElementNode
@@ -232,16 +235,22 @@ struct PlainTextEditorElement: View {
     @State private var selection: TextSelection?
     @State private var shown = Shown()
 
-    /// The selection last sent, or last moved to (a class: set while drawing).
+    /// The selection last sent, or last moved to, and the text last sent (a class: set while drawing).
     final class Shown {
         var sent: TextSelectionSpec?
+        var sentText: String?
     }
 
     var body: some View {
         TextEditor(
             text: Binding(
                 get: { node.props.string("text") ?? "" },
-                set: { if let event = textChange(of: node, to: $0) { app?.dispatch(event) } }
+                set: { edited in
+                    if let event = textChange(of: node, to: edited) {
+                        shown.sentText = edited
+                        app?.dispatch(event)
+                    }
+                }
             ),
             selection: Binding(
                 get: { selection },
@@ -256,12 +265,25 @@ struct PlainTextEditorElement: View {
             )
         )
         .onChange(of: TextEditorProps(props: node.props).selection) { _, wanted in move(to: wanted) }
+        .onChange(of: node.props.string("text") ?? "") { old, new in textArrived(from: old, to: new) }
         .onAppear { move(to: TextEditorProps(props: node.props).selection) }
     }
 
-    /// A selection the app set (not the one this editor sent): the caret goes there.
-    private func move(to wanted: TextSelectionSpec?) {
-        guard let wanted, wanted != shown.sent else { return }
+    /// The app's text changed: the echo of what the viewer typed leaves the caret alone; a text from outside keeps it in place.
+    private func textArrived(from old: String, to new: String) {
+        if new == shown.sentText { return }
+        if let wanted = TextEditorProps(props: node.props).selection {
+            move(to: wanted, force: true)
+        } else if let current = selection, let range = offsets(of: current, in: old) {
+            let start = stringIndex(utf16: caretAfterChange(before: old, after: new, offset: range.start), in: new)
+            let end = stringIndex(utf16: caretAfterChange(before: old, after: new, offset: range.end), in: new)
+            selection = start == end ? TextSelection(insertionPoint: start) : TextSelection(range: start..<end)
+        }
+    }
+
+    /// A selection the app set (not the one this editor sent): the caret goes there; `force` moves even to the numbers last sent (the text changed under them).
+    private func move(to wanted: TextSelectionSpec?, force: Bool = false) {
+        guard let wanted, force || wanted != shown.sent else { return }
         shown.sent = wanted
         let text = node.props.string("text") ?? ""
         let start = stringIndex(utf16: wanted.start, in: text)

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

@@ -0,0 +1,378 @@
+#if canImport(SwiftUI)
+import Foundation
+import SwiftBrowserProtocol
+import SwiftBrowserTree
+import SwiftUI
+#if canImport(UniformTypeIdentifiers)
+import UniformTypeIdentifiers
+#endif
+
+// The kinds that draw or lay out on the app's say: a `canvas` replaying the
+// commands the app's renderer recorded, a custom `layout` answered by the
+// app's JavaScript, and the drag and drop pair (docs/native.md, "Views").
+
+// MARK: - canvas
+
+/// `canvas`: SwiftUI's `Canvas`, replaying each command with the context's state as the app recorded
+/// it: its clips (in the canvas's coordinates), then its transform, opacity, blend mode and filters.
+/// It fills its proposal and clips the drawing to its box, as the page's does.
+struct CanvasElement: View {
+    let node: ElementNode
+
+    var body: some View {
+        let props = CanvasProps(props: node.props)
+        Canvas { context, _ in
+            for command in props.commands { draw(command, into: context) }
+        }
+        .clipped()
+    }
+
+    private func draw(_ command: CanvasCommand, into canvas: GraphicsContext) {
+        var context = canvas
+        for clip in command.clips {
+            if let path = Path(svg: clip) { context.clip(to: path) }
+        }
+        if let m = command.transform { context.transform = CGAffineTransform(a: m[0], b: m[1], c: m[2], d: m[3], tx: m[4], ty: m[5]) }
+        context.opacity = command.opacity
+        if let mode = command.blendMode { setBlendMode(mode, of: &context) }
+        for filter in command.filters { context.addFilter(Self.filter(filter)) }
+        switch command.operation {
+        case .fill(let data, let shading, let evenOdd):
+            guard let path = Path(svg: data) else { return }
+            context.fill(path, with: Self.shading(shading), style: FillStyle(eoFill: evenOdd))
+        case .stroke(let data, let shading, let spec):
+            guard let path = Path(svg: data) else { return }
+            context.stroke(path, with: Self.shading(shading), style: StrokeStyle(
+                lineWidth: spec.lineWidth,
+                lineCap: spec.lineCap == "round" ? .round : spec.lineCap == "square" ? .square : .butt,
+                lineJoin: spec.lineJoin == "round" ? .round : spec.lineJoin == "bevel" ? .bevel : .miter,
+                miterLimit: spec.miterLimit ?? 10,
+                dash: spec.dash.map { CGFloat($0) },
+                dashPhase: spec.dashPhase
+            ))
+        case .text(let text, let x, let y, let anchor, let shading, let font):
+            var resolved = context.resolve(font.map { Text(verbatim: text).font(Font(spec: $0)) } ?? Text(verbatim: text))
+            resolved.shading = Self.shading(shading)
+            context.draw(resolved, at: CGPoint(x: x, y: y), anchor: UnitPoint(spec: anchor))
+        case .image(let image, let x, let y, let anchor, let width, let height, let shading):
+            // A symbol or a catalog image; a remote one has no bytes to draw synchronously here.
+            let source: Image
+            switch image {
+            case .symbol(let name, _): source = Image(systemName: name)
+            case .asset(let name, _): source = Image(name)
+            default: return
+            }
+            var resolved = context.resolve(source)
+            if let shading { resolved.shading = Self.shading(shading) }
+            if let width, let height {
+                let origin = CGPoint(x: x - anchor.x * width, y: y - anchor.y * height)
+                context.draw(resolved, in: CGRect(origin: origin, size: CGSize(width: width, height: height)))
+            } else {
+                context.draw(resolved, at: CGPoint(x: x, y: y), anchor: UnitPoint(spec: anchor))
+            }
+        }
+    }
+
+    static func shading(_ spec: CanvasShadingSpec) -> GraphicsContext.Shading {
+        let gradient = { (stops: [GradientStopSpec]) in Gradient(stops: stops.map { Gradient.Stop(color: Color(spec: $0.color), location: $0.location) }) }
+        switch spec {
+        case .style(let style):
+            return .style(AnyShapeStyle(spec: style))
+        case .linearGradient(let stops, let start, let end):
+            return .linearGradient(gradient(stops), startPoint: CGPoint(x: start.x, y: start.y), endPoint: CGPoint(x: end.x, y: end.y))
+        case .radialGradient(let stops, let center, let startRadius, let endRadius):
+            return .radialGradient(gradient(stops), center: CGPoint(x: center.x, y: center.y), startRadius: startRadius, endRadius: endRadius)
+        }
+    }
+
+    static func filter(_ spec: CanvasFilterSpec) -> GraphicsContext.Filter {
+        switch spec {
+        case .blur(let radius): .blur(radius: radius)
+        case .shadow(let color, let radius, let x, let y): .shadow(color: color.map(Color.init(spec:)) ?? Color.black.opacity(0.33), radius: radius, x: x, y: y)
+        case .grayscale(let amount): .grayscale(amount)
+        case .saturation(let amount): .saturation(amount)
+        case .brightness(let amount): .brightness(amount)
+        case .contrast(let amount): .contrast(amount)
+        case .hueRotation(let degrees): .hueRotation(.degrees(degrees))
+        case .invert(let amount): .colorInvert(amount)
+        }
+    }
+
+    /// The command's CSS blend mode. Assigned member by member: the context's blend mode is its own type
+    /// natively and the view's `BlendMode` in the shim, and both name these.
+    private func setBlendMode(_ name: String, of context: inout GraphicsContext) {
+        switch name {
+        case "multiply": context.blendMode = .multiply
+        case "screen": context.blendMode = .screen
+        case "overlay": context.blendMode = .overlay
+        case "darken": context.blendMode = .darken
+        case "lighten": context.blendMode = .lighten
+        case "color-dodge", "colorDodge": context.blendMode = .colorDodge
+        case "color-burn", "colorBurn": context.blendMode = .colorBurn
+        case "soft-light", "softLight": context.blendMode = .softLight
+        case "hard-light", "hardLight": context.blendMode = .hardLight
+        case "difference": context.blendMode = .difference
+        case "exclusion": context.blendMode = .exclusion
+        case "hue": context.blendMode = .hue
+        case "saturation": context.blendMode = .saturation
+        case "color": context.blendMode = .color
+        case "luminosity": context.blendMode = .luminosity
+        case "plus-lighter", "plusLighter": context.blendMode = .plusLighter
+        case "plus-darker", "plusDarker": context.blendMode = .plusDarker
+        default: context.blendMode = .normal
+        }
+    }
+}
+
+// MARK: - layout
+
+/// `layout`: a SwiftUI `Layout` the app's JavaScript answers. After a pass it reports the proposal it
+/// was placed with and each child's min, ideal and max sizes (`layout`, deferred past the pass, as
+/// `geometry` is, and only when they changed); the app answers with the element's `size` and `frames`.
+/// Until the first answer it fills its proposal; for another proposal it reads its flexibility from the
+/// answer's `sizes`, and places the children at the last frames.
+struct LayoutElement: View {
+    let node: ElementNode
+    @Environment(\.nativeApp) private var app
+    @State private var reporter = LayoutReporter()
+
+    var body: some View {
+        let reporter = reporter
+        let id = node.id
+        let app = app
+        let layout = AppLayout(props: LayoutProps(props: node.props)) { record in
+            reporter.report(RendererEvent.layout(id, proposal: record.proposal, children: record.children), app: app)
+        }
+        layout { ChildrenView(node: node) }
+    }
+}
+
+/// The last record a `layout` element sent: a pass that measured the same sends nothing.
+final class LayoutReporter: @unchecked Sendable {
+    private var last: RendererEvent?
+
+    func report(_ event: RendererEvent, app: NativeApp?) {
+        guard event != last else { return }
+        last = event
+        Task { @MainActor in app?.dispatch(event) }
+    }
+}
+
+struct AppLayout: Layout {
+    struct Record {
+        var proposal: LayoutProposalSpec
+        var children: [LayoutMeasurementSpec]
+    }
+
+    let props: LayoutProps
+    let report: (Record) -> Void
+
+    private static func spec(_ proposal: ProposedViewSize) -> LayoutProposalSpec {
+        LayoutProposalSpec(width: proposal.width.map { LayoutDimensionSpec(Double($0)) }, height: proposal.height.map { LayoutDimensionSpec(Double($0)) })
+    }
+
+    func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
+        if let size = props.size, props.proposal == Self.spec(proposal) { return CGSize(width: size.width, height: size.height) }
+        if let min = props.min, let ideal = props.ideal, let max = props.max {
+            func axis(_ proposed: CGFloat?, _ min: LayoutDimensionSpec, _ ideal: LayoutDimensionSpec, _ max: LayoutDimensionSpec) -> CGFloat {
+                guard let proposed else { return ideal.value.isFinite ? ideal.value : 0 }
+                let clamped = Swift.min(Swift.max(Double(proposed), min.value), max.value)
+                return clamped.isFinite ? clamped : (ideal.value.isFinite ? ideal.value : 0)
+            }
+            return CGSize(width: axis(proposal.width, min.width, ideal.width, max.width), height: axis(proposal.height, min.height, ideal.height, max.height))
+        }
+        return proposal.replacingUnspecifiedDimensions()
+    }
+
+    func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {
+        let measure = { (subview: LayoutSubview, proposal: ProposedViewSize) -> LayoutSizeSpec in
+            let size = subview.sizeThatFits(proposal)
+            return LayoutSizeSpec(width: Double(size.width), height: Double(size.height))
+        }
+        report(Record(
+            proposal: Self.spec(proposal),
+            children: subviews.map { LayoutMeasurementSpec(min: measure($0, .zero), ideal: measure($0, .unspecified), max: measure($0, .infinity)) }
+        ))
+        if let frames = props.frames, frames.count == subviews.count {
+            for (subview, frame) in zip(subviews, frames) {
+                subview.place(at: CGPoint(x: bounds.minX + frame.x, y: bounds.minY + frame.y), anchor: .topLeading, proposal: ProposedViewSize(width: frame.width, height: frame.height))
+            }
+        } else {
+            for subview in subviews { subview.place(at: bounds.origin, anchor: .topLeading, proposal: ProposedViewSize(bounds.size)) }
+        }
+    }
+}
+
+// MARK: - drag and drop
+
+/// `draggable`: SwiftUI's `.draggable`, carrying the element's id as text: what is dragged stays in
+/// the app, which makes it at `dragstart` (sent as the drag begins) and hands it to the destination the
+/// drop names. A drop on no destination sends no `dragend`; the app's next lift replaces what it kept.
+struct DraggableElement: View {
+    let node: ElementNode
+    @Environment(\.nativeApp) private var app
+
+    var body: some View {
+        let id = node.id
+        let app = app
+        content.draggable(Self.lift(id, app))
+    }
+
+    @ViewBuilder private var content: some View {
+        if node.children.count == 1 { ElementView(node: node.children[0]) } else { ChildrenView(node: node) }
+    }
+
+    /// The payload, made as the drag begins: the app hears `dragstart` first.
+    private static func lift(_ id: Int, _ app: NativeApp?) -> String {
+        Task { @MainActor in app?.dispatch(.dragStart(id)) }
+        return DragPayload.text(for: id)
+    }
+}
+
+#if !canImport(FoundationBridge)
+/// What a drop from another app carries: text (or a link) as the page offers it, or a file or folder, copied
+/// into a tmp folder of the app's while the drop runs (a received file is the system's only until then).
+struct DropPayload: Transferable {
+    enum Kind {
+        case text(String)
+        case file(URL, folder: Bool)
+    }
+    let kind: Kind
+
+    static var transferRepresentation: some TransferRepresentation {
+        FileRepresentation(importedContentType: .folder) { received in
+            DropPayload(kind: .file(try Self.keep(received.file), folder: true))
+        }
+        FileRepresentation(importedContentType: .item) { received in
+            DropPayload(kind: .file(try Self.keep(received.file), folder: false))
+        }
+        ProxyRepresentation { (url: URL) in DropPayload(kind: .text(url.absoluteString)) }
+        ProxyRepresentation { (text: String) in DropPayload(kind: .text(text)) }
+    }
+
+    /// The received item copied into a folder of its own in tmp, registered as picked (PickedFiles) until the app releases it.
+    private static func keep(_ received: URL) throws -> URL {
+        let folder = FileManager.default.temporaryDirectory.appendingPathComponent("swiftbrowser-drops-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
+        let kept = folder.appendingPathComponent(received.lastPathComponent)
+        try FileManager.default.copyItem(at: received, to: kept)
+        PickedFiles.shared.register([kept], temporary: folder)
+        return kept
+    }
+}
+
+/// `dropdestination`: SwiftUI's `.dropDestination`. A drag over it sends `drop` `entered` and `exited`; a
+/// drop sends `performed` with the `draggable` it came from (and that one's `dragend`), or, for what another
+/// app dragged in and `accepts` takes, the text as `items`, or each file (a dropped folder's at any depth, named
+/// by their paths in it) as an item still on disk: `{ type, name, path?, url, size }`, which the app reads on
+/// demand through the files bridge (a `LazyFile` in @swiftbrowser/native).
+struct DropDestinationElement: View {
+    let node: ElementNode
+    @Environment(\.nativeApp) private var app
+
+    var body: some View {
+        let id = node.id
+        let app = app
+        let props = DropDestinationProps(props: node.props)
+        content.dropDestination(for: DropPayload.self) { payloads, location in
+            var events: [RendererEvent] = []
+            var outside: [JSONValue] = []
+            for payload in payloads {
+                switch payload.kind {
+                case .text(let text):
+                    if let source = DragPayload.source(of: text) {
+                        events.append(.drop(id, phase: "performed", source: source, x: location.x, y: location.y))
+                        events.append(.dragEnd(source))
+                    } else if props.acceptsText {
+                        let link = URL(string: text).map { $0.scheme != nil && !text.contains(where: \.isWhitespace) } ?? false
+                        outside.append(.object(["type": .string(link ? "text/uri-list" : "text/plain"), "text": .string(text)]))
+                    }
+                case .file(let url, let folder):
+                    guard props.acceptsFiles else { continue }
+                    outside.append(contentsOf: Self.fileItems(url, folder: folder, props: props))
+                }
+            }
+            if !outside.isEmpty { events.append(.drop(id, phase: "performed", items: outside, x: location.x, y: location.y)) }
+            guard !events.isEmpty else { return false }
+            let sent = events
+            Task { @MainActor in for event in sent { app?.dispatch(event) } }
+            return true
+        } isTargeted: { targeted in
+            Task { @MainActor in app?.dispatch(.drop(id, phase: targeted ? "entered" : "exited")) }
+        }
+    }
+
+    /// A dropped file as one item, or a dropped folder's files (at any depth, hidden ones left out) as items named by
+    /// their paths from the folder, the folder's name first, as the page names a dropped folder's files.
+    private static func fileItems(_ url: URL, folder: Bool, props: DropDestinationProps) -> [JSONValue] {
+        let mime = { (file: URL) in UTType(filenameExtension: file.pathExtension)?.preferredMIMEType ?? "application/octet-stream" }
+        let item = { (file: URL, path: String?) -> JSONValue in
+            let size = (try? file.resourceValues(forKeys: [.fileSizeKey]))?.fileSize ?? 0
+            var value: JSONObject = [
+                "type": .string(mime(file)),
+                "name": .string(file.lastPathComponent),
+                "url": .string(file.standardizedFileURL.absoluteString),
+                "size": .number(Double(size)),
+            ]
+            if let path { value["path"] = .string(path) }
+            return .object(value)
+        }
+        guard folder else { return props.accepts(mimeType: mime(url)) ? [item(url, nil)] : [] }
+        let root = url.standardizedFileURL.pathComponents
+        guard let walker = FileManager.default.enumerator(at: url, includingPropertiesForKeys: [.isRegularFileKey], options: [.skipsHiddenFiles, .skipsPackageDescendants]) else { return [] }
+        var items: [JSONValue] = []
+        var urls: [URL] = []
+        for case let file as URL in walker {
+            guard (try? file.resourceValues(forKeys: [.isRegularFileKey]))?.isRegularFile == true, props.accepts(mimeType: mime(file)) else { continue }
+            let components = file.standardizedFileURL.pathComponents
+            guard components.count > root.count else { continue }
+            items.append(item(file, ([url.lastPathComponent] + components.dropFirst(root.count)).joined(separator: "/")))
+            urls.append(file)
+        }
+        PickedFiles.shared.register(urls)
+        return items
+    }
+
+    @ViewBuilder private var content: some View {
+        if node.children.count == 1 { ElementView(node: node.children[0]) } else { ChildrenView(node: node) }
+    }
+}
+#else
+/// `dropdestination`: SwiftUI's `.dropDestination(for: String.self)`, against the shim (the round trip): in-app
+/// drags, and text from outside that `accepts` takes; files need the system's `Transferable` (above).
+struct DropDestinationElement: View {
+    let node: ElementNode
+    @Environment(\.nativeApp) private var app
+
+    var body: some View {
+        let id = node.id
+        let app = app
+        let accepts = DropDestinationProps(props: node.props).acceptsText
+        content.dropDestination(for: String.self) { texts, location in
+            var events: [RendererEvent] = []
+            var outside: [JSONValue] = []
+            for text in texts {
+                if let source = DragPayload.source(of: text) {
+                    events.append(.drop(id, phase: "performed", source: source, x: location.x, y: location.y))
+                    events.append(.dragEnd(source))
+                } else if accepts {
+                    let link = URL(string: text).map { $0.scheme != nil && !text.contains(where: \.isWhitespace) } ?? false
+                    outside.append(.object(["type": .string(link ? "text/uri-list" : "text/plain"), "text": .string(text)]))
+                }
+            }
+            if !outside.isEmpty { events.append(.drop(id, phase: "performed", items: outside, x: location.x, y: location.y)) }
+            guard !events.isEmpty else { return false }
+            let sent = events
+            Task { @MainActor in for event in sent { app?.dispatch(event) } }
+            return true
+        } isTargeted: { targeted in
+            Task { @MainActor in app?.dispatch(.drop(id, phase: targeted ? "entered" : "exited")) }
+        }
+    }
+
+    @ViewBuilder private var content: some View {
+        if node.children.count == 1 { ElementView(node: node.children[0]) } else { ChildrenView(node: node) }
+    }
+}
+#endif
+#endif

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

@@ -8,9 +8,9 @@ import SwiftUI
 /// expresses push and pop purely as children appearing and disappearing;
 /// natively the path is derived from them. A native pop (the back button, an
 /// edge swipe) sends `tap` with the popped screen's id, as the protocol says
-/// (PopTap.swift: at once for a button, once the finger lets go for a
-/// swipe), and the app removes the child, so the next read of the path
-/// agrees with the screen.
+/// (PopTap.swift: once UIKit's pop transition has finished, and not for a
+/// cancelled swipe), and the app removes the child, so the next read of the
+/// path agrees with the screen.
 struct NavigationStackElement: View {
     let node: ElementNode
     @Environment(\.nativeApp) private var app
@@ -28,10 +28,12 @@ struct NavigationStackElement: View {
         let screens = node?.children.filter { $0.kind == "navscreen" } ?? []
         let pushed = screens.dropFirst().map(\.id)
         let path = Binding<[Int]>(
-            get: { node?.children.filter { $0.kind == "navscreen" }.dropFirst().map(\.id) ?? [] },
+            // A screen whose pop is under way is left out, as SwiftUI's own
+            // path has it, while the tree keeps it until the pop has finished.
+            get: { node?.children.filter { $0.kind == "navscreen" }.dropFirst().map(\.id).filter { !PopTap.pending.contains($0) } ?? [] },
             set: { next in
                 // Only pops come from here (pushes come from the app; a
-                // cancelled swipe puts its id back, which the getter kept).
+                // cancelled swipe puts its id back).
                 for id in pushed where !next.contains(id) {
                     PopTap.send(id, app: app)
                 }
@@ -318,12 +320,15 @@ struct NavigationLinkElement: View {
 
     /// Whether the list around is in edit mode with a selection: a link row
     /// is then selected by its tap (the row's `tag`, ListRowElement), not
-    /// followed, as iOS selects a `NavigationLink` row then.
-    private var selecting: Bool {
+    /// followed, as iOS selects a `NavigationLink` row then. A split view
+    /// sidebar's link (`selects`) is its row's selection always: the cell
+    /// takes the touch and selects itself before the app pushes, so the
+    /// list does not change under the push's transition.
+    private func selecting(_ props: NavLinkProps) -> Bool {
         #if os(iOS) || canImport(FoundationBridge)
-        listSelects && editMode?.wrappedValue.isEditing == true
+        listSelects && (props.selects || editMode?.wrappedValue.isEditing == true)
         #else
-        false
+        listSelects && props.selects
         #endif
     }
 
@@ -349,7 +354,7 @@ struct NavigationLinkElement: View {
                 ChildrenView(node: node)
             }
         }
-        let tappable: AnyView = inList && selecting
+        let tappable: AnyView = inList && selecting(props)
             ? AnyView(label)
             : AnyView(Button { app?.dispatch(.tap(node.id)) } label: { label }.buttonStyle(.plain))
         tappable

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

@@ -6,21 +6,24 @@ import UIKit
 #endif
 
 /// The `tap` a native pop sends with the popped screen's id (Navigation.swift),
-/// timed to the pop. For a back button or a programmatic pop it goes at once:
-/// the app removes the screen inside SwiftUI's set of the path, and the stack
-/// keeps drawing it from the tree's record through the transition
-/// (`OpTree.poppedScreen`). For an interactive pop (the edge swipe) SwiftUI
-/// sets the path the moment the swipe begins, before anyone knows whether
-/// it will go through; the tap waits until the finger has let go and the pop
-/// is finishing, and a cancelled swipe sends none. Sent at the swipe's start,
-/// the app's removal left the screen drawn from the record with its title
-/// gone while the finger was still down, and a cancelled swipe showing a
-/// screen the app no longer had.
+/// timed to the pop. SwiftUI sets the stack's path as UIKit's pop begins (a
+/// back button's tap, or the start of an edge swipe, before anyone knows
+/// whether it will go through); the tap waits until the transition has
+/// finished, and a cancelled swipe sends none. Meanwhile the screen is
+/// `pending`: the stack's path leaves it out, as SwiftUI's own has, while
+/// the tree still has it, so the departing screen is drawn as it is, title
+/// included. Removed at once, it was drawn from the tree's record of it
+/// (`OpTree.poppedScreen`) and UIKit dropped its large title in the pop's
+/// first frame. Without a transition (a programmatic pop, or no navigation
+/// controller to ask) the tap goes at once.
 enum PopTap {
+    /// The screens whose pop is under way: their taps wait for its end.
+    @MainActor private(set) static var pending: Set<Int> = []
+
     @MainActor
     static func send(_ id: Int, app: NativeApp?) {
         #if os(iOS) && !canImport(FoundationBridge)
-        if let coordinator = interactivePop() {
+        if let coordinator = runningTransition() {
             send(id, during: CoordinatorTransition(coordinator: coordinator)) { app?.dispatch(.tap($0)) }
             return
         }
@@ -28,27 +31,30 @@ enum PopTap {
         app?.dispatch(.tap(id))
     }
 
-    /// The tap through the pop's transition: at once unless a finger drives
-    /// it, else when the finger lets go, and only when the pop goes through.
+    /// The tap through the pop's transition: once it has finished, and only
+    /// when the pop went through; at once without one.
     @MainActor
-    static func send(_ id: Int, during transition: any PopTransition, dispatch: @escaping @MainActor (Int) -> Void) {
-        guard transition.isInteractive else {
+    static func send(_ id: Int, during transition: (any PopTransition)?, dispatch: @escaping @MainActor (Int) -> Void) {
+        guard let transition else {
             dispatch(id)
             return
         }
-        transition.whenInteractionEnds { cancelled in
+        guard !pending.contains(id) else { return }
+        pending.insert(id)
+        transition.whenFinished { cancelled in
+            pending.remove(id)
             if !cancelled { dispatch(id) }
         }
     }
 
     #if os(iOS) && !canImport(FoundationBridge)
-    /// The transition of a navigation controller in the app's windows that a finger is driving, if any.
+    /// The transition of a navigation controller in the app's windows, if one is running.
     @MainActor
-    private static func interactivePop() -> (any UIViewControllerTransitionCoordinator)? {
+    private static func runningTransition() -> (any UIViewControllerTransitionCoordinator)? {
         let windows = UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }.flatMap(\.windows)
         for window in windows {
             for nav in navigationControllers(in: window) {
-                if let coordinator = nav.transitionCoordinator, coordinator.isInteractive { return coordinator }
+                if let coordinator = nav.transitionCoordinator { return coordinator }
             }
         }
         return nil
@@ -72,13 +78,12 @@ enum PopTap {
     #endif
 }
 
-/// A pop's transition as `PopTap` reads it: whether a finger drives it, and
-/// word of the finger letting go (UIKit's transition coordinator, or a test's).
+/// A pop's transition as `PopTap` reads it: word of its end, and whether
+/// the pop went through (UIKit's transition coordinator, or a test's).
 @MainActor
 protocol PopTransition {
-    var isInteractive: Bool { get }
-    /// Calls `handler` once the interactive part ends, with whether the pop was cancelled.
-    func whenInteractionEnds(_ handler: @escaping @MainActor (_ cancelled: Bool) -> Void)
+    /// Calls `handler` once the transition has finished, with whether the pop was cancelled.
+    func whenFinished(_ handler: @escaping @MainActor (_ cancelled: Bool) -> Void)
 }
 
 #if os(iOS) && !canImport(FoundationBridge)
@@ -87,10 +92,8 @@ protocol PopTransition {
 struct CoordinatorTransition: PopTransition {
     let coordinator: any UIViewControllerTransitionCoordinator
 
-    var isInteractive: Bool { coordinator.isInteractive }
-
-    func whenInteractionEnds(_ handler: @escaping @MainActor (_ cancelled: Bool) -> Void) {
-        coordinator.notifyWhenInteractionChanges { context in
+    func whenFinished(_ handler: @escaping @MainActor (_ cancelled: Bool) -> Void) {
+        coordinator.animate(alongsideTransition: nil) { context in
             let cancelled = context.isCancelled
             MainActor.assumeIsolated { handler(cancelled) }
         }