@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/SwiftUI/API/Text.swift

@@ -0,0 +1,386 @@
+// `Text`: a string, or styled runs of strings and images.
+//
+// A `Text` is a list of segments, each with its own style. `Text + Text`
+// joins segments; the modifiers that return `Text` (`bold()`, `italic()`,
+// `font(_:)`, `foregroundColor(_:)`, `strikethrough()`, `underline()`,
+// `kerning(_:)`, `baselineOffset(_:)`…) style every segment, and the style a
+// segment already has wins (as in SwiftUI, an inner modifier overrides an
+// outer one). An image interpolated into a `LocalizedStringKey`
+// (`Text("\(Image(systemName: "star")) Favorites")`) is a segment of its own.
+//
+// What reaches the page depends on what the text needs:
+//
+// - A single string styled only by `font`, `fontWeight`, `bold` and the
+//   foreground is the `text` element it always was, inside the same `styled`
+//   elements the View modifiers make (so existing apps render unchanged).
+// - Anything else (several segments, images, links, italic, strikethrough,
+//   underline, kerning, baseline offsets) is one `text` element whose `runs`
+//   prop lists each segment with its style; the page lays the runs out as one
+//   paragraph (docs/ops-protocol.md, "Rich text").
+//
+// A run with a link sends a `link` event when tapped; the environment's link
+// handler opens it (FoundationBridge's `openURL` sets it).
+
+import Foundation
+
+public struct Text: Equatable, Sendable {
+    /// The whole text as a string (images contribute nothing).
+    let content: String
+    let segments: [_TextSegment]
+    /// The modifiers applied to the whole text, in order, while it is one
+    /// plain string: they become the View modifiers they always were.
+    let applied: [_TextModifier]
+
+    init(segments: [_TextSegment], applied: [_TextModifier] = []) {
+        self.segments = segments
+        self.applied = applied
+        content = segments.map { if case .string(let s) = $0.content { s } else { "" } }.joined()
+    }
+
+    public init(verbatim content: String) {
+        self.init(segments: [_TextSegment(content: .string(content))])
+    }
+
+    public init(_ key: LocalizedStringKey) {
+        self.init(segments: key.segments)
+    }
+
+    /// A key from a table other than `Localizable`, or another bundle's
+    /// (FoundationBridge's `Text(_:tableName:bundle:comment:)` passes its path).
+    public init(_ key: LocalizedStringKey, _table table: String?, bundlePath: String?) {
+        self.init(segments: key._segments(table: table, bundlePath: bundlePath))
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ content: S) {
+        self.init(verbatim: String(content))
+    }
+
+    /// `Text(price, format: .currency(code: "USD"))`, `Text(date, format: .dateTime.year())`.
+    public init<F: FormatStyle>(_ input: F.FormatInput, format: F) where F.FormatOutput == String {
+        self.init(verbatim: format.format(input))
+    }
+
+    /// An image inline in text (`Text(Image(systemName: "star"))`).
+    public init(_ image: Image) {
+        self.init(segments: [_TextSegment(content: .image(image))])
+    }
+
+    /// The text as a string, for bridge modules (a `prompt` becomes a placeholder).
+    public var _content: String { content }
+
+    public static func + (lhs: Text, rhs: Text) -> Text {
+        Text(segments: lhs.segments + rhs.segments)
+    }
+
+    /// Whether the page gets the plain `text` element the shim has always made.
+    var isPlain: Bool {
+        guard segments.count == 1, case .string = segments[0].content else { return false }
+        return applied.allSatisfy(\.isLegacy) && segments[0].style.isLegacyOnly
+    }
+
+    /// Applies `modifier` to every segment where it is not set yet.
+    func modified(_ modifier: _TextModifier) -> Text {
+        Text(segments: segments.map { segment in
+            var segment = segment
+            modifier.apply(to: &segment.style)
+            return segment
+        }, applied: applied + [modifier])
+    }
+
+    // MARK: Styling
+
+    public func font(_ font: Font?) -> Text { modified(.font(font)) }
+    public func fontWeight(_ weight: Font.Weight?) -> Text { modified(.weight(weight)) }
+    public func bold() -> Text { modified(.weight(.bold)) }
+    public func bold(_ isActive: Bool) -> Text { isActive ? bold() : self }
+    public func italic() -> Text { modified(.italic) }
+    public func italic(_ isActive: Bool) -> Text { isActive ? italic() : self }
+    public func monospaced(_ isActive: Bool = true) -> Text { isActive ? modified(.monospaced) : self }
+    public func monospacedDigit() -> Text { self }
+    public func fontDesign(_ design: Font.Design?) -> Text { design == .monospaced ? modified(.monospaced) : self }
+    public func fontWidth(_ width: Font.Width?) -> Text { self }
+    public func foregroundColor(_ color: Color?) -> Text { modified(.foreground(color?._json)) }
+    public func foregroundStyle<S: ShapeStyle>(_ style: S) -> Text { modified(.foreground(style._json)) }
+    public func strikethrough(_ isActive: Bool = true, color: Color? = nil) -> Text {
+        isActive ? modified(.strikethrough(color?._json ?? .null)) : self
+    }
+    public func strikethrough(_ isActive: Bool = true, pattern: Text.LineStyle.Pattern, color: Color? = nil) -> Text {
+        strikethrough(isActive, color: color)
+    }
+    public func underline(_ isActive: Bool = true, color: Color? = nil) -> Text {
+        isActive ? modified(.underline(color?._json ?? .null)) : self
+    }
+    public func underline(_ isActive: Bool = true, pattern: Text.LineStyle.Pattern, color: Color? = nil) -> Text {
+        underline(isActive, color: color)
+    }
+    public func kerning(_ kerning: CGFloat) -> Text { modified(.kerning(kerning)) }
+    public func tracking(_ tracking: CGFloat) -> Text { modified(.kerning(tracking)) }
+    public func baselineOffset(_ offset: CGFloat) -> Text { modified(.baselineOffset(offset)) }
+    public func textScale(_ scale: Text.Scale, isEnabled: Bool = true) -> Text { self }
+    public func speechSpellsOutCharacters(_ value: Bool = true) -> Text { self }
+    public func accessibilityLabel(_ label: Text) -> Text { self }
+    @_disfavoredOverload
+    public func accessibilityLabel<S: StringProtocol>(_ label: S) -> Text { self }
+    public func accessibilityLabel(_ labelKey: LocalizedStringKey) -> Text { self }
+
+    /// The segments open `url` when tapped (Foundation's `Text(AttributedString)` uses it).
+    public func _link(_ url: String) -> Text { modified(.link(url)) }
+
+    public struct LineStyle: Hashable, Sendable {
+        public struct Pattern: Hashable, Sendable {
+            let name: String
+            public static let solid = Pattern(name: "solid")
+            public static let dot = Pattern(name: "dot")
+            public static let dash = Pattern(name: "dash")
+            public static let dashDot = Pattern(name: "dashDot")
+            public static let dashDotDot = Pattern(name: "dashDotDot")
+        }
+        public init(pattern: Pattern = .solid, color: Color? = nil) {}
+        public static let single = LineStyle()
+    }
+
+    public enum Scale: Hashable, Sendable { case `default`, secondary }
+
+    public enum Case: Hashable, Sendable { case uppercase, lowercase }
+
+    public enum TruncationMode: Hashable, Sendable { case head, tail, middle }
+}
+
+extension Font {
+    public struct Width: Hashable, Sendable {
+        let value: CGFloat
+        public init(_ value: CGFloat) { self.value = value }
+        public static let compressed = Width(-0.3)
+        public static let condensed = Width(-0.2)
+        public static let standard = Width(0)
+        public static let expanded = Width(0.2)
+    }
+}
+
+/// One stretch of a `Text`: a string or an image, with its style.
+struct _TextSegment: Equatable, Sendable {
+    enum Content: Equatable, Sendable {
+        case string(String)
+        case image(Image)
+    }
+
+    var content: Content
+    var style = _TextStyle()
+}
+
+/// The style of a segment; nil fields are unset (an outer modifier may set them).
+struct _TextStyle: Equatable, Sendable {
+    var font: Font?
+    var weight: Font.Weight?
+    var italic = false
+    var monospaced = false
+    var foreground: _JSON?
+    /// The line's color, `.null` for the text's own.
+    var strikethrough: _JSON?
+    var underline: _JSON?
+    var kerning: CGFloat?
+    var baselineOffset: CGFloat?
+    var link: String?
+
+    /// Only what the View modifiers express (font, weight, foreground).
+    var isLegacyOnly: Bool {
+        !italic && !monospaced && strikethrough == nil && underline == nil && kerning == nil && baselineOffset == nil && link == nil
+    }
+
+    /// The run's style as the page reads it.
+    var json: [String: _JSON] {
+        var object: [String: _JSON] = [:]
+        if font != nil || weight != nil || monospaced {
+            var resolved = font ?? Font(size: nil, weight: nil, design: nil)
+            if let weight { resolved.weight = weight }
+            if monospaced { resolved.design = .monospaced }
+            object["font"] = resolved._json
+        }
+        if italic { object["italic"] = .bool(true) }
+        if let foreground { object["foreground"] = foreground }
+        if let strikethrough { object["strikethrough"] = .object(strikethrough == .null ? [:] : ["color": strikethrough]) }
+        if let underline { object["underline"] = .object(underline == .null ? [:] : ["color": underline]) }
+        if let kerning { object["kerning"] = .number(kerning) }
+        if let baselineOffset { object["baselineOffset"] = .number(baselineOffset) }
+        if let link { object["link"] = .string(link) }
+        return object
+    }
+}
+
+/// A modifier that returns `Text`, kept to style later segments and, for a
+/// plain text, to become the View modifier it always was.
+enum _TextModifier: Equatable, Sendable {
+    case font(Font?)
+    case weight(Font.Weight?)
+    case italic
+    case monospaced
+    case foreground(_JSON?)
+    case strikethrough(_JSON)
+    case underline(_JSON)
+    case kerning(CGFloat)
+    case baselineOffset(CGFloat)
+    case link(String)
+
+    var isLegacy: Bool {
+        switch self {
+        case .font, .weight, .foreground: true
+        default: false
+        }
+    }
+
+    func apply(to style: inout _TextStyle) {
+        switch self {
+        case .font(let font): if style.font == nil { style.font = font }
+        case .weight(let weight): if style.weight == nil { style.weight = weight }
+        case .italic: style.italic = true
+        case .monospaced: style.monospaced = true
+        case .foreground(let paint): if style.foreground == nil { style.foreground = paint }
+        case .strikethrough(let color): if style.strikethrough == nil { style.strikethrough = color }
+        case .underline(let color): if style.underline == nil { style.underline = color }
+        case .kerning(let value): if style.kerning == nil { style.kerning = value }
+        case .baselineOffset(let value): if style.baselineOffset == nil { style.baselineOffset = value }
+        case .link(let url): if style.link == nil { style.link = url }
+        }
+    }
+}
+
+extension Text: _PrimitiveView {}
+extension Text: _GroupView {
+    var _children: [any View] {
+        guard isPlain, case .string(let string) = segments[0].content else { return [_RichText(text: self)] }
+        var view: any View = _PlainText(content: string)
+        for modifier in applied {
+            switch modifier {
+            case .font(let font): view = _restyle(view) { $0.font = font }
+            case .weight(let weight): view = _restyle(view) { $0.font = weight.map { Font(size: nil, weight: $0, design: nil) } }
+            case .foreground(let paint): view = _restyle(view) { $0.foreground = paint.map(_JSONShapeStyle.init) }
+            default: break
+            }
+        }
+        return [view]
+    }
+}
+
+/// `view` in a `styled` element, as the View modifiers wrap it.
+private func _restyle(_ view: any View, _ change: (inout _Style) -> Void) -> any View {
+    var style = _Style()
+    change(&style)
+    func open<V: View>(_ view: V) -> any View { _StyledGroup(content: view, style: style) }
+    return open(view)
+}
+
+/// A paint the page already has as JSON (a `Text`'s foreground).
+struct _JSONShapeStyle: ShapeStyle {
+    let json: _JSON
+    init(_ json: _JSON) { self.json = json }
+    var _json: _JSON { json }
+}
+
+/// The page's `text` element for a plain string.
+struct _PlainText: Equatable, Sendable {
+    let content: String
+}
+extension _PlainText: _PrimitiveView {}
+extension _PlainText: _HostView {
+    var _kind: String { "text" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object(["text": .string(environment.textCase?.apply(to: content) ?? content)])
+    }
+}
+
+/// The page's `text` element with runs.
+struct _RichText: Equatable, Sendable {
+    let text: Text
+
+    var hasLinks: Bool { text.segments.contains { $0.style.link != nil } }
+
+    /// Sends inline bitmaps' sources to the page before the element.
+    @MainActor func _sendBitmapSources(through runtime: _Runtime) {
+        for segment in text.segments {
+            if case .image(let image) = segment.content { image._sendBitmapSource(through: runtime) }
+        }
+    }
+}
+extension _RichText: _PrimitiveView {}
+extension _RichText: _HostView {
+    var _kind: String { "text" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        let runs: [_JSON] = text.segments.map { segment in
+            var run = segment.style.json
+            switch segment.content {
+            case .string(let string): run["text"] = .string(environment.textCase?.apply(to: string) ?? string)
+            case .image(let image): run["image"] = image._props(in: environment)
+            }
+            return .object(run)
+        }
+        let content = environment.textCase?.apply(to: text.content) ?? text.content
+        return .object(["text": .string(content), "runs": .array(runs)])
+    }
+}
+extension _RichText: _EnvironmentHandling {
+    /// A tap on a link run: the page sends its URL.
+    func _handler(in environment: EnvironmentValues) -> ((_JSON) -> Void)? {
+        guard hasLinks else { return nil }
+        let open = environment._openLink
+        return { payload in
+            guard case .string(let url) = payload else { return }
+            MainActor.assumeIsolated { (open ?? _Runtime.shared._openLinkOnPage)(url) }
+        }
+    }
+}
+
+// MARK: - Interpolated text
+
+extension LocalizedStringKey {
+    /// The localized text as segments: its strings, and the images and texts
+    /// interpolated into it, where the localized format puts them.
+    var segments: [_TextSegment] { _segments(table: nil, bundlePath: nil) }
+
+    func _segments(table: String?, bundlePath: String?) -> [_TextSegment] {
+        var out: [_TextSegment] = []
+        for piece in _pieces(table: table, bundlePath: bundlePath) {
+            switch piece {
+            case .text(let string):
+                if case .string(let previous)? = out.last?.content, out.last?.style == _TextStyle() {
+                    out[out.count - 1].content = .string(previous + string)
+                } else {
+                    out.append(_TextSegment(content: .string(string)))
+                }
+            case .argument(let index):
+                guard index < arguments.count else { continue }
+                switch arguments[index] {
+                case .image(let image): out.append(_TextSegment(content: .image(image)))
+                case .text(let text): out += text.segments
+                case .value: continue
+                }
+            }
+        }
+        if out.isEmpty { out.append(_TextSegment(content: .string(""))) }
+        return out
+    }
+}
+
+// MARK: - Links
+
+private struct _OpenLinkKey: EnvironmentKey {
+    static var defaultValue: (@MainActor @Sendable (String) -> Void)? { nil }
+}
+
+extension EnvironmentValues {
+    /// What a tap on a link in a `Text` calls; FoundationBridge's `openURL`
+    /// sets it. Without one, the page opens the link.
+    public var _openLink: (@MainActor @Sendable (String) -> Void)? {
+        get { self[_OpenLinkKey.self] }
+        set { self[_OpenLinkKey.self] = newValue }
+    }
+}
+
+extension _Runtime {
+    /// Asks the page to open `url` (in a new tab; headless runs log the request).
+    public func _openLinkOnPage(_ url: String) {
+        Task { @MainActor in
+            _ = try? await _hostRequest(kind: "openURL", params: .object(["url": .string(url)]))
+        }
+    }
+}

