@appsent-co/react-native-watchos 0.1.0

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

@@ -0,0 +1,65 @@
+import SwiftUI
+
+/// SwiftUI `.font(_:)`. Supports semantic styles (`.body`, `.title`, …)
+/// and explicit `Font.system(size:weight:)` constructions. Registered in
+/// the generic registry — works on Text and any other view that has
+/// inheritable typography (Label, Button, etc.).
+enum RNWFontModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("font") { view, params, _ in
+            let weight = parseWeight(params.string("weight"))
+            let font: Font
+            if let style = params.string("style") {
+                font = applyingWeight(weight, to: semanticFont(style))
+            } else if let size = params.double("size") {
+                font = .system(size: size, weight: weight ?? .regular)
+            } else {
+                return view
+            }
+            return AnyView(view.font(font))
+        }
+    }
+
+    private static func semanticFont(_ style: String) -> Font {
+        switch style {
+        case "largeTitle":   return .largeTitle
+        case "title":        return .title
+        case "title2":       return .title2
+        case "title3":       return .title3
+        case "headline":     return .headline
+        case "subheadline":  return .subheadline
+        case "body":         return .body
+        case "callout":      return .callout
+        case "footnote":     return .footnote
+        case "caption":      return .caption
+        case "caption2":     return .caption2
+        default:             return .body
+        }
+    }
+
+    private static func parseWeight(_ s: String?) -> Font.Weight? {
+        switch s {
+        case "ultraLight": return .ultraLight
+        case "thin":       return .thin
+        case "light":      return .light
+        case "regular":    return .regular
+        case "medium":     return .medium
+        case "semibold":   return .semibold
+        case "bold":       return .bold
+        case "heavy":      return .heavy
+        case "black":      return .black
+        default:           return nil
+        }
+    }
+
+    /// `.weight()` on a semantic Font is the SwiftUI-idiomatic way to
+    /// keep the semantic sizing/dynamic-type behavior while overriding
+    /// stroke weight (vs. `.system(size:weight:)` which loses both).
+    private static func applyingWeight(
+        _ weight: Font.Weight?, to font: Font
+    ) -> Font {
+        guard let weight else { return font }
+        return font.weight(weight)
+    }
+}

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

@@ -0,0 +1,20 @@
+import SwiftUI
+
+/// SwiftUI `.fontDesign(_:)`. Overrides the font design (e.g. `.rounded`,
+/// `.serif`) for text within the view. The `View`-level modifier is
+/// watchOS 9.1+, so it's gated and degrades to an unchanged view on 9.0.
+/// An unrecognized design string also leaves the view unchanged.
+enum RNWFontDesignModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("fontDesign") { view, params, _ in
+            guard let design = RNWFontParsers.design(params.string("design")) else {
+                return view
+            }
+            if #available(watchOS 9.1, *) {
+                return AnyView(view.fontDesign(design))
+            }
+            return view
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+import SwiftUI
+
+/// SwiftUI `.fontWeight(_:)`. Sets the stroke weight of text within the
+/// view. An unrecognized (or absent) weight leaves the view unchanged.
+enum RNWFontWeightModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("fontWeight") { view, params, _ in
+            guard let weight = RNWFontParsers.weight(params.string("weight")) else {
+                return view
+            }
+            return AnyView(view.fontWeight(weight))
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+import SwiftUI
+
+/// SwiftUI `.foregroundColor(_:)`. Registered in the generic registry so
+/// it works on every view — for plain Text we lose the typed
+/// `Text → Text` chain (and Text concatenation with it), but the visual
+/// result is identical and the simpler registry layout is worth it for
+/// our scale.
+enum RNWForegroundColorModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("foregroundColor") { view, params, _ in
+            guard let colorString = params.string("color"),
+                  let color = RNWColorParser.parse(colorString) else {
+                return view
+            }
+            return AnyView(view.foregroundColor(color))
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+import SwiftUI
+
+/// SwiftUI `.foregroundStyle(_:)`. Resolves the `style` string through the
+/// shared `RNWShapeStyleParser` (named/hex color, hierarchical level, tint,
+/// or watchOS-10+ material). Leaves the view unchanged when the string is
+/// unrecognized so callers see a graceful fallback.
+enum RNWForegroundStyleModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("foregroundStyle") { view, params, _ in
+            guard let style = RNWShapeStyleParser.parse(params.string("style")) else {
+                return view
+            }
+            return AnyView(view.foregroundStyle(style))
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+import SwiftUI
+
+/// SwiftUI `.formStyle(_:)`. watchOS ships only `AutomaticFormStyle`
+/// (`.automatic`); `.columns` (macOS) and `.grouped` (iOS/macOS) are
+/// unavailable on watchOS, so every value maps to `.automatic`. The `style`
+/// param is accepted for cross-platform parity but has no other effect here.
+enum RNWFormStyleModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("formStyle") { view, _, _ in
+            AnyView(view.formStyle(.automatic))
+        }
+    }
+}

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

@@ -0,0 +1,44 @@
+import SwiftUI
+
+/// SwiftUI `.frame(...)`. Two overloads picked by which keys are present:
+///   - `width` or `height`   → `.frame(width:height:alignment:)`
+///   - otherwise             → `.frame(minWidth:maxWidth:…:alignment:)`
+///
+/// Pass `Infinity` from JS for `maxWidth` / `maxHeight` to fill available
+/// space — Hermes preserves it through JSI as a Double, which CGFloat
+/// converts to `.infinity` and SwiftUI accepts directly.
+enum RNWFrameModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("frame") { view, params, _ in
+            let alignment = parseAlignment(params.string("alignment")) ?? .center
+            let w = params.cgFloat("width")
+            let h = params.cgFloat("height")
+            if w != nil || h != nil {
+                return AnyView(view.frame(width: w, height: h, alignment: alignment))
+            }
+            return AnyView(view.frame(
+                minWidth: params.cgFloat("minWidth"),
+                maxWidth: params.cgFloat("maxWidth"),
+                minHeight: params.cgFloat("minHeight"),
+                maxHeight: params.cgFloat("maxHeight"),
+                alignment: alignment
+            ))
+        }
+    }
+
+    private static func parseAlignment(_ s: String?) -> Alignment? {
+        switch s {
+        case "leading":        return .leading
+        case "trailing":       return .trailing
+        case "center":         return .center
+        case "top":            return .top
+        case "bottom":         return .bottom
+        case "topLeading":     return .topLeading
+        case "topTrailing":    return .topTrailing
+        case "bottomLeading":  return .bottomLeading
+        case "bottomTrailing": return .bottomTrailing
+        default:               return nil
+        }
+    }
+}

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

