@swiftbrowser/native 0.18.1 → 0.18.2

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

@@ -0,0 +1,105 @@
+#if canImport(SwiftUI)
+import SwiftBrowserProtocol
+import SwiftUI
+#if canImport(UIKit)
+import UIKit
+#elseif canImport(AppKit)
+import AppKit
+#endif
+
+/// A `textfield`'s text input hints (docs/ops-protocol.md, "Text input
+/// hints") as SwiftUI's own modifiers: `.keyboardType` and
+/// `.textInputAutocapitalization` where there is an on-screen keyboard,
+/// `.textContentType`, which is what AutoFill and the QuickType bar offer (an
+/// email field with `emailAddress` suggests the viewer's addresses; a
+/// `oneTimeCode` field the code from Messages), and `.autocorrectionDisabled`.
+/// macOS takes the content type and the correction. A name the platform has
+/// no case for is left to the default, as the web renderer leaves it to the
+/// browser. Against the shim (the round trip) the modifiers are the shim's,
+/// which carry the names on as props.
+extension View {
+    func textInputHints(_ props: TextFieldProps) -> some View {
+        var view = AnyView(self)
+        #if os(iOS) || canImport(FoundationBridge)
+        if let keyboard = props.keyboard.flatMap(keyboardTypeNamed) { view = AnyView(view.keyboardType(keyboard)) }
+        if let capitalization = props.autocapitalization.flatMap(autocapitalizationNamed) {
+            view = AnyView(view.textInputAutocapitalization(capitalization))
+        }
+        #endif
+        if let contentType = props.contentType.flatMap(contentTypeNamed) { view = AnyView(view.textContentType(contentType)) }
+        if props.autocorrectionDisabled { view = AnyView(view.autocorrectionDisabled()) }
+        return view
+    }
+}
+
+#if os(iOS) || canImport(FoundationBridge)
+/// The protocol's `keyboard` names: `UIKeyboardType`'s cases.
+private func keyboardTypeNamed(_ name: String) -> UIKeyboardType? {
+    switch name {
+    case "default": .default
+    case "asciiCapable": .asciiCapable
+    case "numbersAndPunctuation": .numbersAndPunctuation
+    case "URL": .URL
+    case "numberPad": .numberPad
+    case "phonePad": .phonePad
+    case "namePhonePad": .namePhonePad
+    case "emailAddress": .emailAddress
+    case "decimalPad": .decimalPad
+    case "twitter": .twitter
+    case "webSearch": .webSearch
+    case "asciiCapableNumberPad": .asciiCapableNumberPad
+    default: nil
+    }
+}
+
+private func autocapitalizationNamed(_ name: String) -> TextInputAutocapitalization? {
+    switch name {
+    case "never": .never
+    case "words": .words
+    case "sentences": .sentences
+    case "characters": .characters
+    default: nil
+    }
+}
+
+/// The protocol's `contentType` names: `UITextContentType`'s.
+private func contentTypeNamed(_ name: String) -> UITextContentType? {
+    switch name {
+    case "name": .name
+    case "givenName": .givenName
+    case "familyName": .familyName
+    case "emailAddress": .emailAddress
+    case "telephoneNumber": .telephoneNumber
+    case "username": .username
+    case "password": .password
+    case "newPassword": .newPassword
+    case "oneTimeCode": .oneTimeCode
+    case "URL": .URL
+    case "fullStreetAddress": .fullStreetAddress
+    case "postalCode": .postalCode
+    case "creditCardNumber": .creditCardNumber
+    default: nil
+    }
+}
+#elseif os(macOS)
+/// The protocol's `contentType` names as `NSTextContentType`, which has them all from macOS 14.
+private func contentTypeNamed(_ name: String) -> NSTextContentType? {
+    switch name {
+    case "name": .name
+    case "givenName": .givenName
+    case "familyName": .familyName
+    case "emailAddress": .emailAddress
+    case "telephoneNumber": .telephoneNumber
+    case "username": .username
+    case "password": .password
+    case "newPassword": .newPassword
+    case "oneTimeCode": .oneTimeCode
+    case "URL": .URL
+    case "fullStreetAddress": .fullStreetAddress
+    case "postalCode": .postalCode
+    case "creditCardNumber": .creditCardNumber
+    default: nil
+    }
+}
+#endif
+#endif

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