package/Sources/SwiftUI/API/TextDates.swift

@@ -0,0 +1,61 @@
+import Foundation
+
+// `Text(date, style:)` and `Text(range)` / `Text(interval)`. The date is
+// formatted when the view's body runs, in the viewer's locale, and the text
+// does not update by itself afterwards (on iOS `.relative`, `.offset` and
+// `.timer` count live): an approximation that is exact for `.date` and
+// `.time`, and right until the next render for the others.
+
+extension Text {
+    public struct DateStyle: Hashable, Sendable {
+        let name: String
+        /// "June 3, 2024".
+        public static let date = DateStyle(name: "date")
+        /// "3:04 PM".
+        public static let time = DateStyle(name: "time")
+        /// "2 hr, 5 min" (from now, either direction).
+        public static let relative = DateStyle(name: "relative")
+        /// "+2 hr, 5 min" / "-2 hr, 5 min".
+        public static let offset = DateStyle(name: "offset")
+        /// "2:05:00", the time from or since the date.
+        public static let timer = DateStyle(name: "timer")
+    }
+
+    public init(_ date: Date, style: DateStyle) {
+        self.init(verbatim: Text._format(date, style: style, now: Date()))
+    }
+
+    public init(_ dates: ClosedRange<Date>) {
+        let format = Date.FormatStyle(date: .abbreviated, time: .shortened)
+        self.init(verbatim: "\(dates.lowerBound.formatted(format)) – \(dates.upperBound.formatted(format))")
+    }
+
+    public init(_ interval: DateInterval) {
+        self.init(interval.start...interval.end)
+    }
+
+    static func _format(_ date: Date, style: DateStyle, now: Date) -> String {
+        switch style.name {
+        case "date":
+            return date.formatted(date: .long, time: .omitted)
+        case "time":
+            return date.formatted(date: .omitted, time: .shortened)
+        case "relative", "offset":
+            let seconds = Int(abs(date.timeIntervalSince(now)).rounded())
+            let hours = seconds / 3600, minutes = seconds % 3600 / 60, rest = seconds % 60
+            var parts: [String] = []
+            if hours > 0 { parts.append("\(hours) hr") }
+            if minutes > 0 { parts.append("\(minutes) min") }
+            if hours == 0 && (rest > 0 || parts.isEmpty) { parts.append("\(rest) sec") }
+            let amount = parts.prefix(2).joined(separator: ", ")
+            if style.name == "relative" { return amount }
+            return (date >= now ? "+" : "-") + amount
+        default:
+            let seconds = Int(abs(date.timeIntervalSince(now)))
+            let hours = seconds / 3600, minutes = seconds % 3600 / 60, rest = seconds % 60
+            let mm = minutes < 10 && hours > 0 ? "0\(minutes)" : "\(minutes)"
+            let ss = rest < 10 ? "0\(rest)" : "\(rest)"
+            return hours > 0 ? "\(hours):\(mm):\(ss)" : "\(mm):\(ss)"
+        }
+    }
+}

