@appsent-co/react-native-watchos 0.1.0

package/apple/Sources/ReactNativeWatchOS/Modifiers/ContainerRelativeFrame.swift

@@ -0,0 +1,24 @@
+import SwiftUI
+
+/// SwiftUI `.containerRelativeFrame(_:alignment:)`. Sizes the view relative
+/// to its nearest container. Requires watchOS 10+; on watchOS 9 the view is
+/// returned unchanged.
+enum RNWContainerRelativeFrameModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("containerRelativeFrame") { view, params, _ in
+            guard #available(watchOS 10.0, *) else { return view }
+            let axes = axisSet(params.string("axes"))
+            let alignment = RNWAlignmentParser.alignment(params.string("alignment"))
+            return AnyView(view.containerRelativeFrame(axes, alignment: alignment))
+        }
+    }
+
+    private static func axisSet(_ s: String?) -> Axis.Set {
+        switch s {
+        case "horizontal": return .horizontal
+        case "vertical":   return .vertical
+        default:           return [.horizontal, .vertical] // "both" / nil
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/ContainerShape.swift

@@ -0,0 +1,25 @@
+import SwiftUI
+
+/// SwiftUI `.containerShape(_:)`. Sets the preferred container shape so
+/// descendants (e.g. `.containerBackground`, container-relative button
+/// borders) can clip to it. Available on watchOS 9+.
+enum RNWContainerShapeModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("containerShape") { view, params, _ in
+            switch params.string("shape") {
+            case "circle":
+                return AnyView(view.containerShape(Circle()))
+            case "capsule":
+                return AnyView(view.containerShape(Capsule()))
+            case "roundedRectangle":
+                let radius = params.cgFloat("cornerRadius") ?? 0
+                return AnyView(view.containerShape(
+                    RoundedRectangle(cornerRadius: radius)
+                ))
+            default: // "rectangle" and anything unknown
+                return AnyView(view.containerShape(Rectangle()))
+            }
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/ContainerValue.swift

@@ -0,0 +1,20 @@
+import SwiftUI
+
+/// SwiftUI `.containerValue(_:_:)` (watchOS 11+).
+///
+/// LIMITATION — implemented as a no-op. `containerValue` writes into a
+/// `ContainerValues` slot addressed by a static `WritableKeyPath` declared
+/// in Swift (via `@Entry`). There is no general, type-safe way to resolve
+/// such a key path from a runtime string arriving across the JS bridge, and
+/// values custom containers read are bridge-opaque. The registration exists
+/// so the `$type` is recognized (forward-compat) and the view passes through
+/// unchanged rather than being dropped.
+enum RNWContainerValueModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("containerValue") { view, _, _ in
+            // No generic bridge for ContainerValues key paths — see note above.
+            return view
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/ContentMargins.swift

@@ -0,0 +1,21 @@
+import SwiftUI
+
+/// SwiftUI `.contentMargins(_:_:for:)`. Adds margins around the content of
+/// a scrollable view. `edges` is parsed via the shared `RNWEdgeParser`
+/// (defaults to `.all`); `length` is the inset in points. Applied for the
+/// `.scrollContent` placement so it insets scrollable content specifically.
+///
+/// Gated to watchOS 10+. Returns the view unchanged on older systems.
+enum RNWContentMarginsModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("contentMargins") { view, params, _ in
+            if #available(watchOS 10.0, *) {
+                let edges = RNWEdgeParser.edgeSet(params["edges"])
+                let length = params.cgFloat("length") ?? 0
+                return AnyView(view.contentMargins(edges, length, for: .scrollContent))
+            }
+            return view
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/ContentShape.swift

@@ -0,0 +1,26 @@
+import SwiftUI
+
+/// SwiftUI `.contentShape(_:)`. Sets the view's hit-testing region to a
+/// simple shape. The shape branches are switched individually because each
+/// concrete `Shape` type differs — a `RoundedRectangle` is not the same type
+/// as a `Circle`. Defaults to `rectangle` when the param is missing/unknown.
+enum RNWContentShapeModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("contentShape") { view, params, _ in
+            switch params.string("shape") {
+            case "circle":
+                return AnyView(view.contentShape(Circle()))
+            case "capsule":
+                return AnyView(view.contentShape(Capsule()))
+            case "roundedRectangle":
+                let radius = params.cgFloat("cornerRadius") ?? 0
+                return AnyView(view.contentShape(
+                    RoundedRectangle(cornerRadius: radius)
+                ))
+            default:
+                return AnyView(view.contentShape(Rectangle()))
+            }
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/ContextMenu.swift

@@ -0,0 +1,14 @@
+import SwiftUI
+
+/// SwiftUI `.contextMenu { … }`. Renders the menu-items content slot as the
+/// context menu body. No-ops (returns the view unchanged) when no content was
+/// provided.
+enum RNWContextMenuModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("contextMenu") { view, params, ctx in
+            guard let body = ctx.content(params.string("content")) else { return view }
+            return AnyView(view.contextMenu { body })
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/Contrast.swift

@@ -0,0 +1,12 @@
+import SwiftUI
+
+/// SwiftUI `.contrast(_:)`. Multiplies color contrast by `value`;
+/// `1` leaves the view unchanged.
+enum RNWContrastModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("contrast") { view, params, _ in
+            AnyView(view.contrast(params.double("value") ?? 1))
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/ControlSize.swift

@@ -0,0 +1,27 @@
+import SwiftUI
+
+/// SwiftUI `.controlSize(_:)`. Maps the `style` string to a `ControlSize`.
+/// `.extraLarge` is watchOS 10+; on older systems it falls back to
+/// `.large`. Unknown values fall back to `.regular`.
+enum RNWControlSizeModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("controlSize") { view, params, _ in
+            switch params.string("style") {
+            case "mini":
+                return AnyView(view.controlSize(.mini))
+            case "small":
+                return AnyView(view.controlSize(.small))
+            case "large":
+                return AnyView(view.controlSize(.large))
+            case "extraLarge":
+                if #available(watchOS 10.0, *) {
+                    return AnyView(view.controlSize(.extraLarge))
+                }
+                return AnyView(view.controlSize(.large))
+            default:
+                return AnyView(view.controlSize(.regular))
+            }
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/CoordinateSpace.swift

@@ -0,0 +1,15 @@
+import SwiftUI
+
+/// SwiftUI `.coordinateSpace(name:)`. Tags the view with a named coordinate
+/// space. Uses the legacy `name:` overload (watchOS 6+) rather than the
+/// `.named(_:)` form (watchOS 10+) so it works on the watchOS 9 floor. A
+/// missing `name` leaves the view unchanged.
+enum RNWCoordinateSpaceModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("coordinateSpace") { view, params, _ in
+            guard let name = params.string("name") else { return view }
+            return AnyView(view.coordinateSpace(name: name))
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/CornerRadius.swift

@@ -0,0 +1,14 @@
+import SwiftUI
+
+/// SwiftUI `.cornerRadius(_:)`. Clips the view to a rounded rectangle of the
+/// given `radius`. The API is deprecated in newer SDKs (in favor of
+/// `.clipShape(RoundedRectangle(...))`) but remains available on watchOS 9+.
+enum RNWCornerRadiusModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("cornerRadius") { view, params, _ in
+            let radius = params.cgFloat("radius") ?? 0
+            return AnyView(view.cornerRadius(radius))
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/DatePickerStyle.swift

@@ -0,0 +1,20 @@
+import SwiftUI
+
+/// SwiftUI `.datePickerStyle(_:)`. Maps the `style` string to a date-picker
+/// style. Unknown values fall back to `.automatic`.
+enum RNWDatePickerStyleModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("datePickerStyle") { view, params, _ in
+            // DatePicker and its styles are watchOS 10+. On watchOS 9 the
+            // view is returned unchanged.
+            guard #available(watchOS 10.0, *) else { return view }
+            switch params.string("style") {
+            case "wheel":
+                return AnyView(view.datePickerStyle(.wheel))
+            default:
+                return AnyView(view.datePickerStyle(.automatic))
+            }
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/DefaultAppStorage.swift

@@ -0,0 +1,21 @@
+import SwiftUI
+
+/// SwiftUI `.defaultAppStorage(_:)`. Sets the `UserDefaults` store that
+/// descendant `@AppStorage` properties read from and write to. Falls back
+/// to `.standard` when no `suiteName` is given or the named suite can't be
+/// opened.
+enum RNWDefaultAppStorageModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("defaultAppStorage") { view, params, _ in
+            let store: UserDefaults
+            if let suiteName = params.string("suiteName"),
+               let suite = UserDefaults(suiteName: suiteName) {
+                store = suite
+            } else {
+                store = .standard
+            }
+            return AnyView(view.defaultAppStorage(store))
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/DefaultScrollAnchor.swift

@@ -0,0 +1,20 @@
+import SwiftUI
+
+/// SwiftUI `.defaultScrollAnchor(_:)`. Sets the unit point the scroll view
+/// initially aligns to (and re-aligns to when content size changes).
+/// `anchor` is parsed via the shared `parseUnitPoint` ('top' | 'center' |
+/// 'bottom' | … | `{ x, y }`); defaults to `.center`.
+///
+/// Gated to watchOS 10+. Returns the view unchanged on older systems.
+enum RNWDefaultScrollAnchorModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("defaultScrollAnchor") { view, params, _ in
+            if #available(watchOS 10.0, *) {
+                let anchor = parseUnitPoint(params["anchor"]) ?? .center
+                return AnyView(view.defaultScrollAnchor(anchor))
+            }
+            return view
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/DeleteDisabled.swift

@@ -0,0 +1,12 @@
+import SwiftUI
+
+/// SwiftUI `.deleteDisabled(_:)`. Prevents a row in an editable `List` /
+/// `ForEach` from being deleted. Defaults to `true` when unspecified.
+enum RNWDeleteDisabledModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("deleteDisabled") { view, params, _ in
+            AnyView(view.deleteDisabled(params.bool("value") ?? true))
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/DigitalCrownAccessory.swift

@@ -0,0 +1,20 @@
+import SwiftUI
+
+/// SwiftUI `.digitalCrownAccessory { … }`. Shows an accessory view next to the
+/// Digital Crown while it's in use (e.g. a value readout). The accessory body
+/// is passed as modifier content from JS and resolved through `ctx.content`;
+/// when no content is provided the view is returned unchanged.
+///
+/// Available on watchOS 9, the deployment floor, so no availability gating is
+/// required.
+enum RNWDigitalCrownAccessoryModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("digitalCrownAccessory") { view, params, ctx in
+            guard let body = ctx.content(params.string("content")) else {
+                return view
+            }
+            return AnyView(view.digitalCrownAccessory { body })
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/DigitalCrownRotation.swift

@@ -0,0 +1,100 @@
+import SwiftUI
+import ReactNativeWatchOSCxx
+
+/// SwiftUI `.digitalCrownRotation(_:…)`. Binds the Digital Crown to a numeric
+/// value. JS owns the source of truth via `value`; we hold a local `@State`
+/// mirror so the crown tracks smoothly without waiting for the JS round-trip,
+/// then converge on the next snapshot via `.onChange` (the same
+/// optimistic-binding pattern as `ToggleView`).
+///
+/// When `from`/`through` are supplied the bounded overload is used (with an
+/// optional `sensitivity`); otherwise the plain unbounded binding overload.
+/// Both overloads exist on watchOS 9, the deployment floor, so no gating is
+/// needed.
+enum RNWDigitalCrownRotationModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("digitalCrownRotation") { view, params, ctx in
+            AnyView(view.modifier(RNWDigitalCrownRotationViewModifier(
+                value: params.double("value") ?? 0,
+                handlerId: params.int("handler"),
+                from: params.double("from"),
+                through: params.double("through"),
+                sensitivity: params.string("sensitivity"),
+                bus: ctx.bus
+            )))
+        }
+    }
+}
+
+private struct RNWDigitalCrownRotationViewModifier: ViewModifier {
+    let value: Double
+    let handlerId: Int?
+    let from: Double?
+    let through: Double?
+    let sensitivity: String?
+    let bus: RNWEventBus
+
+    @State private var localValue: Double
+
+    init(
+        value: Double,
+        handlerId: Int?,
+        from: Double?,
+        through: Double?,
+        sensitivity: String?,
+        bus: RNWEventBus
+    ) {
+        self.value = value
+        self.handlerId = handlerId
+        self.from = from
+        self.through = through
+        self.sensitivity = sensitivity
+        self.bus = bus
+        _localValue = State(initialValue: value)
+    }
+
+    func body(content: Content) -> some View {
+        let binding = Binding<Double>(
+            get: { localValue },
+            set: { newValue in
+                localValue = newValue
+                if let handlerId {
+                    bus.fire(handlerId, payload: newValue)
+                }
+            }
+        )
+
+        return Group {
+            if let from, let through {
+                content.digitalCrownRotation(
+                    binding,
+                    from: from,
+                    through: through,
+                    sensitivity: Self.resolveSensitivity(sensitivity)
+                )
+            } else {
+                content.digitalCrownRotation(binding)
+            }
+        }
+        .onChange(of: value) { newRemote in
+            // JS pushed an authoritative value — converge.
+            if newRemote != localValue {
+                localValue = newRemote
+            }
+        }
+    }
+
+    private static func resolveSensitivity(
+        _ raw: String?
+    ) -> DigitalCrownRotationalSensitivity {
+        switch raw {
+        case "low":
+            return .low
+        case "medium":
+            return .medium
+        default:
+            return .high
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/Disabled.swift

@@ -0,0 +1,12 @@
+import SwiftUI
+
+/// SwiftUI `.disabled(_:)`. Blocks interaction with the view and its
+/// descendants when `value` is true.
+enum RNWDisabledModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("disabled") { view, params, _ in
+            AnyView(view.disabled(params.bool("value") ?? true))
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/DrawingGroup.swift

@@ -0,0 +1,12 @@
+import SwiftUI
+
+/// SwiftUI `.drawingGroup(opaque:colorMode:)`. Flattens descendants into
+/// a single offscreen Metal-rendered image.
+enum RNWDrawingGroupModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("drawingGroup") { view, params, _ in
+            AnyView(view.drawingGroup(opaque: params.bool("opaque") ?? false))
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/DynamicTypeSize.swift

@@ -0,0 +1,36 @@
+import SwiftUI
+
+/// SwiftUI `.dynamicTypeSize(_:)`. Pins the subtree to a fixed
+/// `DynamicTypeSize` instead of tracking the system text-size setting.
+/// Requires watchOS 9.0+ — returns the view unchanged on older systems.
+enum RNWDynamicTypeSizeModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("dynamicTypeSize") { view, params, _ in
+            if #available(watchOS 9.0, *) {
+                guard let size = parse(params.string("size")) else { return view }
+                return AnyView(view.dynamicTypeSize(size))
+            }
+            return view
+        }
+    }
+
+    @available(watchOS 9.0, *)
+    private static func parse(_ s: String?) -> DynamicTypeSize? {
+        switch s {
+        case "xSmall":         return .xSmall
+        case "small":          return .small
+        case "medium":         return .medium
+        case "large":          return .large
+        case "xLarge":         return .xLarge
+        case "xxLarge":        return .xxLarge
+        case "xxxLarge":       return .xxxLarge
+        case "accessibility1": return .accessibility1
+        case "accessibility2": return .accessibility2
+        case "accessibility3": return .accessibility3
+        case "accessibility4": return .accessibility4
+        case "accessibility5": return .accessibility5
+        default:               return nil
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/Environment.swift

@@ -0,0 +1,40 @@
+import SwiftUI
+
+/// SwiftUI `.environment(_:_:)`, restricted to a bridgeable subset of
+/// `EnvironmentValues` key paths.
+///
+/// LIMITED: SwiftUI's `.environment(_:_:)` is generic over arbitrary
+/// `WritableKeyPath<EnvironmentValues, V>`, which cannot be reconstructed
+/// from a JSON string. Only the hand-picked keys below — whose values are
+/// expressible over the bridge — are supported. Unknown `key` values are a
+/// documented no-op (the view is returned unchanged).
+enum RNWEnvironmentModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("environment") { view, params, _ in
+            guard let key = params.string("key") else { return view }
+            switch key {
+            case "locale":
+                guard let identifier = params.string("value") else { return view }
+                return AnyView(view.environment(\.locale, Locale(identifier: identifier)))
+
+            case "layoutDirection":
+                let direction: LayoutDirection =
+                    params.string("value") == "rightToLeft" ? .rightToLeft : .leftToRight
+                return AnyView(view.environment(\.layoutDirection, direction))
+
+            case "lineSpacing":
+                guard let spacing = params.cgFloat("value") else { return view }
+                return AnyView(view.environment(\.lineSpacing, spacing))
+
+            case "multilineTextAlignment":
+                let alignment = RNWAlignmentParser.textAlignment(params.string("value"))
+                return AnyView(view.environment(\.multilineTextAlignment, alignment))
+
+            default:
+                // Unknown / unbridgeable key — no-op.
+                return view
+            }
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/EnvironmentObject.swift

@@ -0,0 +1,20 @@
+import SwiftUI
+
+/// SwiftUI `.environmentObject(_:)`.
+///
+/// UNSUPPORTED: `.environmentObject` injects a reference-type
+/// `ObservableObject` into the environment for descendants to read via
+/// `@EnvironmentObject`. A JS value can't be made into a Swift
+/// `ObservableObject` — it has no `objectWillChange` publisher and no
+/// native identity — and there are no JS-side observers to drive. Registered
+/// as a no-op (returns the view unchanged) so the JS factory exists and
+/// composes; callers should use concrete value modifiers (e.g. `environment`)
+/// for cross-cutting state instead.
+enum RNWEnvironmentObjectModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("environmentObject") { view, _, _ in
+            view
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/FixedSize.swift

@@ -0,0 +1,22 @@
+import SwiftUI
+
+/// SwiftUI `.fixedSize()` / `.fixedSize(horizontal:vertical:)`. With neither
+/// `horizontal` nor `vertical` param present, fixes the view at its ideal
+/// size on both axes; otherwise fixes only the requested axes (a missing
+/// axis param defaults to `false`).
+enum RNWFixedSizeModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("fixedSize") { view, params, _ in
+            let h = params.bool("horizontal")
+            let v = params.bool("vertical")
+            if h == nil && v == nil {
+                return AnyView(view.fixedSize())
+            }
+            return AnyView(view.fixedSize(
+                horizontal: h ?? false,
+                vertical: v ?? false
+            ))
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/Focusable.swift

@@ -0,0 +1,14 @@
+import SwiftUI
+
+/// SwiftUI `.focusable(_:)`. Marks the view as able (or unable) to receive
+/// focus via the Digital Crown / accessibility focus. The `value` param
+/// defaults to `true` when absent.
+enum RNWFocusableModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("focusable") { view, params, _ in
+            let value = params.bool("value") ?? true
+            return AnyView(view.focusable(value))
+        }
+    }
+}

package/apple/Sources/ReactNativeWatchOS/Modifiers/Focused.swift

@@ -0,0 +1,52 @@
+import SwiftUI
+import ReactNativeWatchOSCxx
+
+/// SwiftUI `.focused(_:)` — a two-way focus binding. JS owns the focused
+/// state via the `value` param; we hold a local `@FocusState` mirror so focus
+/// reflects immediately when the system moves it (Digital Crown, taps), fire
+/// the JS `handler` with the new boolean on change, then converge back to the
+/// authoritative `value` from the next snapshot.
+///
+/// `@FocusState` / `.focused(_:)` are watchOS 8+, under the watchOS 9
+/// deployment target, so no availability gate is needed.
+enum RNWFocusedModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("focused") { view, params, ctx in
+            AnyView(view.modifier(FocusedMod(
+                value: params.bool("value") ?? false,
+                handlerId: params.int("handler"),
+                bus: ctx.bus
+            )))
+        }
+    }
+}
+
+/// Concrete `ViewModifier` so we can hang `@FocusState` off it. The applier
+/// re-creates it each render with the latest `value`; `@FocusState` persists
+/// because the modified view's identity is stable (`.id(node.tag)` upstream).
+private struct FocusedMod: ViewModifier {
+    let value: Bool
+    let handlerId: Int?
+    let bus: RNWEventBus
+
+    @FocusState private var focused: Bool
+
+    func body(content: Content) -> some View {
+        content
+            .focused($focused)
+            // Mirror the initial / updated JS value into the focus state.
+            .onAppear { if focused != value { focused = value } }
+            .onChange(of: value) { newValue in
+                // JS pushed an authoritative value — converge.
+                if focused != newValue { focused = newValue }
+            }
+            .onChange(of: focused) { newFocused in
+                // System/user moved focus — notify JS, but only when it
+                // diverges from what JS already holds (skip convergence echoes).
+                if newFocused != value, let handlerId {
+                    bus.fire(handlerId, payload: newFocused)
+                }
+            }
+    }
+}