@@ -0,0 +1,68 @@
+import SwiftUI
+
+/// SwiftUI `.fullScreenCover(isPresented:content:)`.
+///
+/// LIMITATION: `.fullScreenCover` does NOT exist on watchOS (it is
+/// iOS/tvOS-only). This falls back to `.sheet(isPresented:){ body }`. On a
+/// watch a sheet already occupies (nearly) the full screen, so the visual
+/// result is close; the practical difference is that the fallback sheet
+/// stays interactively dismissable. The `$type` is kept distinct from
+/// `sheet` so the JS surface can express intent and so a future watchOS
+/// release that adds the API can upgrade this applier in place.
+///
+/// The presentation flag uses the same optimistic-local-state +
+/// converge-on-`onChange` binding as `RNWSheetModifier`.
+enum RNWFullScreenCoverModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("fullScreenCover") { view, params, ctx in
+            let body = ctx.content(params.string("content"))
+            return AnyView(view.modifier(RNWFullScreenCoverViewModifier(
+                remotePresented: params.bool("isPresented") ?? false,
+                handlerId: params.int("handler"),
+                bus: ctx.bus,
+                coverBody: body
+            )))
+        }
+    }
+}
+
+private struct RNWFullScreenCoverViewModifier: ViewModifier {
+    let remotePresented: Bool
+    let handlerId: Int?
+    let bus: RNWEventBus
+    let coverBody: AnyView?
+
+    @State private var localPresented: Bool
+
+    init(remotePresented: Bool, handlerId: Int?, bus: RNWEventBus, coverBody: AnyView?) {
+        self.remotePresented = remotePresented
+        self.handlerId = handlerId
+        self.bus = bus
+        self.coverBody = coverBody
+        _localPresented = State(initialValue: remotePresented)
+    }
+
+    func body(content: Content) -> some View {
+        let binding = Binding<Bool>(
+            get: { localPresented },
+            set: { newValue in
+                localPresented = newValue
+                if let handlerId {
+                    bus.fire(handlerId, payload: newValue)
+                }
+            }
+        )
+
+        // watchOS has no `.fullScreenCover` — fall back to `.sheet`.
+        return content
+            .sheet(isPresented: binding) {
+                coverBody ?? AnyView(EmptyView())
+            }
+            .onChange(of: remotePresented) { newRemote in
+                if newRemote != localPresented {
+                    localPresented = newRemote
+                }
+            }
+    }
+}

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

