@swiftbrowser/native 0.17.7 → 0.18.0

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

@@ -45,9 +45,10 @@ struct ButtonElement: View {
             }
         }()
         switch props.style {
-        // `.borderless` reaches the protocol as `plain` too; outside a list,
-        // where a plain-looking text button is tinted on iOS, draw it so.
-        case "plain": node.ancestor(ofKind: "list") != nil ? AnyView(sized.buttonStyle(.plain)) : AnyView(sized.buttonStyle(.borderless))
+        // `plain` is the label in the foreground around it, as the page draws
+        // it (Numbers' document cards); `borderless` the tinted text button.
+        case "plain": sized.buttonStyle(.plain)
+        case "borderless": sized.buttonStyle(.borderless)
         case "bordered": sized.buttonStyle(.bordered)
         case "borderedProminent", "glass": sized.buttonStyle(.borderedProminent)
         default: sized.buttonStyle(.automatic)
@@ -62,28 +63,54 @@ struct ToggleElement: View {
     @Environment(\.nativeApp) private var app
 
     var body: some View {
-        Toggle(isOn: Binding(
+        let toggle = Toggle(isOn: Binding(
             get: { ToggleProps(props: node.props).isOn },
             set: { app?.dispatch(.toggle(node.id, $0)) }
         )) {
             ChildrenView(node: node)
         }
+        switch ToggleProps(props: node.props).style {
+        case "button": AnyView(toggle.toggleStyle(.button))
+        case "switch": AnyView(toggle.toggleStyle(.switch))
+        default: AnyView(toggle)
+        }
     }
 }
 
-/// `textfield`: a controlled field. Each keystroke sends `text`; the app's
-/// state is the truth the getter reads back, with no frame in between
-/// because the dispatch is synchronous.
+/// The `text` event for a write to a field's binding, or nil when the
+/// field's text already is `value`. SwiftUI writes a text binding on a focus
+/// and a commit with the text it has, not only on a keystroke; the page's
+/// renderer sends `text` only for input, and an app that takes every `text`
+/// as an edit (Amindia's Discard button, appearing on a tap into a field)
+/// must hear only changes natively too.
+func textChange(of node: ElementNode, to value: String) -> RendererEvent? {
+    (node.props.string("text") ?? "") == value ? nil : .text(node.id, value)
+}
+
+/// `textfield`: a controlled field. Each keystroke sends `text` (a write of
+/// the text the field has sends nothing, `textChange`); the app's state is
+/// the truth the getter reads back, with no frame in between because the
+/// dispatch is synchronous. So is `submit`: Return dismisses the keyboard
+/// after `onSubmit`, and the app's answer decides whether it may. A bound
+/// `focused` the answer leaves true is held (`keeping`): the resign that
+/// follows is taken back, not reported; one it turned false lets the
+/// resign through; another field's turned true takes the focus in its own
+/// `onChange` of the prop.
 struct TextFieldElement: View {
     let node: ElementNode
     @Environment(\.nativeApp) private var app
     @FocusState private var focused: Bool
+    /// Set by a submit the app answered keeping the field focused, until the resign it holds against comes (or would have).
+    @State private var keeping = false
+
+    /// How long after a submit a resign is Return's: SwiftUI's follows within the turn; macOS sends none.
+    private static let resignWindow: Duration = .milliseconds(300)
 
     var body: some View {
         let props = TextFieldProps(props: node.props)
         let text = Binding(
             get: { TextFieldProps(props: node.props).text },
-            set: { app?.dispatch(.text(node.id, $0)) }
+            set: { if let event = textChange(of: node, to: $0) { app?.dispatch(event) } }
         )
         let field: AnyView = {
             if props.secure { return AnyView(SecureField(props.placeholder, text: text)) }
@@ -92,8 +119,16 @@ struct TextFieldElement: View {
         }()
         var styled = props.style == "roundedBorder" ? AnyView(field.textFieldStyle(.roundedBorder)) : AnyView(field.textFieldStyle(.plain))
         // Only what the app set: each of these is a trait of the field to SwiftUI.
-        if props.submit { styled = AnyView(styled.onSubmit { app?.dispatch(.submit(node.id)) }) }
+        if props.submit {
+            styled = AnyView(styled.onSubmit {
+                app?.dispatch(.submit(node.id))
+                // The app's pass applied: a `focused` it left or set true wins over the resign on its way.
+                if TextFieldProps(props: node.props).focused == true { keep() }
+            })
+        }
         if let label = props.submitLabel { styled = AnyView(styled.submitLabel(SubmitLabel(name: label))) }
+        // Backspace at the start of the text (DeleteBackward.swift).
+        if props.deleteBackward { styled = AnyView(styled.onDeleteBackward(true) { app?.dispatch(.deleteBackward(node.id)) }) }
         if props.focused != nil {
             styled = AnyView(styled
                 .focused($focused)
@@ -101,12 +136,29 @@ struct TextFieldElement: View {
                     if let wanted, wanted != focused { focused = wanted }
                 }
                 .onChange(of: focused) { _, now in
-                    if props.focused != now { app?.dispatch(.focus(node.id, now)) }
+                    if now {
+                        keeping = false
+                    } else if keeping {
+                        // Return's resign of a field the app keeps: take the focus back and say nothing.
+                        keeping = false
+                        focused = true
+                        return
+                    }
+                    if TextFieldProps(props: node.props).focused != now { app?.dispatch(.focus(node.id, now)) }
                 }
                 .onAppear { if props.focused == true { focused = true } })
         }
         return styled
     }
+
+    /// Holds the focus against the resign that follows Return, for the moment one can come.
+    private func keep() {
+        keeping = true
+        Task { @MainActor in
+            try? await Task.sleep(for: Self.resignWindow)
+            keeping = false
+        }
+    }
 }
 
 extension SubmitLabel {
@@ -125,19 +177,311 @@ extension SubmitLabel {
     }
 }
 
-/// `texteditor`: a multi-line controlled field.
+/// `texteditor`: a multi-line controlled field. Each edit sends `text` (a
+/// write of the text it has sends nothing, `textChange`). With `runs` it is
+/// the rich editor: on iOS 26 a `TextEditor` of the runs as an
+/// `AttributedString` (`RichTextEditorElement`), earlier the plain editor of
+/// the same text. A bound `focused` moves the focus both ways, as a field's.
 struct TextEditorElement: View {
     let node: ElementNode
     @Environment(\.nativeApp) private var app
+    @FocusState private var focused: Bool
 
     var body: some View {
-        TextEditor(text: Binding(
+        let props = TextEditorProps(props: node.props)
+        var editor = editorView(props)
+        // Backspace at the start of the text (DeleteBackward.swift).
+        if props.deleteBackward { editor = AnyView(editor.onDeleteBackward(true) { app?.dispatch(.deleteBackward(node.id)) }) }
+        if props.focused == nil { return editor }
+        return AnyView(editor
+            .focused($focused)
+            .onChange(of: props.focused) { _, wanted in
+                if let wanted, wanted != focused { focused = wanted }
+            }
+            .onChange(of: focused) { _, now in
+                if TextEditorProps(props: node.props).focused != now { app?.dispatch(.focus(node.id, now)) }
+            }
+            .onAppear { if props.focused == true { focused = true } })
+    }
+
+    private func editorView(_ props: TextEditorProps) -> AnyView {
+        #if !canImport(FoundationBridge) // not in the shim
+        if props.rich {
+            if #available(iOS 26, macOS 26, *) { return AnyView(RichTextEditorElement(node: node)) }
+        } else if props.selection != nil {
+            if #available(iOS 18, macOS 15, *) { return AnyView(PlainTextEditorElement(node: node)) }
+        }
+        #endif
+        return AnyView(TextEditor(text: Binding(
             get: { node.props.string("text") ?? "" },
-            set: { app?.dispatch(.text(node.id, $0)) }
-        ))
+            set: { if let event = textChange(of: node, to: $0) { app?.dispatch(event) } }
+        )))
     }
 }
 
+#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.
+@available(iOS 18, macOS 15, *)
+struct PlainTextEditorElement: View {
+    let node: ElementNode
+    @Environment(\.nativeApp) private var app
+    @State private var selection: TextSelection?
+    @State private var shown = Shown()
+
+    /// The selection last sent, or last moved to (a class: set while drawing).
+    final class Shown {
+        var sent: TextSelectionSpec?
+    }
+
+    var body: some View {
+        TextEditor(
+            text: Binding(
+                get: { node.props.string("text") ?? "" },
+                set: { if let event = textChange(of: node, to: $0) { app?.dispatch(event) } }
+            ),
+            selection: Binding(
+                get: { selection },
+                set: { next in
+                    selection = next
+                    guard let next, let range = offsets(of: next, in: node.props.string("text") ?? "") else { return }
+                    if range != shown.sent {
+                        shown.sent = range
+                        app?.dispatch(.selection(node.id, start: range.start, end: range.end))
+                    }
+                }
+            )
+        )
+        .onChange(of: TextEditorProps(props: node.props).selection) { _, wanted in move(to: wanted) }
+        .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 }
+        shown.sent = wanted
+        let text = node.props.string("text") ?? ""
+        let start = stringIndex(utf16: wanted.start, in: text)
+        let end = stringIndex(utf16: max(wanted.start, wanted.end), in: text)
+        selection = start == end ? TextSelection(insertionPoint: start) : TextSelection(range: start..<end)
+    }
+
+    private func offsets(of selection: TextSelection, in text: String) -> TextSelectionSpec? {
+        switch selection.indices {
+        case .selection(let range):
+            return TextSelectionSpec(start: utf16Offset(range.lowerBound, in: text), end: utf16Offset(range.upperBound, in: text))
+        case .multiSelection(let ranges):
+            guard let first = ranges.ranges.first, let last = ranges.ranges.last else { return nil }
+            return TextSelectionSpec(start: utf16Offset(first.lowerBound, in: text), end: utf16Offset(last.upperBound, in: text))
+        @unknown default:
+            return nil
+        }
+    }
+
+    private func utf16Offset(_ index: String.Index, in text: String) -> Int {
+        guard index >= text.startIndex, index <= text.endIndex else { return 0 }
+        return text.utf16.distance(from: text.utf16.startIndex, to: index)
+    }
+}
+
+/// The index `offset` UTF-16 units into `text` (its end, past it; a character's start, inside one).
+private func stringIndex(utf16 offset: Int, in text: String) -> String.Index {
+    let utf16 = text.utf16
+    let index = utf16.index(utf16.startIndex, offsetBy: min(max(0, offset), utf16.count))
+    return index.samePosition(in: text) ?? text.endIndex
+}
+
+/// The rich `texteditor` (iOS 26): the runs as an `AttributedString`, each
+/// with its weight and slant over the editor's font (or its own size and
+/// design, `font`), its lines, its color and its background color.
+/// What the viewer types goes to the app as plain `text`; the app keeps the
+/// runs (the typed text taking the attributes around it, as here). While
+/// the app's runs are the ones this editor's string stands for, the editor
+/// keeps its own string, so an edit's echo never resets the text under the
+/// caret. With `selection` bound it reports the viewer's in UTF-16 offsets,
+/// and moves the caret to one the app sets. An edit of the attributes alone
+/// (the editor's own Bold, Italic and Underline, from the edit menu) goes
+/// to the app as `runs`, the app's runs cut where the formatting changed.
+@available(iOS 26, macOS 26, *)
+struct RichTextEditorElement: View {
+    let node: ElementNode
+    @Environment(\.nativeApp) private var app
+    @Environment(\.font) private var font
+    @Environment(\.fontResolutionContext) private var fontContext
+    @State private var selection = AttributedTextSelection()
+    @State private var shown = Shown()
+
+    /// The string the editor holds, the runs it stands for, and the selection
+    /// last sent (a class: the getter brings it up to date while drawing).
+    final class Shown {
+        var runs: [TextRunSpec]?
+        var string = AttributedString()
+        var sent: TextSelectionSpec?
+    }
+
+    var body: some View {
+        TextEditor(
+            text: Binding(
+                get: { current() },
+                set: { edited in
+                    shown.string = edited
+                    let text = String(edited.characters)
+                    if let event = textChange(of: node, to: text) {
+                        app?.dispatch(event)
+                    } else if let runs = formatting(of: edited) {
+                        app?.dispatch(.runs(node.id, runs))
+                    }
+                    // The app answered (synchronously): its runs are this string's,
+                    // unless it changed the text (a newline taken elsewhere).
+                    let props = TextEditorProps(props: node.props)
+                    shown.runs = props.text == text ? props.runs : nil
+                }
+            ),
+            selection: Binding(
+                get: { selection },
+                set: { next in
+                    selection = next
+                    guard TextEditorProps(props: node.props).selection != nil else { return }
+                    let range = offsets(of: next, in: shown.string)
+                    if range != shown.sent {
+                        shown.sent = range
+                        app?.dispatch(.selection(node.id, start: range.start, end: range.end))
+                    }
+                }
+            )
+        )
+        .onChange(of: TextEditorProps(props: node.props).selection) { _, wanted in move(to: wanted) }
+        .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 }
+        shown.sent = wanted
+        let text = current()
+        let start = index(at: wanted.start, in: text)
+        let end = index(at: max(wanted.start, wanted.end), in: text)
+        selection = AttributedTextSelection(range: start..<end)
+    }
+
+    /// The index `offset` UTF-16 units into the text (its end, past it).
+    private func index(at offset: Int, in text: AttributedString) -> AttributedString.Index {
+        var index = text.startIndex
+        var count = 0
+        while index < text.endIndex, count < offset {
+            count += String(text.characters[index]).utf16.count
+            index = text.characters.index(after: index)
+        }
+        return index
+    }
+
+    private func current() -> AttributedString {
+        let runs = TextEditorProps(props: node.props).runs ?? []
+        if runs != shown.runs {
+            shown.runs = runs
+            shown.string = attributed(runs)
+        }
+        return shown.string
+    }
+
+    private func attributed(_ runs: [TextRunSpec]) -> AttributedString {
+        var string = AttributedString()
+        let base = font ?? .body
+        for run in runs {
+            var piece = AttributedString(run.text ?? "")
+            var runFont: Font?
+            let weight = run.font?.weight.map(Font.Weight.init(name:))
+            let design = run.font?.design.map(Font.Design.init(name:))
+            if let size = run.font?.size {
+                // A size of its own: a system font of it, with the run's weight and design.
+                runFont = .system(size: size, weight: weight, design: design)
+            } else if let design {
+                // A design over the editor's font: at the size the editor's resolves to.
+                runFont = .system(size: base.resolve(in: fontContext).pointSize, weight: weight, design: design)
+            } else if let weight {
+                runFont = base.weight(weight)
+            }
+            if run.italic { runFont = (runFont ?? base).italic() }
+            if let runFont { piece.font = runFont }
+            if run.underline { piece.underlineStyle = Text.LineStyle.single }
+            if run.strikethrough { piece.strikethroughStyle = Text.LineStyle.single }
+            if case .color(let color)? = run.foreground { piece.foregroundColor = Color(spec: color) }
+            if let background = run.background { piece.backgroundColor = Color(spec: background) }
+            string.append(piece)
+        }
+        return string
+    }
+
+    /// The weights the editor shows as bold (`Font.Resolved.isBold`: semibold and up).
+    private static let boldWeights: Set<String> = ["semibold", "bold", "heavy", "black"]
+
+    /// The runs `edited` stands for when its characters are the app's and
+    /// its formatting is not (the editor's own Bold, Italic or Underline):
+    /// the app's runs (their JSON, so a color, a background, a font's size
+    /// and design or a link stay as sent) cut where the editor's formatting
+    /// changes, each cut with the weight, slant and lines the editor shows.
+    /// Nil while the formatting is the app's.
+    private func formatting(of edited: AttributedString) -> [JSONValue]? {
+        guard let appRuns = node.props.array("runs") else { return nil }
+        let base = font ?? .body
+        let shows = edited.runs.map { run -> (range: Range<Int>, bold: Bool, italic: Bool, underline: Bool, strikethrough: Bool) in
+            let resolved = (run.font ?? base).resolve(in: fontContext)
+            let range = utf16Offset(run.range.lowerBound, in: edited)..<utf16Offset(run.range.upperBound, in: edited)
+            return (range, resolved.isBold, resolved.isItalic, run.underlineStyle != nil, run.strikethroughStyle != nil)
+        }
+        var out: [JSONValue] = []
+        var changed = false
+        var offset = 0
+        for json in appRuns {
+            guard let fields = json.object, let spec = TextRunSpec(json: json) else { continue }
+            let text = spec.text ?? ""
+            let range = offset..<(offset + text.utf16.count)
+            offset = range.upperBound
+            let bold = Self.boldWeights.contains(spec.font?.weight ?? "")
+            for show in shows {
+                let lower = max(show.range.lowerBound, range.lowerBound)
+                let upper = min(show.range.upperBound, range.upperBound)
+                guard lower < upper else { continue }
+                var cut = fields
+                cut["text"] = .string(String(text[stringIndex(utf16: lower - range.lowerBound, in: text)..<stringIndex(utf16: upper - range.lowerBound, in: text)]))
+                if show.bold != bold {
+                    var fontFields = fields.object("font") ?? [:]
+                    fontFields["weight"] = show.bold ? JSONValue.string("bold") : nil
+                    cut["font"] = fontFields.isEmpty ? nil : JSONValue.object(fontFields)
+                }
+                if show.italic != spec.italic { cut["italic"] = show.italic ? JSONValue.bool(true) : nil }
+                if show.underline != spec.underline { cut["underline"] = show.underline ? JSONValue.object([:]) : nil }
+                if show.strikethrough != spec.strikethrough { cut["strikethrough"] = show.strikethrough ? JSONValue.object([:]) : nil }
+                if show.bold != bold || show.italic != spec.italic || show.underline != spec.underline || show.strikethrough != spec.strikethrough {
+                    changed = true
+                }
+                out.append(.object(cut))
+            }
+        }
+        return changed ? out : nil
+    }
+
+    private func offsets(of selection: AttributedTextSelection, in text: AttributedString) -> TextSelectionSpec {
+        switch selection.indices(in: text) {
+        case .insertionPoint(let index):
+            let offset = utf16Offset(index, in: text)
+            return TextSelectionSpec(start: offset, end: offset)
+        case .ranges(let ranges):
+            guard let first = ranges.ranges.first, let last = ranges.ranges.last else { return TextSelectionSpec(start: 0, end: 0) }
+            return TextSelectionSpec(start: utf16Offset(first.lowerBound, in: text), end: utf16Offset(last.upperBound, in: text))
+        @unknown default:
+            return TextSelectionSpec(start: 0, end: 0)
+        }
+    }
+
+    private func utf16Offset(_ index: AttributedString.Index, in text: AttributedString) -> Int {
+        guard index >= text.startIndex, index <= text.endIndex else { return 0 }
+        return String(text[text.startIndex..<index].characters).utf16.count
+    }
+}
+#endif
+
 /// `picker`: the options are strings; choosing sends `select` with the index.
 struct PickerElement: View {
     let node: ElementNode
@@ -220,12 +564,14 @@ struct TapGestureElement: View {
     var body: some View {
         let props = TapGestureProps(props: node.props)
         let content = ChildrenView(node: node).contentShape(Rectangle())
+        // `count`: a double tap. SwiftUI delays a single tap attached outside
+        // (after) a double tap until the double tap can no longer land.
         if props.location {
-            content.onTapGesture(coordinateSpace: .local) { point in
+            content.onTapGesture(count: props.count, coordinateSpace: .local) { point in
                 app?.dispatch(.tap(node.id, x: point.x, y: point.y))
             }
         } else {
-            content.onTapGesture { app?.dispatch(.tap(node.id)) }
+            content.onTapGesture(count: props.count) { app?.dispatch(.tap(node.id)) }
         }
     }
 }

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

@@ -0,0 +1,147 @@
+#if canImport(SwiftUI)
+import SwiftBrowserProtocol
+import SwiftUI
+
+#if os(iOS) && !canImport(FoundationBridge)
+import ObjectiveC
+import UIKit
+
+/// `deleteBackward` on a `textfield` or `texteditor`: Backspace with nothing
+/// selected and the caret at the start sends `deletebackward` and deletes
+/// nothing (docs/ops-protocol.md, "The delete key at the start of a field").
+///
+/// SwiftUI gives no hook for it: `.onKeyPress(.delete)` hears hardware
+/// keyboards only, and the binding is not written when the text does not
+/// change. The software keyboard (and a hardware Backspace, which UIKit
+/// routes the same way) calls `UIKeyInput.deleteBackward()` on the text
+/// view or text field behind SwiftUI's editor. So the editor carries a
+/// `DeleteBackwardFinder` as its background: a `UIViewRepresentable` that,
+/// once in a window, finds the nearest `UITextView` or `UITextField` beside
+/// it in UIKit's hierarchy (up to six ancestors up, their subtrees down) and
+/// marks it with the handler. `deleteBackward()` is swizzled once per class
+/// (`UITextView`, `UITextField`): a marked input with an empty selection at
+/// offset 0 runs the handler instead; everything else goes to UIKit's own.
+///
+/// Limits: it relies on SwiftUI's fields staying UIKit-backed and on the
+/// nearest text input being the editor's own (an editor's background is
+/// nearer to it than to any other field); a private subclass that
+/// overrides `deleteBackward()` without calling super would not be heard.
+/// macOS (`NSTextView`) is not covered: the modifier is a no-op there.
+extension View {
+    func onDeleteBackward(_ enabled: Bool, perform action: @escaping () -> Void) -> some View {
+        background {
+            if enabled { DeleteBackwardFinder(action: action) }
+        }
+    }
+}
+
+struct DeleteBackwardFinder: UIViewRepresentable {
+    let action: () -> Void
+
+    func makeUIView(context: Context) -> FinderView {
+        let view = FinderView()
+        view.isUserInteractionEnabled = false
+        return view
+    }
+
+    func updateUIView(_ view: FinderView, context: Context) {
+        view.action = action
+        view.attach()
+    }
+
+    final class FinderView: UIView {
+        var action: (() -> Void)?
+        /// The text input marked, while it is on screen.
+        private(set) weak var attached: UIView?
+
+        override func didMoveToWindow() {
+            super.didMoveToWindow()
+            attach()
+            // The text input may join the hierarchy after its background does.
+            DispatchQueue.main.async { [weak self] in self?.attach() }
+        }
+
+        func attach() {
+            guard window != nil, let action else { return }
+            if let attached, attached.window != nil {
+                DeleteBackwardHook.set(action, on: attached)
+                return
+            }
+            guard let input = nearestTextInput() else { return }
+            attached = input
+            DeleteBackwardHook.set(action, on: input)
+        }
+
+        private func nearestTextInput() -> UIView? {
+            var ancestor = superview
+            for _ in 0..<6 {
+                guard let candidate = ancestor else { return nil }
+                if let found = Self.textInput(in: candidate, skipping: self) { return found }
+                ancestor = candidate.superview
+            }
+            return nil
+        }
+
+        private static func textInput(in view: UIView, skipping: UIView) -> UIView? {
+            for subview in view.subviews where subview !== skipping {
+                if subview is UITextView || subview is UITextField { return subview }
+                if let found = textInput(in: subview, skipping: skipping) { return found }
+            }
+            return nil
+        }
+    }
+}
+
+/// The handler a text input carries, and the swizzle that runs it.
+@MainActor
+enum DeleteBackwardHook {
+    private final class Handler {
+        let action: () -> Void
+        init(_ action: @escaping () -> Void) { self.action = action }
+    }
+
+    private static var handlerKey = 0
+    private static var swizzled: Set<ObjectIdentifier> = []
+
+    static func set(_ action: @escaping () -> Void, on view: UIView) {
+        objc_setAssociatedObject(view, &handlerKey, Handler(action), .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+        let cls: AnyClass = view is UITextView ? UITextView.self : UITextField.self
+        swizzle(cls)
+    }
+
+    static func handler(of view: UIView) -> (() -> Void)? {
+        (objc_getAssociatedObject(view, &handlerKey) as? Handler)?.action
+    }
+
+    /// Whether the input's selection is empty and at the start of its text.
+    static func isAtStart(_ input: UITextInput) -> Bool {
+        guard let range = input.selectedTextRange, range.isEmpty else { return false }
+        return input.offset(from: input.beginningOfDocument, to: range.start) == 0
+    }
+
+    private static func swizzle(_ cls: AnyClass) {
+        guard swizzled.insert(ObjectIdentifier(cls)).inserted else { return }
+        let selector = #selector(UIKeyInput.deleteBackward)
+        guard let method = class_getInstanceMethod(cls, selector) else { return }
+        typealias Original = @convention(c) (AnyObject, Selector) -> Void
+        let original = unsafeBitCast(method_getImplementation(method), to: Original.self)
+        let replacement: @convention(block) (AnyObject) -> Void = { object in
+            let handled = MainActor.assumeIsolated { () -> Bool in
+                guard let view = object as? UIView, let input = object as? UITextInput, let action = handler(of: view), isAtStart(input) else { return false }
+                action()
+                return true
+            }
+            if !handled { original(object, selector) }
+        }
+        method_setImplementation(method, imp_implementationWithBlock(replacement))
+    }
+}
+#else
+extension View {
+    /// `deleteBackward` is heard on iOS only (DeleteBackward.swift); elsewhere the key deletes as it does.
+    func onDeleteBackward(_ enabled: Bool, perform action: @escaping () -> Void) -> some View {
+        self
+    }
+}
+#endif
+#endif