package/Sources/SwiftUI/API/TextDecorations.swift

@@ -0,0 +1,52 @@
+/// Text modifiers on any view (iOS 16): `.underline()`, `.strikethrough()`
+/// and `.italic()` style every text inside. Each is a style key of a `styled`
+/// box (`underline`, `strikethrough`, `italic`: true, or false to turn it off
+/// below an ancestor that set it), which the page passes down to the texts
+/// below through inherited CSS (Web/src/renderer.ts `applyStyle`). The line
+/// takes the text's color: `pattern` and `color` are not drawn. Italic text is
+/// measured upright.
+///
+/// `.fontDesign` and `.monospaced` set the design of the fonts inside, as
+/// `.fontWeight` sets their weight. `.monospacedDigit`, `.fontWidth`,
+/// `.minimumScaleFactor` and `.allowsTightening` are accepted: digits keep the
+/// font's own widths, and the page wraps or truncates text at its size
+/// instead of shrinking it.
+
+nonisolated extension View {
+    /// Underlines the texts inside.
+    public func underline(_ isActive: Bool = true, pattern: Text.LineStyle.Pattern = .solid, color: Color? = nil) -> some View {
+        _styled { $0.extras["underline"] = .bool(isActive) }
+    }
+
+    /// Strikes the texts inside through.
+    public func strikethrough(_ isActive: Bool = true, pattern: Text.LineStyle.Pattern = .solid, color: Color? = nil) -> some View {
+        _styled { $0.extras["strikethrough"] = .bool(isActive) }
+    }
+
+    /// Slants the texts inside.
+    public func italic(_ isActive: Bool = true) -> some View {
+        _styled { $0.extras["italic"] = .bool(isActive) }
+    }
+
+    /// The design of the fonts inside (nil leaves it as it is).
+    public func fontDesign(_ design: Font.Design?) -> some View {
+        _styled { $0.font = design.map { Font(size: nil, weight: nil, design: $0) } }
+    }
+
+    /// Monospaced fonts inside.
+    public func monospaced(_ isActive: Bool = true) -> some View {
+        _styled { $0.font = isActive ? Font(size: nil, weight: nil, design: .monospaced) : nil }
+    }
+
+    /// Accepted: digits keep their proportional widths.
+    public func monospacedDigit() -> some View { self }
+
+    /// Accepted: the page has one width of each font.
+    public func fontWidth(_ width: Font.Width?) -> some View { self }
+
+    /// Accepted: text is not shrunk to fit.
+    public func minimumScaleFactor(_ factor: CGFloat) -> some View { self }
+
+    /// Accepted: letter spacing is not tightened to fit.
+    public func allowsTightening(_ flag: Bool) -> some View { self }
+}