@@ -0,0 +1,27 @@
+import SwiftUI
+
+/// SwiftUI `.gaugeStyle(_:)`. Maps the `style` string to a gauge style.
+/// All listed styles are available on watchOS 9 (the deployment target),
+/// so no availability gating is required. Unknown values fall back to
+/// `.automatic`.
+enum RNWGaugeStyleModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("gaugeStyle") { view, params, _ in
+            switch params.string("style") {
+            case "accessoryCircular":
+                return AnyView(view.gaugeStyle(.accessoryCircular))
+            case "accessoryCircularCapacity":
+                return AnyView(view.gaugeStyle(.accessoryCircularCapacity))
+            case "accessoryLinear":
+                return AnyView(view.gaugeStyle(.accessoryLinear))
+            case "accessoryLinearCapacity":
+                return AnyView(view.gaugeStyle(.accessoryLinearCapacity))
+            case "linearCapacity":
+                return AnyView(view.gaugeStyle(.linearCapacity))
+            default:
+                return AnyView(view.gaugeStyle(.automatic))
+            }
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+import SwiftUI
+
+/// SwiftUI `.geometryGroup()`. Isolates the view's geometry from its
+/// parent so child layout/transform changes animate as one unit.
+/// Available on watchOS 10+; older systems return the view unchanged.
+enum RNWGeometryGroupModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("geometryGroup") { view, _, _ in
+            if #available(watchOS 10.0, *) {
+                return AnyView(view.geometryGroup())
+            }
+            return view
+        }
+    }
+}

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

@@ -0,0 +1,68 @@
+import SwiftUI
+
+/// SwiftUI `.gesture(_:)`.
+///
+/// **Limited (v1):** a general SwiftUI `Gesture` (drag/magnify/rotate,
+/// composed gestures, value payloads) cannot be expressed across the JS
+/// bridge. Only `tap` (→ `TapGesture`) and `longPress` (→ `LongPressGesture`)
+/// are supported. The JS `handler` id fires on the gesture's action
+/// (`.onEnded` for tap; the action closure for long press).
+enum RNWGestureModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("gesture") { view, params, ctx in
+            RNWGestureSupport.apply(.standard, to: view, params: params, ctx: ctx)
+        }
+    }
+}
+
+/// Shared gesture construction for `.gesture`, `.simultaneousGesture`, and
+/// `.highPriorityGesture`. `TapGesture` and `LongPressGesture` are distinct
+/// concrete types and watchOS 9 has no `AnyGesture`, so each combination of
+/// (gesture type × attach kind) is applied in its own branch.
+enum RNWGestureSupport {
+    /// Which SwiftUI gesture-attachment modifier to use.
+    enum Kind {
+        case standard
+        case simultaneous
+        case highPriority
+    }
+
+    @MainActor
+    static func apply(
+        _ kind: Kind,
+        to view: AnyView,
+        params: [String: Any],
+        ctx: RNWModifierContext
+    ) -> AnyView {
+        let handlerId = params.int("handler")
+        switch params.string("type") {
+        case "longPress":
+            let duration = params.double("minimumDuration") ?? 0.5
+            let g = LongPressGesture(minimumDuration: duration)
+                .onEnded { _ in ctx.fire(handlerId) }
+            return attach(kind, g, to: view)
+        default: // "tap" and unknown both map to a tap gesture
+            let count = params.int("count") ?? 1
+            let g = TapGesture(count: max(1, count))
+                .onEnded { ctx.fire(handlerId) }
+            return attach(kind, g, to: view)
+        }
+    }
+
+    @MainActor
+    private static func attach<G: Gesture>(
+        _ kind: Kind,
+        _ gesture: G,
+        to view: AnyView
+    ) -> AnyView {
+        switch kind {
+        case .standard:
+            return AnyView(view.gesture(gesture))
+        case .simultaneous:
+            return AnyView(view.simultaneousGesture(gesture))
+        case .highPriority:
+            return AnyView(view.highPriorityGesture(gesture))
+        }
+    }
+}

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

