@appsent-co/react-native-watchos 0.1.0

package/src/modifiers/presentationDragIndicator.ts

@@ -0,0 +1,14 @@
+import { createModifier } from './createModifier';
+
+/// Visibility of a presentation's drag indicator. Mirrors SwiftUI's
+/// `Visibility`.
+export type DragIndicatorVisibility = 'automatic' | 'visible' | 'hidden';
+
+/// SwiftUI `.presentationDragIndicator(_:)`. Sets the visibility of the
+/// drag indicator on top of a sheet. Defaults to `'automatic'`, letting
+/// the system decide. Available on watchOS 9+.
+export function presentationDragIndicator(
+  visibility: DragIndicatorVisibility = 'automatic'
+) {
+  return createModifier('presentationDragIndicator', { visibility });
+}

package/src/modifiers/privacySensitive.ts

@@ -0,0 +1,8 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.privacySensitive(_:)`. Marks the subtree as containing private,
+/// user-sensitive content so the system can redact it when appropriate
+/// (e.g. on an inactive/wrist-down watch face). Defaults to `true`.
+export function privacySensitive(value: boolean = true) {
+  return createModifier('privacySensitive', { value });
+}

package/src/modifiers/progressViewStyle.ts

@@ -0,0 +1,10 @@
+import { createModifier } from './createModifier';
+
+export type ProgressViewStyle = 'automatic' | 'linear' | 'circular';
+
+/// SwiftUI `.progressViewStyle(_:)`. Sets the visual style applied to
+/// `ProgressView`s within the view. `'automatic'` defers to the platform
+/// default.
+export function progressViewStyle(style: ProgressViewStyle = 'automatic') {
+  return createModifier('progressViewStyle', { style });
+}

package/src/modifiers/projectionEffect.ts

@@ -0,0 +1,13 @@
+import { createModifier } from './createModifier';
+import type { AffineTransformParams } from './transformEffect';
+
+/// SwiftUI `.projectionEffect(_:)`. Bridged via the 2D affine subset:
+/// a `ProjectionTransform` is built from `CGAffineTransform(a:b:c:d:tx:ty:)`
+/// (same six components as `transformEffect`). Full 3D `CATransform3D`
+/// projections are NOT bridged — only affine projections are expressible
+/// here. Omitted components default to the identity matrix.
+export function projectionEffect(params: AffineTransformParams) {
+  return createModifier('projectionEffect', params);
+}
+
+export type { AffineTransformParams };

package/src/modifiers/redacted.ts

@@ -0,0 +1,12 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `RedactionReasons`. Only `'placeholder'` is expressible on
+/// watchOS today (it's the single public reason in the framework).
+export type RedactionReason = 'placeholder';
+
+/// SwiftUI `.redacted(reason:)`. Renders the subtree as a redacted
+/// placeholder (e.g. for skeleton / loading states). Defaults to
+/// `'placeholder'`.
+export function redacted(reason: RedactionReason = 'placeholder') {
+  return createModifier('redacted', { reason });
+}

package/src/modifiers/refreshable.ts

@@ -0,0 +1,10 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.refreshable { … }`. Marks the view as refreshable and fires
+/// `handler` when the user triggers a pull-to-refresh. The native closure
+/// is async; the handler is invoked once per refresh gesture. The bridge
+/// cannot await JS, so the refresh indicator dismisses as soon as the
+/// handler is fired rather than when JS work completes. watchOS 9+.
+export function refreshable(handler: () => void) {
+  return createModifier('refreshable', { handler });
+}

package/src/modifiers/renderingMode.ts

@@ -0,0 +1,11 @@
+import { createModifier } from './createModifier';
+
+export type RenderingMode = 'original' | 'template' | 'automatic';
+
+/// SwiftUI `.renderingMode(_:)`. Image-only.
+/// - `'template'` recolours the image with the current `foregroundColor`
+/// - `'original'` keeps the source colours
+/// - `'automatic'` (default) defers to SwiftUI's default for the asset
+export function renderingMode(mode: RenderingMode = 'automatic') {
+  return createModifier('renderingMode', { mode });
+}

