@appsent-co/react-native-watchos 0.1.0

package/src/modifiers/filters.ts

@@ -0,0 +1,19 @@
+// "Filters & effects" modifiers.
+//
+// `visualEffect` is intentionally omitted: SwiftUI's
+// `.visualEffect { content, proxy in … }` takes a closure that mutates
+// the content using live `GeometryProxy` values, which has no static
+// JSON equivalent the bridge can express.
+export { blur, type BlurParams } from './blur';
+export { brightness } from './brightness';
+export { contrast } from './contrast';
+export { saturation } from './saturation';
+export { grayscale } from './grayscale';
+export { hueRotation, type HueRotationParams } from './hueRotation';
+export { colorInvert } from './colorInvert';
+export { colorMultiply } from './colorMultiply';
+export { blendMode, type BlendModeValue } from './blendMode';
+export { luminanceToAlpha } from './luminanceToAlpha';
+export { compositingGroup } from './compositingGroup';
+export { drawingGroup, type DrawingGroupParams } from './drawingGroup';
+export { geometryGroup } from './geometryGroup';

package/src/modifiers/fixedSize.ts

@@ -0,0 +1,17 @@
+import { createModifier } from './createModifier';
+
+export interface FixedSizeParams {
+  /// Fix the ideal width, so the view never compresses or stretches
+  /// horizontally.
+  horizontal?: boolean;
+  /// Fix the ideal height, so the view never compresses or stretches
+  /// vertically.
+  vertical?: boolean;
+}
+
+/// SwiftUI `.fixedSize()` / `.fixedSize(horizontal:vertical:)`. With no
+/// params the view is fixed at its ideal size on both axes. Pass
+/// `horizontal` / `vertical` booleans to fix only specific axes.
+export function fixedSize(params?: FixedSizeParams) {
+  return createModifier('fixedSize', params);
+}

package/src/modifiers/focusable.ts

@@ -0,0 +1,20 @@
+import { createModifier } from './createModifier';
+
+export interface FocusableParams {
+  /// Whether the view can receive focus. Defaults to `true`.
+  value?: boolean;
+}
+
+/// SwiftUI `.focusable(_:)`. Marks the view as able (or unable) to receive
+/// focus via the Digital Crown / accessibility focus. Pass a boolean directly
+/// or an object; omitting the value defaults to `true`.
+export function focusable(value?: boolean): ReturnType<typeof createModifier>;
+export function focusable(
+  params: FocusableParams
+): ReturnType<typeof createModifier>;
+export function focusable(arg?: boolean | FocusableParams) {
+  if (typeof arg === 'object') {
+    return createModifier('focusable', { value: arg.value ?? true });
+  }
+  return createModifier('focusable', { value: arg ?? true });
+}

package/src/modifiers/focused.ts

@@ -0,0 +1,17 @@
+import { createModifier } from './createModifier';
+
+export interface FocusedParams {
+  /// JS-owned source of truth for whether this view is focused. The native
+  /// side mirrors this into a `@FocusState` and converges on changes.
+  value: boolean;
+  /// Fired with the new boolean whenever focus enters or leaves the view.
+  handler?: (focused: boolean) => void;
+}
+
+/// SwiftUI `.focused(_:)` — a two-way focus binding. JS owns the focused
+/// state via `value`; the native side holds a `@FocusState` mirror so focus
+/// reflects immediately, fires `handler` with the new value on change, and
+/// converges back to the JS-supplied `value`. Params `value`, `handler`.
+export function focused(params: FocusedParams) {
+  return createModifier('focused', params);
+}

package/src/modifiers/font.ts