@@ -0,0 +1,102 @@
+#if canImport(SwiftUI)
+import SwiftBrowserProtocol
+import SwiftBrowserTree
+import SwiftUI
+
+/// `touches`: every finger on the element (docs/ops-protocol.md,
+/// "Multi-touch"), for chords and glissandi. On iOS 18 and macOS 15
+/// `SpatialEventGesture` reports them all; before that, and against the shim
+/// (the round trip), a `DragGesture` with no minimum distance reports the one
+/// finger it can. Each change sends `touches` with every finger still down,
+/// in the element's coordinates.
+struct TouchesElement: View {
+    let node: ElementNode
+    @Environment(\.nativeApp) private var app
+    @State private var tracker = TouchTracker()
+
+    var body: some View {
+        let content = ChildrenView(node: node).contentShape(Rectangle())
+        #if os(iOS) || os(macOS)
+        if #available(iOS 18.0, macOS 15.0, *) {
+            content.gesture(
+                SpatialEventGesture()
+                    .onChanged { events in report(events) }
+                    .onEnded { events in report(events) }
+            )
+        } else {
+            single(content)
+        }
+        #else
+        single(content)
+        #endif
+    }
+
+    #if os(iOS) || os(macOS)
+    @available(iOS 18.0, macOS 15.0, *)
+    private func report(_ events: SpatialEventCollection) {
+        let active = events.filter { $0.phase == .active }.map { (tracker.number(for: AnyHashable($0.id)), $0.location) }
+        let cancelled = events.contains { $0.phase == .cancelled }
+        send(tracker.update(active: active, cancelled: cancelled))
+    }
+    #endif
+
+    /// One finger, where the system reports no more.
+    private func single(_ content: some View) -> some View {
+        content.gesture(
+            DragGesture(minimumDistance: 0)
+                .onChanged { value in send(tracker.update(active: [(1, value.location)], cancelled: false)) }
+                .onEnded { _ in send(tracker.update(active: [], cancelled: false)) }
+        )
+    }
+
+    private func send(_ change: TouchTracker.Change?) {
+        guard let change else { return }
+        app?.dispatch(.touches(node.id, phase: change.phase, touches: change.touches.map { (id: $0.id, x: $0.x, y: $0.y) }))
+    }
+}
+
+/// The fingers last reported on a `touches` element, so each report tells
+/// its phase. A reference, so a move redraws nothing.
+final class TouchTracker {
+    struct Change: Equatable {
+        var phase: String
+        var touches: [Touch]
+    }
+    struct Touch: Equatable {
+        var id: Int
+        var x: Double
+        var y: Double
+    }
+
+    /// The system's event identifiers as small integers, stable while a finger is down.
+    private var numbers: [AnyHashable: Int] = [:]
+    private var next = 1
+    /// The fingers down, in order of arrival.
+    private var down: [(id: Int, point: CGPoint)] = []
+
+    func number(for id: AnyHashable) -> Int {
+        if let known = numbers[id] { return known }
+        numbers[id] = next
+        next += 1
+        return next - 1
+    }
+
+    /// Takes the fingers now down; what to report, or nil when nothing changed.
+    func update(active: [(Int, CGPoint)], cancelled: Bool) -> Change? {
+        let before = down
+        let beforeIds = Set(before.map(\.id))
+        let nowIds = Set(active.map(\.0))
+        let began = !nowIds.subtracting(beforeIds).isEmpty
+        let ended = !beforeIds.subtracting(nowIds).isEmpty
+        let points = Dictionary(active.map { ($0.0, $0.1) }, uniquingKeysWith: { _, last in last })
+        let moved = before.contains { finger in points[finger.id].map { $0 != finger.point } ?? false }
+        down = before.compactMap { finger in points[finger.id].map { (id: finger.id, point: $0) } }
+            + active.filter { !beforeIds.contains($0.0) }.map { (id: $0.0, point: $0.1) }
+        if nowIds.isEmpty { numbers.removeAll() } else { numbers = numbers.filter { nowIds.contains($0.value) } }
+        let phase: String? = began ? "began" : ended ? (cancelled && nowIds.isEmpty ? "cancelled" : "ended") : moved ? "changed" : nil
+        guard let phase else { return nil }
+        let round = { (value: CGFloat) in (Double(value) * 100).rounded() / 100 }
+        return Change(phase: phase, touches: down.map { Touch(id: $0.id, x: round($0.point.x), y: round($0.point.y)) })
+    }
+}
+#endif