package/src/modifiers/resizable.ts

@@ -0,0 +1,9 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.resizable()`. Image-only — makes the image stretch to fill
+/// the space allocated by layout (combined with `.aspectRatio` or a
+/// `.frame`). Without this, SwiftUI renders the image at its intrinsic
+/// pixel size.
+export function resizable() {
+  return createModifier('resizable');
+}

package/src/modifiers/rotation3DEffect.ts

@@ -0,0 +1,22 @@
+import { createModifier } from './createModifier';
+import type { TransformAnchor } from './rotationEffect';
+
+export interface Rotation3DEffectParams {
+  /// Rotation angle in degrees.
+  degrees: number;
+  /// X component of the rotation axis. Defaults to `0`.
+  axisX?: number;
+  /// Y component of the rotation axis. Defaults to `1` (rotate about Y).
+  axisY?: number;
+  /// Z component of the rotation axis. Defaults to `0`.
+  axisZ?: number;
+  /// 2D anchor point for the rotation. Defaults to `'center'`.
+  anchor?: TransformAnchor;
+}
+
+/// SwiftUI `.rotation3DEffect(_:axis:anchor:)`. Rotates the view about the
+/// 3D axis `(axisX, axisY, axisZ)` by `degrees`. The optional `anchorZ`
+/// and perspective parameters are not bridged; defaults are used.
+export function rotation3DEffect(params: Rotation3DEffectParams) {
+  return createModifier('rotation3DEffect', params);
+}

package/src/modifiers/rotationEffect.ts

@@ -0,0 +1,39 @@
+import { createModifier } from './createModifier';
+
+/// Anchor point for a transform, expressed as a named `UnitPoint`.
+export type TransformAnchor =
+  | 'center'
+  | 'top'
+  | 'bottom'
+  | 'leading'
+  | 'trailing'
+  | 'topLeading'
+  | 'topTrailing'
+  | 'bottomLeading'
+  | 'bottomTrailing';
+
+export interface RotationEffectParams {
+  /// Rotation angle in degrees (positive is clockwise).
+  degrees: number;
+  /// Point the view rotates about. Defaults to `'center'`.
+  anchor?: TransformAnchor;
+}
+
+/// SwiftUI `.rotationEffect(_:anchor:)`. Rotates the view in 2D by the
+/// given angle (degrees) about `anchor` without affecting layout.
+export function rotationEffect(
+  params: RotationEffectParams
+): ReturnType<typeof createModifier>;
+export function rotationEffect(
+  degrees: number,
+  anchor?: TransformAnchor
+): ReturnType<typeof createModifier>;
+export function rotationEffect(
+  a: RotationEffectParams | number,
+  b?: TransformAnchor
+) {
+  if (typeof a === 'number') {
+    return createModifier('rotationEffect', { degrees: a, anchor: b });
+  }
+  return createModifier('rotationEffect', a);
+}

package/src/modifiers/safeAreaInset.ts

@@ -0,0 +1,24 @@
+import type { ReactNode } from 'react';
+import { createModifier } from './createModifier';
+
+export type SafeAreaInsetEdge = 'top' | 'bottom' | 'leading' | 'trailing';
+
+export interface SafeAreaInsetParams {
+  /// Edge to inset and place `content` against. `'top'` / `'bottom'` use a
+  /// horizontal alignment; `'leading'` / `'trailing'` use a vertical one.
+  edge: SafeAreaInsetEdge;
+  /// Alignment of `content` along the edge. Defaults to `'center'`.
+  alignment?: string;
+  /// Spacing between `content` and the main view's content. Defaults to
+  /// SwiftUI's automatic spacing when omitted.
+  spacing?: number;
+  /// View rendered in the reserved safe-area inset region.
+  content: ReactNode;
+}
+
+/// SwiftUI `.safeAreaInset(edge:alignment:spacing:content:)`. Reserves space
+/// along an edge of the view and places `content` there, shrinking the main
+/// content's safe area to make room.
+export function safeAreaInset(params: SafeAreaInsetParams) {
+  return createModifier('safeAreaInset', params);
+}

package/src/modifiers/saturation.ts

@@ -0,0 +1,7 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.saturation(_:)`. Adjusts the color saturation of the view.
+/// `1` is unchanged, `0` is grayscale, and values `> 1` oversaturate.
+export function saturation(value: number) {
+  return createModifier('saturation', { value });
+}