@@ -0,0 +1,48 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI semantic font sizes. Match `Font.largeTitle`, `.title`, etc.
+export type FontStyle =
+  | 'largeTitle'
+  | 'title'
+  | 'title2'
+  | 'title3'
+  | 'headline'
+  | 'subheadline'
+  | 'body'
+  | 'callout'
+  | 'footnote'
+  | 'caption'
+  | 'caption2';
+
+/// SwiftUI `Font.Weight` values.
+export type FontWeight =
+  | 'ultraLight'
+  | 'thin'
+  | 'light'
+  | 'regular'
+  | 'medium'
+  | 'semibold'
+  | 'bold'
+  | 'heavy'
+  | 'black';
+
+export interface FontParams {
+  /// SwiftUI semantic style (`'body'`, `'headline'`, …). Wins over `size`
+  /// when both are set — matching SwiftUI's `Font.title.weight(...)` API.
+  style?: FontStyle;
+  /// System font size in points. Ignored when `style` is set.
+  size?: number;
+  weight?: FontWeight;
+}
+
+/// SwiftUI `.font(_:)`. Pass a number for a system font of that size,
+/// a style string for a semantic font, or an object combining both.
+export function font(params?: FontParams | FontStyle | number) {
+  if (typeof params === 'number') {
+    return createModifier('font', { size: params });
+  }
+  if (typeof params === 'string') {
+    return createModifier('font', { style: params });
+  }
+  return createModifier('font', params);
+}

package/src/modifiers/fontDesign.ts

@@ -0,0 +1,18 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `Font.Design` values.
+export type FontDesign = 'default' | 'serif' | 'rounded' | 'monospaced';
+
+export interface FontDesignParams {
+  design?: FontDesign;
+}
+
+/// SwiftUI `.fontDesign(_:)` (watchOS 9+). Overrides the font design of
+/// text within the view — e.g. `'rounded'` for SF Rounded. Pass a design
+/// string directly or an object.
+export function fontDesign(params?: FontDesignParams | FontDesign) {
+  if (typeof params === 'string') {
+    return createModifier('fontDesign', { design: params });
+  }
+  return createModifier('fontDesign', params);
+}

package/src/modifiers/fontWeight.ts

@@ -0,0 +1,15 @@
+import { createModifier } from './createModifier';
+import type { FontWeight } from './font';
+
+export interface FontWeightParams {
+  weight?: FontWeight;
+}
+
+/// SwiftUI `.fontWeight(_:)`. Sets the stroke weight of text within the
+/// view. Pass a weight string directly or an object.
+export function fontWeight(params?: FontWeightParams | FontWeight) {
+  if (typeof params === 'string') {
+    return createModifier('fontWeight', { weight: params });
+  }
+  return createModifier('fontWeight', params);
+}

package/src/modifiers/foregroundColor.ts

@@ -0,0 +1,9 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.foregroundColor(_:)`. Sets the tint of foreground content
+/// (text glyphs, template images, SF Symbols). The color string supports
+/// named colors (`'red'`, …), SwiftUI semantic colors (`'primary'`,
+/// `'secondary'`, `'accent'`), and `#RRGGBB` / `#RRGGBBAA`.
+export function foregroundColor(color: string) {
+  return createModifier('foregroundColor', { color });
+}

package/src/modifiers/foregroundStyle.ts

@@ -0,0 +1,11 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.foregroundStyle(_:)`. Sets the style of foreground content
+/// (text glyphs, template images, SF Symbols). The `style` string supports
+/// named / `#RRGGBB` / `#RRGGBBAA` colors, SwiftUI semantic colors
+/// (`'primary'`, `'secondary'`, `'accent'`), hierarchical levels
+/// (`'primary'`, `'secondary'`, `'tertiary'`, `'quaternary'`), `'tint'`,
+/// and (watchOS 10+) materials (`'ultraThinMaterial'`, …).
+export function foregroundStyle(style: string) {
+  return createModifier('foregroundStyle', { style });
+}

package/src/modifiers/formStyle.ts