@@ -0,0 +1,49 @@
+import SwiftUI
+
+/// SwiftUI `.glassEffect(_:in:)` — watchOS 26 "Liquid Glass". Applies a
+/// Liquid Glass material to the view, clipped to a shape.
+///
+/// `variant` selects the `Glass` material (`regular` / `clear` / `identity`),
+/// `shape` the clip (`capsule` / `rect` / `circle` / `roundedRectangle`,
+/// the last reading `cornerRadius`). Defaults: `.regular` in `.capsule`.
+///
+/// Gated to watchOS 26+ — returns the view unchanged on older OS, since
+/// these APIs don't exist before "Liquid Glass".
+enum RNWGlassEffectModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("glassEffect") { view, params, _ in
+            guard #available(watchOS 26.0, *) else { return view }
+
+            let glass = makeGlass(params.string("variant"))
+            let shape = params.string("shape") ?? "capsule"
+            let cornerRadius = params.cgFloat("cornerRadius") ?? 0
+
+            // `glassEffect(_:in:)` takes `some Shape`, so the shape can't be
+            // type-erased without losing its identity for the morph system.
+            // Branch per concrete shape instead.
+            switch shape {
+            case "rect":
+                return AnyView(view.glassEffect(glass, in: Rectangle()))
+            case "circle":
+                return AnyView(view.glassEffect(glass, in: Circle()))
+            case "roundedRectangle":
+                return AnyView(view.glassEffect(
+                    glass,
+                    in: RoundedRectangle(cornerRadius: cornerRadius)
+                ))
+            default:
+                return AnyView(view.glassEffect(glass, in: Capsule()))
+            }
+        }
+    }
+
+    @available(watchOS 26.0, *)
+    private static func makeGlass(_ variant: String?) -> Glass {
+        switch variant {
+        case "clear":    return .clear
+        case "identity": return .identity
+        default:         return .regular
+        }
+    }
+}

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

@@ -0,0 +1,34 @@
+import SwiftUI
+
+/// SwiftUI `.glassEffectID(_:in:)` — watchOS 26 "Liquid Glass".
+///
+/// [LIMITED] The real API associates a glass element with a `Namespace.ID`
+/// shared across the views that should morph into one another. The bridge
+/// renders each native node independently and can't yet thread a single
+/// `@Namespace` through them, so we mint a *local* `@Namespace` per applied
+/// view (via a `ViewModifier` struct that can host the property wrapper).
+/// The `id` is honored within that view, but cross-view morph/union (which
+/// requires a shared namespace) is NOT bridged in v1.
+///
+/// Gated to watchOS 26+ — no-op on older OS.
+enum RNWGlassEffectIDModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("glassEffectID") { view, params, _ in
+            guard #available(watchOS 26.0, *) else { return view }
+            guard let id = params.string("id") else { return view }
+            return AnyView(view.modifier(GlassEffectIDImpl(id: id)))
+        }
+    }
+}
+
+/// Hosts the local `@Namespace` required by `glassEffectID(_:in:)`.
+@available(watchOS 26.0, *)
+private struct GlassEffectIDImpl: ViewModifier {
+    let id: String
+    @Namespace private var namespace
+
+    func body(content: Content) -> some View {
+        content.glassEffectID(id, in: namespace)
+    }
+}

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

@@ -0,0 +1,29 @@
+import SwiftUI
+
+/// SwiftUI `.glassEffectTransition(_:)` — watchOS 26 "Liquid Glass".
+/// Selects how a glass element animates as it's inserted or removed.
+///
+/// `transition`: `materialize` (default Liquid Glass materialize),
+/// `identity` (no transition), or `matchedGeometry` (driven from a
+/// matched-geometry source).
+///
+/// Gated to watchOS 26+ — returns the view unchanged on older OS.
+enum RNWGlassEffectTransitionModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("glassEffectTransition") { view, params, _ in
+            guard #available(watchOS 26.0, *) else { return view }
+
+            let transition: GlassEffectTransition
+            switch params.string("transition") {
+            case "identity":
+                transition = .identity
+            case "matchedGeometry":
+                transition = .matchedGeometry
+            default:
+                transition = .materialize
+            }
+            return AnyView(view.glassEffectTransition(transition))
+        }
+    }
+}

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

@@ -0,0 +1,35 @@
+import SwiftUI
+
+/// SwiftUI `.glassEffectUnion(id:namespace:)` — watchOS 26 "Liquid Glass".
+/// Merges multiple glass elements that share an `id` (and namespace) into a
+/// single continuous shape.
+///
+/// [LIMITED] The union is only meaningful when several sibling views share
+/// one `Namespace.ID`. The bridge renders nodes independently and can't yet
+/// share a single `@Namespace` across them, so we mint a *local* namespace
+/// per applied view (via a `ViewModifier` struct that can host the property
+/// wrapper) as a best effort. Real cross-view unions (multiple views melding
+/// into one shape) are NOT bridged in v1.
+///
+/// Gated to watchOS 26+ — no-op on older OS.
+enum RNWGlassEffectUnionModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("glassEffectUnion") { view, params, _ in
+            guard #available(watchOS 26.0, *) else { return view }
+            guard let id = params.string("id") else { return view }
+            return AnyView(view.modifier(GlassEffectUnionImpl(id: id)))
+        }
+    }
+}
+
+/// Hosts the local `@Namespace` required by `glassEffectUnion(id:namespace:)`.
+@available(watchOS 26.0, *)
+private struct GlassEffectUnionImpl: ViewModifier {
+    let id: String
+    @Namespace private var namespace
+
+    func body(content: Content) -> some View {
+        content.glassEffectUnion(id: id, namespace: namespace)
+    }
+}

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

