@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/SwiftUI/API/Primitives.swift

@@ -1,42 +1,99 @@
+import Foundation
+
 // MARK: - Text
 
-/// A localization key. Without localization tables the key is the text;
-/// interpolations are rendered into it.
+/// A localization key, as Xcode writes it in a string catalog: the literal
+/// text with a specifier for each interpolation (`"\(count) posts"` is the
+/// key `"%lld posts"` with the argument `count`), looked up in the app's string
+/// tables when shown (Localization/Localization.swift). A key the tables lack
+/// is its own text.
 public struct LocalizedStringKey: Equatable, Sendable, ExpressibleByStringInterpolation {
-    public let key: String
+    /// The key, with `%%` for a literal percent sign when it has arguments.
+    let formatKey: String
+    let arguments: [Argument]
+
+    /// An interpolated value: one a specifier formats, or a view in the text.
+    enum Argument: Equatable, Sendable {
+        case value(_LocalizationArgument)
+        case image(Image)
+        case text(Text)
+
+        var formatted: _LocalizationArgument? {
+            if case .value(let value) = self { return value }
+            return nil
+        }
+    }
 
-    public init(_ value: String) { key = value }
-    public init(stringLiteral value: String) { key = value }
-    public init(stringInterpolation: StringInterpolation) { key = stringInterpolation.text }
+    public init(_ value: String) { formatKey = value; arguments = [] }
+    public init(stringLiteral value: String) { formatKey = value; arguments = [] }
+    public init(stringInterpolation: StringInterpolation) {
+        formatKey = stringInterpolation.key
+        arguments = stringInterpolation.arguments
+    }
+
+    /// The localized text, views left out: what titles, labels and placeholders show.
+    public var key: String { _resolved(table: nil, bundlePath: nil) }
 
+    /// The localized text from `table` in the bundle at `bundlePath` (the main bundle when nil).
+    public func _resolved(table: String?, bundlePath: String?) -> String {
+        _Localization.string(key: formatKey, arguments: arguments.map(\.formatted), table: table, bundlePath: bundlePath)
+    }
+
+    /// The localized pieces, with the views in their places.
+    func _pieces(table: String?, bundlePath: String?) -> [_LocalizedPiece] {
+        _Localization.resolve(key: formatKey, arguments: arguments.map(\.formatted), table: table, bundlePath: bundlePath)
+    }
+
+    /// Builds the key as SwiftUI does: each interpolation adds the specifier of
+    /// its type (`%@` for strings and views, `%lld` for `Int`, `%lf` for
+    /// `Double`…) and an argument; literal percent signs are doubled.
     public struct StringInterpolation: StringInterpolationProtocol {
-        var text = ""
+        var key = ""
+        var arguments: [Argument] = []
         public init(literalCapacity: Int, interpolationCount: Int) {}
-        public mutating func appendLiteral(_ literal: String) { text += literal }
-        public mutating func appendInterpolation<T>(_ value: T) { text += String(describing: value) }
-        public mutating func appendInterpolation<T>(_ value: T, specifier: String) { text += String(describing: value) }
-    }
-}
 