@@ -0,0 +1,10 @@
+import { createModifier } from './createModifier';
+
+export type FormStyle = 'automatic' | 'columns' | 'grouped';
+
+/// SwiftUI `.formStyle(_:)`. Sets the visual style applied to `Form`s
+/// within the view (watchOS 9+). `'automatic'` defers to the platform
+/// default.
+export function formStyle(style: FormStyle = 'automatic') {
+  return createModifier('formStyle', { style });
+}

package/src/modifiers/frame.ts

@@ -0,0 +1,34 @@
+import { createModifier } from './createModifier';
+
+export type FrameAlignment =
+  | 'leading'
+  | 'trailing'
+  | 'center'
+  | 'top'
+  | 'bottom'
+  | 'topLeading'
+  | 'topTrailing'
+  | 'bottomLeading'
+  | 'bottomTrailing';
+
+export interface FrameParams {
+  /// Fixed width. When set, `minWidth` / `maxWidth` are ignored.
+  width?: number;
+  /// Fixed height. When set, `minHeight` / `maxHeight` are ignored.
+  height?: number;
+  minWidth?: number;
+  /// Pass `Infinity` to fill the available width (SwiftUI's `.infinity`).
+  maxWidth?: number;
+  minHeight?: number;
+  /// Pass `Infinity` to fill the available height (SwiftUI's `.infinity`).
+  maxHeight?: number;
+  /// Where to position the view's content within the laid-out frame.
+  /// Defaults to `center`, matching SwiftUI.
+  alignment?: FrameAlignment;
+}
+
+/// SwiftUI `.frame(width:height:alignment:)` / `.frame(min/maxWidth:…)`.
+/// To fill the screen, pass `{ maxWidth: Infinity, maxHeight: Infinity }`.
+export function frame(params: FrameParams = {}) {
+  return createModifier('frame', params);
+}

package/src/modifiers/fullScreenCover.ts

@@ -0,0 +1,29 @@
+import type { ReactNode } from 'react';
+import { createModifier } from './createModifier';
+
+export interface FullScreenCoverParams {
+  /// Whether the cover is shown. JS owns the source of truth; the native
+  /// side mirrors it in local `@State` and converges on the JS value.
+  isPresented: boolean;
+  /// Fired with the new boolean whenever the presentation state changes.
+  onChange?: (isPresented: boolean) => void;
+  /// The cover's content.
+  content: ReactNode;
+}
+
+/// SwiftUI `.fullScreenCover(isPresented:content:)`.
+///
+/// LIMITATION: `.fullScreenCover` is unavailable on watchOS, so the native
+/// side falls back to `.sheet(isPresented:)`. On a watch a sheet already
+/// occupies (nearly) the full screen, so the visual result is close; the
+/// only difference is that the fallback sheet remains interactively
+/// dismissable. The JS surface is kept distinct so callers can express
+/// intent and so a future watchOS that adds the API can upgrade in place.
+export function fullScreenCover(params: FullScreenCoverParams) {
+  const { isPresented, onChange, content } = params;
+  return createModifier('fullScreenCover', {
+    isPresented,
+    handler: onChange,
+    content,
+  });
+}

package/src/modifiers/gaugeStyle.ts

@@ -0,0 +1,17 @@
+import { createModifier } from './createModifier';
+
+export type GaugeStyle =
+  | 'automatic'
+  | 'accessoryCircular'
+  | 'accessoryCircularCapacity'
+  | 'accessoryLinear'
+  | 'accessoryLinearCapacity'
+  | 'linearCapacity';
+
+/// SwiftUI `.gaugeStyle(_:)`. Sets the visual style applied to `Gauge`s
+/// within the view. `'automatic'` defers to the platform default. Some
+/// capacity styles require newer watchOS; unsupported values leave the
+/// view unchanged on older systems.
+export function gaugeStyle(style: GaugeStyle = 'automatic') {
+  return createModifier('gaugeStyle', { style });
+}

package/src/modifiers/geometry.ts