package/swift/Sources/SwiftBrowserProtocol/Props.swift

@@ -240,6 +240,15 @@ public struct TextFieldProps: Equatable, Sendable {
     public var deleteBackward: Bool
     public var submitLabel: String?
     public var vertical: Bool
+    /// The text input hints (docs/ops-protocol.md, "Text input hints").
+    /// `.keyboardType(_:)`: a `UIKeyboardType` case name (`emailAddress`, `numberPad`…); nil for the default.
+    public var keyboard: String?
+    /// `.textContentType(_:)`: a `UITextContentType` name (`emailAddress`, `oneTimeCode`…), what autofill offers.
+    public var contentType: String?
+    /// `.textInputAutocapitalization(_:)`: `never`, `words`, `sentences` or `characters`.
+    public var autocapitalization: String?
+    /// `.autocorrectionDisabled()`.
+    public var autocorrectionDisabled: Bool
     public init(props: JSONObject) {
         text = props.string("text") ?? ""
         placeholder = props.string("placeholder") ?? ""
@@ -250,6 +259,10 @@ public struct TextFieldProps: Equatable, Sendable {
         deleteBackward = props.bool("deleteBackward") ?? false
         submitLabel = props.string("submitLabel")
         vertical = props.string("axis") == "vertical"
+        keyboard = props.string("keyboard")
+        contentType = props.string("contentType")
+        autocapitalization = props.string("autocapitalization")
+        autocorrectionDisabled = props.bool("autocorrectionDisabled") ?? false
     }
 }
 

package/swift/Sources/SwiftBrowserProtocol/RendererEvent.swift

@@ -126,6 +126,15 @@ public struct RendererEvent: Equatable, Sendable {
     public static func lazy(_ id: Int) -> RendererEvent { with("lazy", id: id) }
     /// A `gesture` long press.
     public static func longPress(_ id: Int) -> RendererEvent { with("longpress", id: id) }
+    /// A `touches` element's pointers changed (docs/ops-protocol.md, "Multi-touch"): `phase` as a drag's
+    /// (`began` a finger down, `changed` moved, `ended` lifted, `cancelled` all lost); `touches` every finger
+    /// still down, in the element's coordinates, in order of arrival.
+    public static func touches(_ id: Int, phase: String, touches: [(id: Int, x: Double, y: Double)]) -> RendererEvent {
+        with("touches", id: id, [
+            "phase": .string(phase),
+            "touches": .array(touches.map { .object(["id": .number(Double($0.id)), "x": .number($0.x), "y": .number($0.y)]) }),
+        ])
+    }
     /// A `list` or `scrollview` with `refreshable` was pulled.
     public static func refresh(_ id: Int) -> RendererEvent { with("refresh", id: id) }
     /// `.scrollPosition(id:)`: the marked element at the scroll view's anchor once it settled.

package/wasm/SwiftBrowserNative.wasm

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