@@ -0,0 +1,12 @@
+import SwiftUI
+
+/// SwiftUI `.grayscale(_:)`. Desaturates by `value`; `0` is unchanged,
+/// `1` is fully gray.
+enum RNWGrayscaleModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("grayscale") { view, params, _ in
+            AnyView(view.grayscale(params.double("value") ?? 0))
+        }
+    }
+}

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

@@ -0,0 +1,38 @@
+import SwiftUI
+
+/// SwiftUI `.gridCellAnchor(_:)`. Positions a view within its `Grid` cell.
+/// Accepts a named anchor or an explicit `{ x, y }` unit point. Available
+/// on watchOS 9+.
+enum RNWGridCellAnchorModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("gridCellAnchor") { view, params, _ in
+            let anchor = unitPoint(params["anchor"]) ?? .center
+            return AnyView(view.gridCellAnchor(anchor))
+        }
+    }
+
+    /// Map a named anchor string or an `{ x, y }` dict to a `UnitPoint`.
+    private static func unitPoint(_ raw: Any?) -> UnitPoint? {
+        if let s = raw as? String {
+            switch s {
+            case "center":         return .center
+            case "top":            return .top
+            case "bottom":         return .bottom
+            case "leading":        return .leading
+            case "trailing":       return .trailing
+            case "topLeading":     return .topLeading
+            case "topTrailing":    return .topTrailing
+            case "bottomLeading":  return .bottomLeading
+            case "bottomTrailing": return .bottomTrailing
+            default:               return nil
+            }
+        }
+        if let dict = raw as? [String: Any] {
+            let x = (dict["x"] as? NSNumber)?.doubleValue ?? 0
+            let y = (dict["y"] as? NSNumber)?.doubleValue ?? 0
+            return UnitPoint(x: x, y: y)
+        }
+        return nil
+    }
+}

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

@@ -0,0 +1,13 @@
+import SwiftUI
+
+/// SwiftUI `.gridCellColumns(_:)`. Makes a view span multiple `Grid`
+/// columns. Available on watchOS 9+.
+enum RNWGridCellColumnsModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("gridCellColumns") { view, params, _ in
+            let count = params.int("count") ?? 1
+            return AnyView(view.gridCellColumns(count))
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+import SwiftUI
+
+/// SwiftUI `.gridCellUnsizedAxes(_:)`. Opts a cell out of the `Grid`'s
+/// width/height sizing along the given axes. Available on watchOS 9+.
+enum RNWGridCellUnsizedAxesModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("gridCellUnsizedAxes") { view, params, _ in
+            return AnyView(view.gridCellUnsizedAxes(axisSet(params.string("axes"))))
+        }
+    }
+
+    private static func axisSet(_ s: String?) -> Axis.Set {
+        switch s {
+        case "horizontal": return .horizontal
+        case "vertical":   return .vertical
+        case "both":       return [.horizontal, .vertical]
+        default:           return []
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+import SwiftUI
+
+/// SwiftUI `.gridColumnAlignment(_:)`. Sets the horizontal alignment for the
+/// whole `Grid` column the modified cell sits in. Available on watchOS 9+.
+enum RNWGridColumnAlignmentModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("gridColumnAlignment") { view, params, _ in
+            let alignment = RNWAlignmentParser.horizontal(params.string("alignment"))
+            return AnyView(view.gridColumnAlignment(alignment))
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+import SwiftUI
+
+/// SwiftUI `.handGestureShortcut(_:)`. Assigns a view to a system
+/// hand-gesture shortcut (the Apple Watch double-tap / pinch gesture).
+/// Requires watchOS 11 — on older systems the view is returned unchanged.
+///
+/// `shortcut`: `.primaryAction` is the only hand-gesture shortcut on
+/// watchOS, so every value maps to it (`.counter` exists only on other
+/// platforms). The `shortcut` param is accepted for parity.
+enum RNWHandGestureShortcutModifier {
+    @MainActor
+    static func register(into r: RNWModifierRegistry) {
+        r.register("handGestureShortcut") { view, _, _ in
+            guard #available(watchOS 11.0, *) else { return view }
+            return AnyView(view.handGestureShortcut(.primaryAction))
+        }
+    }
+}