package/Sources/SwiftUI/API/TextFieldAxis.swift

@@ -0,0 +1,103 @@
+// Multi-line text fields (`TextField(_:text:axis: .vertical)`), line-limit
+// ranges, and `.textCase(_:)`.
+//
+// A vertical field is the `textfield` element with `"axis": "vertical"`:
+// the page draws a `<textarea>` that grows with its text from the lower
+// bound of the enclosing line-limit range to its upper bound (one line to
+// unlimited by default) and scrolls inside past that. Typing sends `text`
+// events as for a one-line field; Return inserts a line break, except in a
+// field with `.onSubmit`, where Return submits and Shift-Return breaks the
+// line (iOS has no Shift, and submits).
+//
+// `.lineLimit(2...4)` / `.lineLimit(...4)` / `.lineLimit(2...)` set the
+// style's `lineLimit` to the upper bound (null for none) and, when the lower
+// bound is above one, `lineLimitMin`. Text takes the lines it needs up to the
+// upper bound (as with `reservesSpace`, the lower bound reserves nothing for
+// text); a vertical field is at least `lineLimitMin` lines tall.
+
+extension TextField where Label == Text {
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, text: Binding<String>, axis: Axis) {
+        self.init(placeholder: String(title), text: text, secure: false)
+        self.axis = axis
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, text: Binding<String>, prompt: Text?, axis: Axis) {
+        self.init(placeholder: prompt?.content ?? String(title), text: text, secure: false)
+        self.axis = axis
+    }
+
+    public init(_ titleKey: LocalizedStringKey, text: Binding<String>, axis: Axis) {
+        self.init(placeholder: titleKey.key, text: text, secure: false)
+        self.axis = axis
+    }
+
+    public init(_ titleKey: LocalizedStringKey, text: Binding<String>, prompt: Text?, axis: Axis) {
+        self.init(placeholder: prompt?.content ?? titleKey.key, text: text, secure: false)
+        self.axis = axis
+    }
+}
+
+extension TextField {
+    /// A field labelled by a view: the prompt (or else the label's text) is the placeholder.
+    @MainActor
+    public init(text: Binding<String>, prompt: Text? = nil, axis: Axis, @ViewBuilder label: () -> Label) {
+        self.init(placeholder: prompt?.content ?? _textContent(of: label()), text: text, secure: false)
+        self.axis = axis
+    }
+}
+
+nonisolated extension View {
+    /// Text takes up to `limit.upperBound` lines; a vertical text field is
+    /// `limit.lowerBound` to `limit.upperBound` lines tall.
+    public func lineLimit(_ limit: ClosedRange<Int>) -> some View {
+        _lineLimit(min: limit.lowerBound, max: limit.upperBound)
+    }
+
+    public func lineLimit(_ limit: PartialRangeThrough<Int>) -> some View {
+        _lineLimit(min: 1, max: limit.upperBound)
+    }
+
+    public func lineLimit(_ limit: PartialRangeFrom<Int>) -> some View {
+        _lineLimit(min: limit.lowerBound, max: nil)
+    }
+
+    func _lineLimit(min: Int, max: Int?) -> some View {
+        _styled { style in
+            style.lineLimit = max ?? -1
+            if min > 1 { style.extras["lineLimitMin"] = .number(Double(min)) }
+        }
+    }
+}
+
+// MARK: - textCase
+
+enum _TextCaseKey: EnvironmentKey { static let defaultValue: Text.Case? = nil }
+
+extension EnvironmentValues {
+    /// `.textCase(_:)`: texts below are upper- or lower-cased when emitted
+    /// (so the page measures and draws the cased string); nil leaves them.
+    public var textCase: Text.Case? {
+        get { self[_TextCaseKey.self] }
+        set { self[_TextCaseKey.self] = newValue }
+    }
+}
+
+nonisolated extension View {
+    /// Upper- or lower-cases the texts in this view (`nil`: as written, which
+    /// also undoes the upper case of a list section header).
+    public func textCase(_ textCase: Text.Case?) -> some View {
+        environment(\.textCase, textCase)
+    }
+}
+
+extension Text.Case {
+    /// `string` in this case.
+    func apply(to string: String) -> String {
+        switch self {
+        case .uppercase: string.uppercased()
+        case .lowercase: string.lowercased()
+        }
+    }
+}