-public struct Text: Equatable, Sendable {
-    let content: String
+        public mutating func appendLiteral(_ literal: String) {
+            key += literal.replacingOccurrences(of: "%", with: "%%")
+        }
 
-    public init(verbatim content: String) { self.content = content }
-    public init(_ key: LocalizedStringKey) { self.content = key.key }
-    @_disfavoredOverload
-    public init<S: StringProtocol>(_ content: S) { self.content = String(content) }
+        /// An argument with its specifier: for the shim's own interpolations (a date with a style).
+        public mutating func _append(_ argument: _LocalizationArgument, specifier: String) {
+            key += specifier
+            arguments.append(.value(argument))
+        }
 
-    /// A value formatted by `format` (`FoundationLite` supplies the formats;
-    /// FoundationBridge adds Foundation's `FormatStyle`).
-    public init<F: _TextFormat>(_ input: F.Input, format: F) { content = format._formatText(input) }
+        /// A string the shim made (a formatted value): `%@`.
+        mutating func append(_ string: String) { _append(.string(string), specifier: "%@") }
 
-    /// The text as a string, for bridge modules (a `prompt` becomes a placeholder).
-    public var _content: String { content }
-}
-extension Text: _PrimitiveView {}
-extension Text: _HostView {
-    var _kind: String { "text" }
-    func _props(in environment: EnvironmentValues) -> _JSON { .object(["text": .string(content)]) }
+        public mutating func appendInterpolation(_ string: String) { append(string) }
+        public mutating func appendInterpolation<T>(_ value: T) { append(String(describing: value)) }
+        /// A number, with its type's specifier (`%lld` for `Int`, `%lf` for `Double`…).
+        public mutating func appendInterpolation<T: _FormatSpecifiable>(_ value: T) {
+            _append(value._localizationArgument, specifier: T._specifier)
+        }
+
+        /// `"\(value, specifier: "%.1f")"`: the key holds the given specifier.
+        public mutating func appendInterpolation<T>(_ value: T, specifier: String) {
+            _append((value as? any _FormatSpecifiable)?._localizationArgument ?? .string(String(describing: value)), specifier: specifier)
+        }
+
+        /// `"\(price, format: .currency(code: "USD"))"`: `%@`, the formatted value.
+        public mutating func appendInterpolation<F: FormatStyle>(_ value: F.FormatInput, format: F) where F.FormatOutput == String {
+            append(format.format(value))
+        }
+
+        /// An image inline in the text: `Text("\(Image(systemName: "star")) Favorites")`.
+        public mutating func appendInterpolation(_ image: Image) {
+            key += "%@"
+            arguments.append(.image(image))
+        }
+
+        /// A styled text inline: `Text("Hello \(Text("world").bold())")`.
+        public mutating func appendInterpolation(_ text: Text) {
+            key += "%@"
+            arguments.append(.text(text))
+        }
+    }
 }
 
 // MARK: - Image