package/src/modifiers/scaleEffect.ts

@@ -0,0 +1,33 @@
+import { createModifier } from './createModifier';
+import type { TransformAnchor } from './rotationEffect';
+
+export interface ScaleEffectParams {
+  /// Uniform scale applied to both axes. Overridden by `x` / `y` when set.
+  scale?: number;
+  /// Horizontal scale factor. Falls back to `scale`, then `1`.
+  x?: number;
+  /// Vertical scale factor. Falls back to `scale`, then `1`.
+  y?: number;
+  /// Anchor the scaling expands/contracts around. Defaults to `'center'`.
+  anchor?: TransformAnchor;
+}
+
+/// SwiftUI `.scaleEffect(x:y:anchor:)`. Scales the view's rendered output
+/// (not its layout). Pass a single number for a uniform scale, or an
+/// object for per-axis control.
+export function scaleEffect(
+  params: ScaleEffectParams
+): ReturnType<typeof createModifier>;
+export function scaleEffect(
+  scale: number,
+  anchor?: TransformAnchor
+): ReturnType<typeof createModifier>;
+export function scaleEffect(
+  a: ScaleEffectParams | number,
+  b?: TransformAnchor
+) {
+  if (typeof a === 'number') {
+    return createModifier('scaleEffect', { scale: a, anchor: b });
+  }
+  return createModifier('scaleEffect', a);
+}

package/src/modifiers/scaledTo.ts

@@ -0,0 +1,15 @@
+import { aspectRatio } from './aspectRatio';
+
+/// SwiftUI `.scaledToFit()`. Shorthand for `aspectRatio({ contentMode: 'fit' })`
+/// — fits the view inside its parent without cropping, preserving the
+/// intrinsic aspect ratio.
+export function scaledToFit() {
+  return aspectRatio({ contentMode: 'fit' });
+}
+
+/// SwiftUI `.scaledToFill()`. Shorthand for `aspectRatio({ contentMode: 'fill' })`
+/// — fills the parent's space, cropping overflow, preserving the
+/// intrinsic aspect ratio.
+export function scaledToFill() {
+  return aspectRatio({ contentMode: 'fill' });
+}

package/src/modifiers/scroll.ts

@@ -0,0 +1,45 @@
+// "Scroll" modifiers — SwiftUI scroll-container configuration.
+// One unit owns this file.
+export { scrollDisabled } from './scrollDisabled';
+export {
+  scrollIndicators,
+  type ScrollIndicatorVisibility,
+  type ScrollIndicatorsParams,
+} from './scrollIndicators';
+export {
+  scrollContentBackground,
+  type ScrollContentBackgroundVisibility,
+  type ScrollContentBackgroundParams,
+} from './scrollContentBackground';
+export {
+  scrollDismissesKeyboard,
+  type ScrollDismissesKeyboardMode,
+  type ScrollDismissesKeyboardParams,
+} from './scrollDismissesKeyboard';
+export {
+  scrollTargetBehavior,
+  type ScrollTargetBehaviorKind,
+  type ScrollTargetBehaviorParams,
+} from './scrollTargetBehavior';
+export { scrollTargetLayout } from './scrollTargetLayout';
+export {
+  scrollBounceBehavior,
+  type ScrollBounceBehaviorKind,
+  type ScrollBounceAxis,
+  type ScrollBounceBehaviorParams,
+} from './scrollBounceBehavior';
+export { scrollClipDisabled } from './scrollClipDisabled';
+export {
+  defaultScrollAnchor,
+  type DefaultScrollAnchorParams,
+} from './defaultScrollAnchor';
+export {
+  contentMargins,
+  type ContentMarginEdge,
+  type ContentMarginsParams,
+} from './contentMargins';
+export {
+  scrollPosition,
+  type ScrollPositionParams,
+} from './scrollPosition';
+export { refreshable } from './refreshable';