@@ -0,0 +1,17 @@
+// "Geometry hooks" modifiers.
+export { coordinateSpace, type CoordinateSpaceParams } from './coordinateSpace';
+export {
+  matchedGeometryEffect,
+  type MatchedGeometryEffectParams,
+  type MatchedGeometryProperty,
+} from './matchedGeometryEffect';
+export {
+  matchedTransitionSource,
+  type MatchedTransitionSourceParams,
+} from './matchedTransitionSource';
+export {
+  navigationTransition,
+  type NavigationTransitionParams,
+  type NavigationTransitionType,
+} from './navigationTransition';
+export { onGeometryChange, type GeometrySize } from './onGeometryChange';

package/src/modifiers/geometryGroup.ts

@@ -0,0 +1,8 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.geometryGroup()`. Isolates the view's geometry from its
+/// parent so child layout/transform changes animate as one unit. Native
+/// support requires watchOS 10+; on older systems it is a no-op.
+export function geometryGroup() {
+  return createModifier('geometryGroup');
+}

package/src/modifiers/gesture.ts

@@ -0,0 +1,30 @@
+import { createModifier } from './createModifier';
+
+/// The kind of gesture to attach. Only `'tap'` and `'longPress'` are
+/// bridgeable in v1 — a general SwiftUI `Gesture` value (drag, magnify,
+/// rotate, composed gestures, value payloads) cannot cross the JS bridge,
+/// so it is intentionally unsupported.
+export type GestureType = 'tap' | 'longPress';
+
+export interface GestureParams {
+  /// Which gesture to recognize. Defaults to `'tap'`.
+  type?: GestureType;
+  /// For `type: 'tap'` — the number of taps required to fire. Defaults to 1.
+  count?: number;
+  /// For `type: 'longPress'` — minimum press duration in seconds before the
+  /// gesture fires. Defaults to SwiftUI's standard long-press duration.
+  minimumDuration?: number;
+  /// Fired when the gesture completes (tap recognized / long press ended).
+  handler: () => void;
+}
+
+/// SwiftUI `.gesture(_:)`.
+///
+/// **Limited (v1):** only `'tap'` (building a `TapGesture`) and `'longPress'`
+/// (building a `LongPressGesture`) are bridged. An arbitrary SwiftUI
+/// `Gesture` — including drag/magnify/rotate, gesture composition, and
+/// gestures that emit value payloads — is not expressible across the bridge.
+/// `handler` is invoked on `.onEnded` (the gesture's action).
+export function gesture(params: GestureParams) {
+  return createModifier('gesture', params);
+}

package/src/modifiers/gestures.ts

@@ -0,0 +1,14 @@
+// "Gestures" modifiers barrel. Owned by the Gestures unit.
+export { allowsHitTesting } from './allowsHitTesting';
+export {
+  contentShape,
+  type ContentShapeKind,
+  type ContentShapeParams,
+} from './contentShape';
+export {
+  springLoadingBehavior,
+  type SpringLoadingBehaviorValue,
+} from './springLoadingBehavior';
+export { gesture, type GestureParams, type GestureType } from './gesture';
+export { simultaneousGesture } from './simultaneousGesture';
+export { highPriorityGesture } from './highPriorityGesture';

package/src/modifiers/glass.ts

@@ -0,0 +1,25 @@
+// "Glass (watchOS 26)" modifiers — SwiftUI Liquid Glass. Every modifier in
+// this unit is gated to watchOS 26+ on the native side and is a no-op on
+// older OS versions.
+export {
+  glassEffect,
+  type GlassEffectParams,
+  type GlassVariant,
+  type GlassShape,
+} from './glassEffect';
+export { glassEffectID, type GlassEffectIDParams } from './glassEffectID';
+export {
+  glassEffectTransition,
+  type GlassEffectTransitionParams,
+  type GlassEffectTransitionType,
+} from './glassEffectTransition';
+export {
+  glassEffectUnion,
+  type GlassEffectUnionParams,
+} from './glassEffectUnion';
+export {
+  materialActiveAppearance,
+  type MaterialActiveAppearanceParams,
+  type MaterialActiveAppearanceMode,
+} from './materialActiveAppearance';
+export { backgroundExtensionEffect } from './backgroundExtensionEffect';

package/src/modifiers/glassEffect.ts

@@ -0,0 +1,26 @@
+import { createModifier } from './createModifier';
+
+/// The `Glass` material variant. `regular` is the default frosted glass;
+/// `clear` is a more transparent variant; `identity` is a no-op pass-through
+/// (useful for conditionally disabling the effect while keeping layout stable).
+export type GlassVariant = 'regular' | 'clear' | 'identity';
+
+/// The clipping shape the glass is rendered into. `roundedRectangle` reads
+/// the optional `cornerRadius` param (defaults to 0).
+export type GlassShape = 'capsule' | 'rect' | 'circle' | 'roundedRectangle';
+
+export interface GlassEffectParams {
+  /// Glass material variant. Defaults to `regular`.
+  variant?: GlassVariant;
+  /// Shape the glass is clipped to. Defaults to `capsule`.
+  shape?: GlassShape;
+  /// Corner radius — only used when `shape` is `roundedRectangle`.
+  cornerRadius?: number;
+}
+
+/// SwiftUI `.glassEffect(_:in:)` (watchOS 26 "Liquid Glass"). Applies a
+/// Liquid Glass background to the view, clipped to `shape`. No-op on
+/// watchOS < 26 (the native side returns the view unchanged).
+export function glassEffect(params: GlassEffectParams = {}) {
+  return createModifier('glassEffect', params);
+}

package/src/modifiers/glassEffectID.ts

@@ -0,0 +1,19 @@
+import { createModifier } from './createModifier';
+
+export interface GlassEffectIDParams {
+  /// Identifier associating this glass element with others in the same
+  /// container so they can morph/merge during transitions.
+  id: string;
+}
+
+/// SwiftUI `.glassEffectID(_:in:)` (watchOS 26 "Liquid Glass").
+///
+/// [LIMITED] The real API requires a `Namespace.ID` shared across the views
+/// that should morph into one another. The bridge can't yet share a single
+/// `@Namespace` across independently-rendered native nodes, so the native
+/// side uses a *local* namespace per applied view. The `id` is still honored
+/// within that view, but cross-view union/morph animations (which need a
+/// shared namespace) are not bridged in v1.
+export function glassEffectID(id: string) {
+  return createModifier('glassEffectID', { id });
+}

package/src/modifiers/glassEffectTransition.ts

@@ -0,0 +1,24 @@
+import { createModifier } from './createModifier';
+
+/// How a glass element animates in/out as it appears or disappears.
+/// `materialize` is the default Liquid Glass materialize transition;
+/// `identity` disables the transition; `matchedGeometry` drives the
+/// transition from a matched-geometry source.
+export type GlassEffectTransitionType =
+  | 'materialize'
+  | 'identity'
+  | 'matchedGeometry';
+
+export interface GlassEffectTransitionParams {
+  /// The transition style. Defaults to `materialize`.
+  transition?: GlassEffectTransitionType;
+}
+
+/// SwiftUI `.glassEffectTransition(_:)` (watchOS 26 "Liquid Glass").
+/// Controls how the glass effect transitions when the view is inserted or
+/// removed. No-op on watchOS < 26.
+export function glassEffectTransition(
+  transition: GlassEffectTransitionType = 'materialize'
+) {
+  return createModifier('glassEffectTransition', { transition });
+}

package/src/modifiers/glassEffectUnion.ts

@@ -0,0 +1,19 @@
+import { createModifier } from './createModifier';
+
+export interface GlassEffectUnionParams {
+  /// Union identifier. Views sharing the same `id` (and namespace) merge
+  /// their glass shapes into a single continuous element.
+  id: string;
+}
+
+/// SwiftUI `.glassEffectUnion(id:namespace:)` (watchOS 26 "Liquid Glass").
+///
+/// [LIMITED] Merging multiple glass elements into one shape requires a
+/// `Namespace.ID` shared across all the participating views. The bridge can't
+/// yet share one `@Namespace` across independently-rendered native nodes, so
+/// the native side falls back to a *local* namespace per applied view —
+/// honoring `id` within that view as a best effort. True cross-view unions
+/// (multiple sibling views melding) are not bridged in v1.
+export function glassEffectUnion(id: string) {
+  return createModifier('glassEffectUnion', { id });
+}

package/src/modifiers/grayscale.ts

@@ -0,0 +1,7 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.grayscale(_:)`. Desaturates the view by `value`, where `0`
+/// leaves colors unchanged and `1` is fully gray.
+export function grayscale(value: number) {
+  return createModifier('grayscale', { value });
+}