package/Sources/SwiftUI/API/TextFieldCommit.swift

@@ -0,0 +1,52 @@
+/// iOS 13's text field initializers with `onEditingChanged:` and `onCommit:`.
+/// `onCommit` runs when the viewer presses Return, as `.onSubmit` does (the
+/// field asks the page for submit events). `onEditingChanged` is accepted and
+/// not called: use `.focused` to follow editing.
+extension TextField where Label == Text {
+    public init(_ titleKey: LocalizedStringKey, text: Binding<String>,
+                onEditingChanged: @escaping (Bool) -> Void = { _ in }, onCommit: @escaping () -> Void) {
+        self.init(placeholder: titleKey.key, text: text, secure: false)
+        self.onCommit = onCommit
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, text: Binding<String>,
+                                   onEditingChanged: @escaping (Bool) -> Void = { _ in }, onCommit: @escaping () -> Void) {
+        self.init(placeholder: String(title), text: text, secure: false)
+        self.onCommit = onCommit
+    }
+}
+
+extension Menu where Label == Text {
+    /// A menu titled with a localized key (the key's text: no string tables are loaded).
+    public init(_ titleKey: LocalizedStringKey, @ViewBuilder content: () -> Content) {
+        self.init(content: content) { Text(titleKey) }
+    }
+}
+
+extension Menu where Label == SwiftUI.Label<Text, Image> {
+    public init(_ titleKey: LocalizedStringKey, systemImage: String, @ViewBuilder content: () -> Content) {
+        self.init(content: content) { SwiftUI.Label(titleKey, systemImage: systemImage) }
+    }
+}
+
+nonisolated extension View {
+    /// Search with a binding to whether the field is active. The page's
+    /// search field is always shown: `isPresented` is not changed by the
+    /// viewer (approximation).
+    public func searchable(text: Binding<String>, isPresented: Binding<Bool>, placement: SearchFieldPlacement = .automatic,
+                           prompt: Text? = nil) -> some View {
+        searchable(text: text, placement: placement, prompt: prompt)
+    }
+
+    public func searchable(text: Binding<String>, isPresented: Binding<Bool>, placement: SearchFieldPlacement = .automatic,
+                           prompt: LocalizedStringKey) -> some View {
+        searchable(text: text, placement: placement, prompt: prompt)
+    }
+
+    @_disfavoredOverload
+    public func searchable<S: StringProtocol>(text: Binding<String>, isPresented: Binding<Bool>,
+                                              placement: SearchFieldPlacement = .automatic, prompt: S) -> some View {
+        searchable(text: text, placement: placement, prompt: prompt)
+    }
+}