package/src/modifiers/scrollBounceBehavior.ts

@@ -0,0 +1,32 @@
+import { createModifier } from './createModifier';
+
+/// Maps to SwiftUI's `ScrollBounceBehavior`.
+export type ScrollBounceBehaviorKind = 'automatic' | 'always' | 'basedOnSize';
+
+/// Which axes the bounce behavior applies to.
+export type ScrollBounceAxis = 'horizontal' | 'vertical';
+
+export interface ScrollBounceBehaviorParams {
+  behavior: ScrollBounceBehaviorKind;
+  /// Axes the behavior applies to. Defaults to `['vertical']` to match
+  /// SwiftUI's default `axes: [.vertical]`.
+  axes?: ScrollBounceAxis | ScrollBounceAxis[];
+}
+
+/// SwiftUI `.scrollBounceBehavior(_:axes:)`. Configures the bounce
+/// behavior of scrollable views along the given axes. Gated to watchOS
+/// 10+ natively; a no-op on older systems.
+export function scrollBounceBehavior(
+  behavior: ScrollBounceBehaviorKind
+): ReturnType<typeof createModifier>;
+export function scrollBounceBehavior(
+  params: ScrollBounceBehaviorParams
+): ReturnType<typeof createModifier>;
+export function scrollBounceBehavior(
+  a: ScrollBounceBehaviorKind | ScrollBounceBehaviorParams
+) {
+  if (typeof a === 'string') {
+    return createModifier('scrollBounceBehavior', { behavior: a });
+  }
+  return createModifier('scrollBounceBehavior', a);
+}

package/src/modifiers/scrollClipDisabled.ts

@@ -0,0 +1,8 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.scrollClipDisabled(_:)`. Controls whether a scrollable view
+/// clips its content to its bounds. Gated to watchOS 10+ natively; a
+/// no-op on older systems.
+export function scrollClipDisabled(disabled = true) {
+  return createModifier('scrollClipDisabled', { disabled });
+}

package/src/modifiers/scrollContentBackground.ts

@@ -0,0 +1,29 @@
+import { createModifier } from './createModifier';
+
+/// Visibility maps to SwiftUI's `Visibility` enum.
+export type ScrollContentBackgroundVisibility =
+  | 'automatic'
+  | 'visible'
+  | 'hidden';
+
+export interface ScrollContentBackgroundParams {
+  visibility: ScrollContentBackgroundVisibility;
+}
+
+/// SwiftUI `.scrollContentBackground(_:)`. Controls whether the scroll
+/// view's background is visible (e.g. hide a `List`/`Form` background to
+/// show a custom one underneath). watchOS 9+.
+export function scrollContentBackground(
+  visibility: ScrollContentBackgroundVisibility
+): ReturnType<typeof createModifier>;
+export function scrollContentBackground(
+  params: ScrollContentBackgroundParams
+): ReturnType<typeof createModifier>;
+export function scrollContentBackground(
+  a: ScrollContentBackgroundVisibility | ScrollContentBackgroundParams
+) {
+  if (typeof a === 'string') {
+    return createModifier('scrollContentBackground', { visibility: a });
+  }
+  return createModifier('scrollContentBackground', a);
+}

package/src/modifiers/scrollDisabled.ts

@@ -0,0 +1,7 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.scrollDisabled(_:)`. Disables (or re-enables) scrolling of
+/// scrollable containers nested in this view. watchOS 9+.
+export function scrollDisabled(disabled = true) {
+  return createModifier('scrollDisabled', { disabled });
+}