package/src/modifiers/gridCellAnchor.ts

@@ -0,0 +1,36 @@
+import { createModifier } from './createModifier';
+
+/// A named anchor point, or an explicit unit point in the 0...1 space
+/// (`{ x: 0, y: 0 }` is the top-leading corner, `{ x: 1, y: 1 }` is
+/// bottom-trailing).
+export type GridCellAnchor =
+  | 'center'
+  | 'top'
+  | 'bottom'
+  | 'leading'
+  | 'trailing'
+  | 'topLeading'
+  | 'topTrailing'
+  | 'bottomLeading'
+  | 'bottomTrailing'
+  | { x: number; y: number };
+
+export interface GridCellAnchorParams {
+  /// The unit point within the cell that the view is anchored to.
+  anchor: GridCellAnchor;
+}
+
+/// SwiftUI `.gridCellAnchor(_:)`. Positions a view within its `Grid` cell
+/// (overriding the grid's default alignment for that one cell).
+export function gridCellAnchor(
+  params: GridCellAnchorParams
+): ReturnType<typeof createModifier>;
+export function gridCellAnchor(
+  anchor: GridCellAnchor
+): ReturnType<typeof createModifier>;
+export function gridCellAnchor(a: GridCellAnchorParams | GridCellAnchor) {
+  if (typeof a === 'object' && a !== null && 'anchor' in a) {
+    return createModifier('gridCellAnchor', a);
+  }
+  return createModifier('gridCellAnchor', { anchor: a });
+}