@@ -49,26 +106,36 @@ public struct Image: Equatable, Sendable {
     enum Source: Equatable, Sendable {
         case system(String)
         case named(String)
+        /// Phase 13: a remote image the browser loads itself (`AsyncImage`);
+        /// `width` and `height` are its intrinsic size in points.
+        case url(String, width: Double, height: Double)
+        /// A `UIImage` or `CGImage` bitmap the page draws from its recipe
+        /// (Bitmaps.swift); `width` and `height` are its size in points.
+        case bitmap(_ImageRecipe, width: Double, height: Double)
     }
 
     let source: Source
     /// `.resizable()`: fill the proposed size instead of the intrinsic one.
     let isResizable: Bool
+    /// `.interpolation(.none)`: scaled without smoothing (a QR code's modules
+    /// stay square). The other levels draw as the browser smooths.
+    var interpolation: Interpolation = .high
 
     public init(systemName: String) {
         source = .system(systemName)
         isResizable = false
     }
 
-    /// An image from the asset catalog. SwiftUI's `bundle:` parameter is not
-    /// offered: a Wasm app has no bundles, the catalog is the whole app's.
+    /// An image from the asset catalog, which is the whole app's: packages'
+    /// catalogs included. `Image(_:bundle:)` (FoundationBridge, which has
+    /// `Bundle`) draws the same image.
     public init(_ name: String) {
         source = .named(name)
         isResizable = false
     }
 
     /// A catalog image hidden from assistive technology (no bridge in the
-    /// browser, so it draws like `Image(_:)`). As for `Image(_:)`, no `bundle:`.
+    /// browser, so it draws like `Image(_:)`). `bundle:` as for `Image(_:)`.
     public init(decorative name: String) {
         source = .named(name)
         isResizable = false
@@ -79,6 +146,14 @@ public struct Image: Equatable, Sendable {
         self.isResizable = isResizable
     }
 
+    /// An image at a URL the host has already loaded (`AsyncImage` asks it
+    /// to, and learns the pixel size); `scale` turns pixels into points.
+    public init(_url url: String, pixelWidth: Double, pixelHeight: Double, scale: Double) {
+        let factor = scale > 0 ? scale : 1
+        source = .url(url, width: pixelWidth / factor, height: pixelHeight / factor)
+        isResizable = false
+    }
+
     /// The SF Symbol name, for labels that render the icon as a glyph (tab
     /// items, menu pickers); nil for catalog images.
     var systemName: String? {
@@ -86,26 +161,64 @@ public struct Image: Equatable, Sendable {
         return nil
     }
 
-    public func resizable() -> Image { Image(source: source, isResizable: true) }
+    public func resizable() -> Image {
+        var copy = Image(source: source, isResizable: true)
+        copy.interpolation = interpolation
+        return copy
+    }
 
-    /// Accepted for source compatibility; the browser picks the interpolation.
+    /// `.none` draws without smoothing; the other levels are the browser's.
     public enum Interpolation: Hashable, Sendable {
         case none, low, medium, high
     }
 
-    public func interpolation(_ interpolation: Interpolation) -> Image { self }
+    public func interpolation(_ interpolation: Interpolation) -> Image {
+        var copy = self
+        copy.interpolation = interpolation
+        return copy
+    }
     public func antialiased(_ isAntialiased: Bool) -> Image { self }
+
+    /// Whether an image draws its own colors or, as a template, the foreground
+    /// color through its shape. SF Symbols are templates already.
+    public enum TemplateRenderingMode: Hashable, Sendable {
+        case template, original
+    }
+
+    /// Approximation: a bitmap draws its own colors either way (tint one with
+    /// `UIImage.withTintColor(_:)`); symbols take the foreground color as before.
+    public func renderingMode(_ renderingMode: TemplateRenderingMode?) -> Image { self }
+
+    /// Symbols draw in one color here, whatever the mode (as the View modifier).
+    public func symbolRenderingMode(_ mode: SymbolRenderingMode?) -> Image { self }
+
+    /// The page draws images in the browser's range.
+    public func allowedDynamicRange(_ range: DynamicRange?) -> Image { self }
+
+    public struct DynamicRange: Hashable, Sendable {
+        let name: String
+        public static let standard = DynamicRange(name: "standard")
+        public static let constrainedHigh = DynamicRange(name: "constrainedHigh")
+        public static let high = DynamicRange(name: "high")
+    }
 }
 extension Image: _PrimitiveView {}
 extension Image: _HostView {
     var _kind: String { "image" }
     func _props(in environment: EnvironmentValues) -> _JSON {
+        var props: [String: _JSON]
         switch source {
         case .system(let name):
             return .object(["systemName": .string(name)])
         case .named(let name):
-            return .object(["name": .string(name), "resizable": .bool(isResizable)])
+            props = ["name": .string(name), "resizable": .bool(isResizable)]
+        case .url(let url, let width, let height):
+            props = ["url": .string(url), "resizable": .bool(isResizable), "width": .number(width), "height": .number(height)]
+        case .bitmap(let recipe, let width, let height):
+            props = ["bitmap": recipe.json, "resizable": .bool(isResizable), "width": .number(width), "height": .number(height)]
         }
+        if interpolation == .none { props["interpolation"] = .string("none") }
+        return .object(props)
     }
 }
 
@@ -248,10 +361,19 @@ extension ScrollView: _HostView {
         var props: [String: _JSON] = ["axes": .string(axes._name)]
         _refresh(in: environment).addProps(to: &props)
         if let snap = environment._scrollTargetBehavior { props["snap"] = .string(snap) }
+        // `.scrollDismissesKeyboard` (ScrollModifiers.swift).
+        if environment._scrollDismissesKeyboard { props["dismissesKeyboard"] = .bool(true) }
         return .object(props)
     }
     var _content: [any View] { [content] }
 }
+extension ScrollView: _EnvironmentContent {
+    /// `.contentMargins` above (ScrollModifiers.swift): padding inside the scroll view.
+    func _content(in environment: EnvironmentValues) -> [any View] {
+        guard let margins = environment._scrollContentMargins else { return [content] }
+        return [content.padding(margins)]
+    }
+}
 extension ScrollView: _Refreshing {
     func _refresh(in environment: EnvironmentValues) -> _Refresh {
         _Refresh(action: environment._refreshAction, refreshing: $refreshing)
@@ -286,10 +408,12 @@ public struct Button<Label: View> {
 }
 
 extension Button where Label == Text {
+    @_disfavoredOverload
     public init<S: StringProtocol>(_ title: S, action: @escaping @MainActor () -> Void) {
         self.init(action: action) { Text(title) }
     }
 
+    @_disfavoredOverload
     public init<S: StringProtocol>(_ title: S, role: ButtonRole?, action: @escaping @MainActor () -> Void) {
         self.init(role: role, action: action) { Text(title) }
     }
@@ -304,11 +428,13 @@ extension Button where Label == Text {
 }
 
 extension Button where Label == SwiftUI.Label<Text, Image> {
+    @_disfavoredOverload
     public init<S: StringProtocol>(_ title: S, systemImage: String, action: @escaping @MainActor () -> Void) {
         let title = String(title)
         self.init(action: action) { SwiftUI.Label(title, systemImage: systemImage) }
     }
 
+    @_disfavoredOverload
     public init<S: StringProtocol>(_ title: S, systemImage: String, role: ButtonRole?,
                                    action: @escaping @MainActor () -> Void) {
         let title = String(title)
@@ -329,7 +455,8 @@ extension Button: _HostView {
     var _kind: String { "button" }
     func _props(in environment: EnvironmentValues) -> _JSON {
         .object([
-            "style": .string(environment._buttonStyle),
+            // A custom `ButtonStyle` draws its own look: `plain` (ButtonStyles.swift).
+            "style": .string(environment._buttonStyle == _CustomButtonStyle.marker ? "plain" : environment._buttonStyle),
             "role": role.map { .string($0.name) } ?? .null,
         ])
     }
@@ -383,7 +510,7 @@ extension PrimitiveButtonStyle where Self == BorderedProminentButtonStyle {
     public static var borderedProminent: BorderedProminentButtonStyle { BorderedProminentButtonStyle() }
 }
 
-extension View {
+nonisolated extension View {
     public func buttonStyle<S: PrimitiveButtonStyle>(_ style: S) -> some View {
         environment(\._buttonStyle, style._name)
     }

package/Sources/SwiftUI/API/Publishers.swift

@@ -20,9 +20,8 @@ public struct _TaskCancellable: _Cancellable {
 }
 
 /// Emits `make()` every `interval` seconds, from the executor's clock (the same
-/// clock as `.task` sleeps, so headless runs stay deterministic). The shim
-/// cannot name `Date`, so `Timer.publish` in FoundationLite and FoundationBridge
-/// wraps this with `{ Date() }`.
+/// clock as `.task` sleeps, so headless runs stay deterministic).
+/// `Timer.publish` in FoundationBridge wraps this with `{ Date() }`.
 public struct _IntervalPublisher<Output: Sendable>: _Publisher, Sendable {
     public let interval: Double
     let make: @Sendable () -> Output
@@ -99,8 +98,9 @@ struct _OnReceiveView<Content: View, P: _Publisher>: View {
     }
 }
 
-extension View {
+nonisolated extension View {
     /// Calls `action` with every value `publisher` emits while the view is shown.
+    @MainActor
     public func onReceive<P: _Publisher>(_ publisher: P, perform action: @escaping @MainActor (P.Output) -> Void) -> some View {
         _OnReceiveView(content: self, publisher: publisher, action: action)
     }

package/Sources/SwiftUI/API/Redaction.swift

@@ -0,0 +1,75 @@
+// Redaction (`.redacted(reason:)`, `@Environment(\.redactionReasons)`) and
+// list separators' visibility. Redaction reasons pass down the environment,
+// so views that check them (to show placeholder content) adapt; the page
+// does not paint redacted text as grey boxes. The page draws a list's
+// separators itself, so `.listRowSeparator` and `.listSectionSeparator`
+// are accepted and leave the separators as they are.
+
+public struct RedactionReasons: OptionSet, Hashable, Sendable {
+    public let rawValue: Int
+    public init(rawValue: Int) { self.rawValue = rawValue }
+    public static let placeholder = RedactionReasons(rawValue: 1 << 0)
+    public static let privacy = RedactionReasons(rawValue: 1 << 1)
+    public static let invalidated = RedactionReasons(rawValue: 1 << 2)
+}
+
+struct _RedactionReasonsKey: EnvironmentKey {
+    static var defaultValue: RedactionReasons { [] }
+}
+
+extension EnvironmentValues {
+    /// Why the content is redacted; empty unless an ancestor is `.redacted(reason:)`.
+    public var redactionReasons: RedactionReasons {
+        get { self[_RedactionReasonsKey.self] }
+        set { self[_RedactionReasonsKey.self] = newValue }
+    }
+}
+
+public enum VerticalEdge: Int8, CaseIterable, Hashable, Sendable {
+    case top, bottom
+
+    public struct Set: OptionSet, Hashable, Sendable {
+        public let rawValue: Int8
+        public init(rawValue: Int8) { self.rawValue = rawValue }
+        public init(_ edge: VerticalEdge) { rawValue = 1 << edge.rawValue }
+        public static let top = Set(.top)
+        public static let bottom = Set(.bottom)
+        public static let all: Set = [.top, .bottom]
+    }
+}
+
+nonisolated extension View {
+    /// Adds `reason` to the environment's `redactionReasons` for the views below.
+    public func redacted(reason: RedactionReasons) -> some View {
+        _EnvironmentView(content: self) { $0.redactionReasons.formUnion(reason) }
+    }
+
+    /// Clears `redactionReasons` for the views below.
+    public func unredacted() -> some View {
+        _EnvironmentView(content: self) { $0.redactionReasons = [] }
+    }
+
+    /// Changes an environment value for the views below.
+    public func transformEnvironment<V>(_ keyPath: WritableKeyPath<EnvironmentValues, V>,
+                                        transform: @escaping (inout V) -> Void) -> some View {
+        _EnvironmentView(content: self) { transform(&$0[keyPath: keyPath]) }
+    }
+
+    /// Hides the separators at the row's `edges` (the page draws list
+    /// separators; a row hiding its bottom one, or the next row hiding its
+    /// top one, leaves the line between them out). `.visible` and
+    /// `.automatic` leave them as they are.
+    public func listRowSeparator(_ visibility: Visibility, edges: VerticalEdge.Set = .all) -> some View {
+        _styled {
+            guard visibility == .hidden else { return }
+            $0.extras["listRowSeparator"] = .object([
+                "top": .bool(edges.contains(.top)),
+                "bottom": .bool(edges.contains(.bottom)),
+            ])
+        }
+    }
+    /// The view unchanged: separators take the system color.
+    public func listRowSeparatorTint(_ color: Color?, edges: VerticalEdge.Set = .all) -> some View { self }
+    public func listSectionSeparator(_ visibility: Visibility, edges: VerticalEdge.Set = .all) -> some View { self }
+    public func listSectionSeparatorTint(_ color: Color?, edges: VerticalEdge.Set = .all) -> some View { self }
+}

package/Sources/SwiftUI/API/RowActions.swift

@@ -44,9 +44,10 @@ extension _SwipeActionsView: _HostView {
     var _content: [any View] { [content] + trailing + leading }
 }
 
-extension View {
+nonisolated extension View {
     /// Buttons revealed by swiping the row horizontally. The first declared
     /// action is nearest the content and is the one a full swipe performs.
+    @MainActor
     public func swipeActions<T: View>(edge: HorizontalEdge = .trailing, allowsFullSwipe: Bool = true,
                                       @ViewBuilder content: () -> T) -> _SwipeActionsView {
         var view = (self as? _SwipeActionsView) ?? _SwipeActionsView(content: self)
@@ -69,7 +70,7 @@ extension _ContextMenuView: _HostView {
     var _content: [any View] { [content, items] }
 }
 
-extension View {
+nonisolated extension View {
     /// Items shown in a popover on a long press or right click.
     public func contextMenu<M: View>(@ViewBuilder menuItems: () -> M) -> some View {
         _ContextMenuView(content: self, items: menuItems())

package/Sources/SwiftUI/API/Scenes.swift

@@ -0,0 +1,131 @@
+/// More of an app's scenes: several scenes in one `body`, window groups
+/// with an identifier or for a presented value, and the scene modifiers.
+///
+/// The page is the app's one window. An app whose `body` lists several
+/// scenes shows the first window group that is not for a value (a value's
+/// window opens only through `openWindow`, which does nothing, Windows.swift).
+/// `.onChange(of:)` on a scene watches the value from the window's root view.
+/// Window sizes, resizability, styles and the menu bar's `.commands` are
+/// accepted and do nothing: there is no window to size and no menu bar.
+
+/// The scenes of a `body` that lists several.
+public struct _TupleScene: Scene {
+    let parts: [any Scene]
+    public typealias Body = Never
+    public var body: Never { fatalError("_TupleScene is a primitive scene") }
+}
+
+extension _TupleScene: _RootScene {
+    var _rootView: any View {
+        let roots = parts.compactMap { $0 as? any _RootScene }
+        guard let root = roots.first(where: { !($0 is any _ValueWindowScene) }) ?? roots.first else {
+            fatalError("No scene the runtime can present. Use WindowGroup.")
+        }
+        return root._rootView
+    }
+}
+
+@MainActor
+extension SceneBuilder {
+    public static func buildBlock<each Content: Scene>(_ content: repeat each Content) -> _TupleScene {
+        var parts: [any Scene] = []
+        for part in repeat each content { parts.append(part) }
+        return _TupleScene(parts: parts)
+    }
+
+    public static func buildOptional<Content: Scene>(_ content: Content?) -> _TupleScene {
+        _TupleScene(parts: content.map { [$0] } ?? [])
+    }
+
+    public static func buildEither<Content: Scene>(first content: Content) -> _TupleScene {
+        _TupleScene(parts: [content])
+    }
+
+    public static func buildEither<Content: Scene>(second content: Content) -> _TupleScene {
+        _TupleScene(parts: [content])
+    }
+
+    public static func buildLimitedAvailability<Content: Scene>(_ content: Content) -> _TupleScene {
+        _TupleScene(parts: [content])
+    }
+}
+
+extension WindowGroup {
+    /// A window group with an identifier (`openWindow(id:)` names it).
+    public init(id: String, @ViewBuilder content: () -> Content) {
+        self.init(content: content)
+    }
+
+    public init(_ title: String, id: String, @ViewBuilder content: () -> Content) {
+        self.init(content: content)
+    }
+
+    public init(_ titleKey: LocalizedStringKey, id: String, @ViewBuilder content: () -> Content) {
+        self.init(content: content)
+    }
+}
+
+/// The content of a `WindowGroup(for:)`: made with no value.
+public struct _ValueWindowContent<Value: Codable & Hashable, Content: View>: View {
+    let make: (Binding<Value?>) -> Content
+    public var body: Content { make(.constant(nil)) }
+}
+
+/// A window group for presented values: never opened in the browser.
+protocol _ValueWindowScene {}
+extension WindowGroup: _ValueWindowScene where Content: _ValueWindowContentMarker {}
+protocol _ValueWindowContentMarker {}
+extension _ValueWindowContent: _ValueWindowContentMarker {}
+
+@MainActor
+extension WindowGroup {
+    /// A window per presented value (`openWindow(value:)`). The page opens no
+    /// other window, so the group is declared and never shown.
+    public init<D: Codable & Hashable, C: View>(for type: D.Type, @ViewBuilder content: @escaping (Binding<D?>) -> C)
+    where Content == _ValueWindowContent<D, C> {
+        self.init { _ValueWindowContent(make: content) }
+    }
+
+    public init<D: Codable & Hashable, C: View>(_ title: String, for type: D.Type,
+                                               @ViewBuilder content: @escaping (Binding<D?>) -> C)
+    where Content == _ValueWindowContent<D, C> {
+        self.init { _ValueWindowContent(make: content) }
+    }
+}
+
+/// How a window may be resized; accepted.
+public struct WindowResizability: Hashable, Sendable {
+    let name: String
+    public static let automatic = WindowResizability(name: "automatic")
+    public static let contentSize = WindowResizability(name: "contentSize")
+    public static let contentMinSize = WindowResizability(name: "contentMinSize")
+}
+
+/// `.onChange(of:)` on a scene: the root view watches the value.
+struct _SceneOnChange<Value: Equatable>: ViewModifier {
+    let value: Value
+    let initial: Bool
+    let action: (Value, Value) -> Void
+
+    func body(content: Content) -> some View {
+        content.onChange(of: value, initial: initial, action)
+    }
+}
+
+extension Scene {
+    /// Accepted: the page is not a resizable window.
+    public func defaultSize(width: CGFloat, height: CGFloat) -> some Scene { self }
+    public func defaultSize(_ size: CGSize) -> some Scene { self }
+    public func windowResizability(_ resizability: WindowResizability) -> some Scene { self }
+    public func handlesExternalEvents(matching conditions: Set<String>) -> some Scene { self }
+
+    /// Runs `action` when `value` changes, from the window's root view.
+    public func onChange<V: Equatable>(of value: V, initial: Bool = false,
+                                       _ action: @escaping (_ oldValue: V, _ newValue: V) -> Void) -> some Scene {
+        _modifyingRootView(_SceneOnChange(value: value, initial: initial, action: action))
+    }
+
+    public func onChange<V: Equatable>(of value: V, initial: Bool = false, _ action: @escaping () -> Void) -> some Scene {
+        _modifyingRootView(_SceneOnChange(value: value, initial: initial) { _, _ in action() })
+    }
+}