package/src/modifiers/scrollDismissesKeyboard.ts

@@ -0,0 +1,30 @@
+import { createModifier } from './createModifier';
+
+/// Maps to SwiftUI's `ScrollDismissesKeyboardMode`.
+export type ScrollDismissesKeyboardMode =
+  | 'automatic'
+  | 'immediately'
+  | 'interactively'
+  | 'never';
+
+export interface ScrollDismissesKeyboardParams {
+  mode: ScrollDismissesKeyboardMode;
+}
+
+/// SwiftUI `.scrollDismissesKeyboard(_:)`. Configures how scrolling
+/// dismisses the keyboard. Gated to watchOS 10+ natively; a no-op on
+/// older systems.
+export function scrollDismissesKeyboard(
+  mode: ScrollDismissesKeyboardMode
+): ReturnType<typeof createModifier>;
+export function scrollDismissesKeyboard(
+  params: ScrollDismissesKeyboardParams
+): ReturnType<typeof createModifier>;
+export function scrollDismissesKeyboard(
+  a: ScrollDismissesKeyboardMode | ScrollDismissesKeyboardParams
+) {
+  if (typeof a === 'string') {
+    return createModifier('scrollDismissesKeyboard', { mode: a });
+  }
+  return createModifier('scrollDismissesKeyboard', a);
+}

package/src/modifiers/scrollIndicators.ts

@@ -0,0 +1,30 @@
+import { createModifier } from './createModifier';
+
+/// Visibility of scroll indicators. Maps to SwiftUI's
+/// `ScrollIndicatorVisibility`.
+export type ScrollIndicatorVisibility =
+  | 'automatic'
+  | 'visible'
+  | 'hidden'
+  | 'never';
+
+export interface ScrollIndicatorsParams {
+  visibility: ScrollIndicatorVisibility;
+}
+
+/// SwiftUI `.scrollIndicators(_:)`. Sets the visibility of scroll
+/// indicators within scrollable containers nested in this view. watchOS 9+.
+export function scrollIndicators(
+  visibility: ScrollIndicatorVisibility
+): ReturnType<typeof createModifier>;
+export function scrollIndicators(
+  params: ScrollIndicatorsParams
+): ReturnType<typeof createModifier>;
+export function scrollIndicators(
+  a: ScrollIndicatorVisibility | ScrollIndicatorsParams
+) {
+  if (typeof a === 'string') {
+    return createModifier('scrollIndicators', { visibility: a });
+  }
+  return createModifier('scrollIndicators', a);
+}

package/src/modifiers/scrollPosition.ts

@@ -0,0 +1,19 @@
+import { createModifier } from './createModifier';
+
+export interface ScrollPositionParams {
+  /// The id of the currently top-most/leading visible scroll target. Pair
+  /// with `scrollTargetLayout()` on the scrolled content so each child has
+  /// a stable id. Two-way: JS owns the value, native mirrors it in local
+  /// `@State` and reports user-driven changes through `onChange`.
+  id?: string | null;
+  /// Fired with the new id string (or `null`) when the scroll position
+  /// changes. Passed through as the `handler` param to the native side.
+  onChange?: (id: string | null) => void;
+}
+
+/// SwiftUI `.scrollPosition(id:)`. Binds the scroll position to a target
+/// id. Gated to watchOS 10+ natively; a no-op on older systems.
+export function scrollPosition(params: ScrollPositionParams = {}) {
+  const { onChange, ...rest } = params;
+  return createModifier('scrollPosition', { ...rest, handler: onChange });
+}

package/src/modifiers/scrollTargetBehavior.ts