package/src/modifiers/gridCellColumns.ts

@@ -0,0 +1,21 @@
+import { createModifier } from './createModifier';
+
+export interface GridCellColumnsParams {
+  /// Number of columns this cell should span.
+  count: number;
+}
+
+/// SwiftUI `.gridCellColumns(_:)`. Tells the enclosing `Grid` that a view
+/// spans `count` columns.
+export function gridCellColumns(
+  params: GridCellColumnsParams
+): ReturnType<typeof createModifier>;
+export function gridCellColumns(
+  count: number
+): ReturnType<typeof createModifier>;
+export function gridCellColumns(a: GridCellColumnsParams | number) {
+  if (typeof a === 'number') {
+    return createModifier('gridCellColumns', { count: a });
+  }
+  return createModifier('gridCellColumns', a);
+}

package/src/modifiers/gridCellUnsizedAxes.ts

@@ -0,0 +1,27 @@
+import { createModifier } from './createModifier';
+
+/// Axes along which the cell should NOT inflate to the row/column size.
+export type GridCellUnsizedAxesValue = 'horizontal' | 'vertical' | 'both';
+
+export interface GridCellUnsizedAxesParams {
+  /// The axes to leave unsized. Use `'both'` to opt out of grid sizing on
+  /// both axes (e.g. for a `Divider` that should keep its intrinsic size).
+  axes: GridCellUnsizedAxesValue;
+}
+
+/// SwiftUI `.gridCellUnsizedAxes(_:)`. Prevents a cell from filling the
+/// width/height the `Grid` would otherwise impose along the given axes.
+export function gridCellUnsizedAxes(
+  params: GridCellUnsizedAxesParams
+): ReturnType<typeof createModifier>;
+export function gridCellUnsizedAxes(
+  axes: GridCellUnsizedAxesValue
+): ReturnType<typeof createModifier>;
+export function gridCellUnsizedAxes(
+  a: GridCellUnsizedAxesParams | GridCellUnsizedAxesValue
+) {
+  if (typeof a === 'string') {
+    return createModifier('gridCellUnsizedAxes', { axes: a });
+  }
+  return createModifier('gridCellUnsizedAxes', a);
+}