@@ -0,0 +1,27 @@
+import { createModifier } from './createModifier';
+
+/// `paging` snaps a page at a time; `viewAligned` snaps to views marked
+/// with `scrollTargetLayout()`.
+export type ScrollTargetBehaviorKind = 'paging' | 'viewAligned';
+
+export interface ScrollTargetBehaviorParams {
+  behavior: ScrollTargetBehaviorKind;
+}
+
+/// SwiftUI `.scrollTargetBehavior(_:)`. Sets the scroll snapping behavior
+/// of the scrollable container. Gated to watchOS 10+ natively; a no-op on
+/// older systems.
+export function scrollTargetBehavior(
+  behavior: ScrollTargetBehaviorKind
+): ReturnType<typeof createModifier>;
+export function scrollTargetBehavior(
+  params: ScrollTargetBehaviorParams
+): ReturnType<typeof createModifier>;
+export function scrollTargetBehavior(
+  a: ScrollTargetBehaviorKind | ScrollTargetBehaviorParams
+) {
+  if (typeof a === 'string') {
+    return createModifier('scrollTargetBehavior', { behavior: a });
+  }
+  return createModifier('scrollTargetBehavior', a);
+}

package/src/modifiers/scrollTargetLayout.ts

@@ -0,0 +1,9 @@
+import { createModifier } from './createModifier';
+
+/// SwiftUI `.scrollTargetLayout()`. Marks a layout container (e.g. the
+/// `LazyVStack` inside a `ScrollView`) so its children become scroll
+/// targets for `scrollTargetBehavior('viewAligned')`. Gated to watchOS
+/// 10+ natively; a no-op on older systems.
+export function scrollTargetLayout() {
+  return createModifier('scrollTargetLayout');
+}

package/src/modifiers/search.ts

@@ -0,0 +1,21 @@
+// "Search polish" modifiers. Search-suggestion / search-toolbar refinements
+// for `.searchable` contexts. Some entries are iOS-only and apply as no-ops
+// on watchOS (see each factory's doc comment).
+export {
+  searchCompletion,
+  type SearchCompletionParams,
+} from './searchCompletion';
+export {
+  searchToolbarBehavior,
+  type SearchToolbarBehavior,
+  type SearchToolbarBehaviorParams,
+} from './searchToolbarBehavior';
+export {
+  searchPresentationToolbarBehavior,
+  type SearchPresentationToolbarBehavior,
+  type SearchPresentationToolbarBehaviorParams,
+} from './searchPresentationToolbarBehavior';
+export {
+  searchSuggestions,
+  type SearchSuggestionsParams,
+} from './searchSuggestions';

package/src/modifiers/searchCompletion.ts

@@ -0,0 +1,30 @@
+import { createModifier } from './createModifier';
+
+export interface SearchCompletionParams {
+  /// The completion string offered for the search field when this view is
+  /// tapped. Applied to a suggestion row inside a `.searchSuggestions` /
+  /// `.searchable` context — selecting the row fills the search field with
+  /// this text.
+  completion: string;
+}
+
+/// SwiftUI `.searchCompletion(_:)`.
+///
+/// Associates a completion string with a search-suggestion view. When the
+/// user taps the suggestion, the search field is filled with `completion`.
+/// Only meaningful on views presented as search suggestions (i.e. inside a
+/// `.searchSuggestions { … }` slot or a searchable scope); applied to any
+/// other view it is a harmless no-op.
+///
+/// Available on watchOS 9+ (the bridge deployment target), so no availability
+/// gate is required.
+export function searchCompletion(
+  params: SearchCompletionParams
+): ReturnType<typeof createModifier>;
+export function searchCompletion(
+  completion: string
+): ReturnType<typeof createModifier>;
+export function searchCompletion(a: SearchCompletionParams | string) {
+  if (typeof a === 'string') return createModifier('searchCompletion', { completion: a });
+  return createModifier('searchCompletion', a);
+}

package/src/modifiers/searchPresentationToolbarBehavior.ts