package/src/modifiers/gridColumnAlignment.ts

@@ -0,0 +1,27 @@
+import { createModifier } from './createModifier';
+
+/// Horizontal alignment guide for a `Grid` column.
+export type GridColumnAlignmentGuide = 'leading' | 'center' | 'trailing';
+
+export interface GridColumnAlignmentParams {
+  /// The horizontal alignment to apply to the whole column this cell sits
+  /// in.
+  alignment: GridColumnAlignmentGuide;
+}
+
+/// SwiftUI `.gridColumnAlignment(_:)`. Overrides the horizontal alignment
+/// for the entire `Grid` column containing the modified cell.
+export function gridColumnAlignment(
+  params: GridColumnAlignmentParams
+): ReturnType<typeof createModifier>;
+export function gridColumnAlignment(
+  alignment: GridColumnAlignmentGuide
+): ReturnType<typeof createModifier>;
+export function gridColumnAlignment(
+  a: GridColumnAlignmentParams | GridColumnAlignmentGuide
+) {
+  if (typeof a === 'string') {
+    return createModifier('gridColumnAlignment', { alignment: a });
+  }
+  return createModifier('gridColumnAlignment', a);
+}

package/src/modifiers/handGestureShortcut.ts

@@ -0,0 +1,30 @@
+import { createModifier } from './createModifier';
+
+/// Which system hand-gesture (double-tap / pinch) action a view opts into.
+/// `primaryAction` maps to `HandGestureShortcut.primaryAction` (treat as the
+/// view's primary action); `counter` maps to `HandGestureShortcut.counter`.
+export type HandGestureShortcutKind = 'primaryAction' | 'counter';
+
+export interface HandGestureShortcutParams {
+  /// The hand-gesture action this view should respond to.
+  shortcut: HandGestureShortcutKind;
+}
+
+/// SwiftUI `.handGestureShortcut(_:)` — assigns a view (typically a `Button`)
+/// to a system hand-gesture shortcut so it can be triggered by the Apple Watch
+/// double-tap / pinch gesture. Requires watchOS 10; on older systems the view
+/// is returned unchanged.
+export function handGestureShortcut(
+  shortcut: HandGestureShortcutKind
+): ReturnType<typeof createModifier>;
+export function handGestureShortcut(
+  params: HandGestureShortcutParams
+): ReturnType<typeof createModifier>;
+export function handGestureShortcut(
+  arg: HandGestureShortcutKind | HandGestureShortcutParams
+) {
+  if (typeof arg === 'string') {
+    return createModifier('handGestureShortcut', { shortcut: arg });
+  }
+  return createModifier('handGestureShortcut', arg);
+}

package/src/modifiers/headerProminence.ts

@@ -0,0 +1,11 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `Prominence` values for section headers.
+export type Prominence = 'standard' | 'increased';
+
+/// SwiftUI `.headerProminence(_:)`. Sets the prominence of section headers
+/// within the view — `'increased'` gives list section headers a larger,
+/// more emphasized appearance.
+export function headerProminence(value: Prominence) {
+  return createModifier('headerProminence', { value });
+}