@@ -0,0 +1,31 @@
+import { createModifier } from './createModifier';
+
+export type SearchPresentationToolbarBehavior = 'automatic' | 'minimize';
+
+export interface SearchPresentationToolbarBehaviorParams {
+  /// How the toolbar behaves while search is presented.
+  /// - `'automatic'` — system default.
+  /// - `'minimize'` — minimize toolbar content while searching.
+  behavior: SearchPresentationToolbarBehavior;
+}
+
+/// SwiftUI `.searchPresentationToolbarBehavior(_:)`.
+///
+/// Configures the toolbar behaviour while a search presentation is active.
+/// This API is `unavailable` on watchOS (iOS 17.0+ / macOS 14.0+ only), so
+/// the native side applies it as a no-op. The factory exists for
+/// cross-platform source compatibility; it has no visible effect on watchOS.
+export function searchPresentationToolbarBehavior(
+  params: SearchPresentationToolbarBehaviorParams
+): ReturnType<typeof createModifier>;
+export function searchPresentationToolbarBehavior(
+  behavior: SearchPresentationToolbarBehavior
+): ReturnType<typeof createModifier>;
+export function searchPresentationToolbarBehavior(
+  a: SearchPresentationToolbarBehaviorParams | SearchPresentationToolbarBehavior
+) {
+  if (typeof a === 'string') {
+    return createModifier('searchPresentationToolbarBehavior', { behavior: a });
+  }
+  return createModifier('searchPresentationToolbarBehavior', a);
+}

package/src/modifiers/searchSuggestions.ts

@@ -0,0 +1,21 @@
+import type { ReactNode } from 'react';
+import { createModifier } from './createModifier';
+
+export interface SearchSuggestionsParams {
+  /// The suggestion views shown beneath a searchable field. Each child may
+  /// carry a `searchCompletion(...)` modifier so tapping it fills the search
+  /// field. Hoisted across the bridge as modifier content.
+  content: ReactNode;
+}
+
+/// SwiftUI `.searchSuggestions { … }`.
+///
+/// Supplies the suggestion views for a searchable context. Available on
+/// watchOS 9+ (the bridge deployment target); the native side still gates
+/// defensively and falls back to the unmodified view on older systems.
+///
+/// The suggestions only render when this view is also marked searchable; on
+/// a non-searchable view the modifier is an inert pass-through.
+export function searchSuggestions(params: SearchSuggestionsParams) {
+  return createModifier('searchSuggestions', params);
+}

package/src/modifiers/searchToolbarBehavior.ts

@@ -0,0 +1,27 @@
+import { createModifier } from './createModifier';
+
+export type SearchToolbarBehavior = 'automatic' | 'minimize';
+
+export interface SearchToolbarBehaviorParams {
+  /// How the search field behaves when integrated into a toolbar.
+  /// - `'automatic'` — system default placement/behaviour.
+  /// - `'minimize'` — collapse the search field into a button until tapped.
+  behavior: SearchToolbarBehavior;
+}
+
+/// SwiftUI `.searchToolbarBehavior(_:)`.
+///
+/// Controls how a toolbar-integrated search field minimizes. This API is
+/// `unavailable` on watchOS (iOS 17.1+ / macOS 14.1+ only), so the native
+/// side applies it as a no-op. The factory is provided for cross-platform
+/// source compatibility; the modifier has no visible effect on watchOS.
+export function searchToolbarBehavior(
+  params: SearchToolbarBehaviorParams
+): ReturnType<typeof createModifier>;
+export function searchToolbarBehavior(
+  behavior: SearchToolbarBehavior
+): ReturnType<typeof createModifier>;
+export function searchToolbarBehavior(a: SearchToolbarBehaviorParams | SearchToolbarBehavior) {
+  if (typeof a === 'string') return createModifier('searchToolbarBehavior', { behavior: a });
+  return createModifier('searchToolbarBehavior', a);
+}