@appsent-co/react-native-watchos 0.1.0

package/src/createNativeView.ts

@@ -0,0 +1,28 @@
+import { createElement, type FC } from 'react';
+
+import type { CommonProps } from './types';
+import { useModifiers } from './useModifiers';
+
+/// Build a React component that, when rendered, asks the reconciler to
+/// create a native node with the given SwiftUI view name. Component
+/// files in `src/components/` are typically one line:
+///   `export const VStack = createNativeView<VStackProps>('VStack');`
+///
+/// The `name` is forwarded as-is to the C++ shadow tree and used by
+/// the Swift-side `RNWViewRegistry` to pick the renderer. `useModifiers`
+/// rewrites the `modifiers` prop so callback / content modifiers work
+/// (function → handler id, element → hoisted `__ModifierContent` child).
+export function createNativeView<P extends object>(
+  name: string
+): FC<P & CommonProps> {
+  const Component: FC<P & CommonProps> = (props) => {
+    const { modifiers, children } = useModifiers(props.modifiers, props.children);
+    return createElement(name, {
+      ...props,
+      modifiers,
+      children,
+    } as Record<string, unknown>);
+  };
+  Component.displayName = name;
+  return Component;
+}

package/src/devSupport/index.ts

@@ -0,0 +1,287 @@
+// Side-effect module: install React Refresh + connect to Metro's HMR
+// endpoint. Import this BEFORE any module that pulls in React, otherwise
+// `injectIntoGlobalHook` lands after React has already cached the runtime
+// and Refresh registrations are silently ignored.
+//
+//   // example/index.watchos.tsx
+//   import '@appsent-co/react-native-watchos/dev-support';
+//   import { render } from '@appsent-co/react-native-watchos/renderer';
+//   …
+//
+// The Swift host injects `globalThis.__RNW_DEV_SERVER` with the dev-server
+// host/port/entry parsed from the bundle URL. If that global isn't present
+// (production build, static bundle, etc.), this module is a no-op.
+
+// Side-effect import — installs `setImmediate`/`clearImmediate` globals
+// before any consumer code (including React's scheduler) reads them.
+// Idempotent; safe to run again from the renderer's own import chain.
+import '../polyfills';
+
+// Bare-minimum runtime shape we depend on. The real interface in
+// `react-refresh/runtime` is larger; we just name the bits we touch.
+interface RefreshRuntime {
+  injectIntoGlobalHook(global: unknown): void;
+  register(type: unknown, id: string): void;
+  createSignatureFunctionForTransform(): (
+    type: unknown,
+    key: string,
+    forceReset?: boolean,
+    getCustomHooks?: () => unknown[]
+  ) => unknown;
+  isLikelyComponentType(type: unknown): boolean;
+  getFamilyByType(type: unknown): unknown;
+  performReactRefresh(): void;
+}
+
+interface DevServerInfo {
+  host: string;
+  port: number;
+  entry: string;
+  scheme: 'http' | 'https';
+}
+
+// Metro's polyfill reads `global.__ReactRefresh` once per module load.
+// We populate it before any other module evaluates (this file is the
+// first thing the entry imports), so by the time React itself loads it
+// already sees the hook.
+interface ReactRefreshGlobal {
+  register: RefreshRuntime['register'];
+  createSignatureFunctionForTransform: RefreshRuntime['createSignatureFunctionForTransform'];
+  isLikelyComponentType: RefreshRuntime['isLikelyComponentType'];
+  getFamilyByType: RefreshRuntime['getFamilyByType'];
+  performReactRefresh(): void;
+  performFullRefresh(reason: string): void;
+}
+
+// `__DEV__` is a Metro-defined global, true only for dev bundles. Guarding
+// the whole side effect on it lets Metro dead-code-eliminate this entire
+// module from production bundles.
+declare const __DEV__: boolean;
+
+// `require`, `console`, and `setTimeout` aren't in tsconfig's `lib`
+// (ESNext only — no DOM, no Node). Bridge them through globalThis the
+// same way `createHostConfig.ts` does for timers.
+declare const require: (id: string) => unknown;
+const g = globalThis as unknown as {
+  __DEV__?: boolean;
+  __RNW_DEV_SERVER?: DevServerInfo;
+  __METRO_GLOBAL_PREFIX__?: string;
+  WebSocket?: new (url: string) => unknown;
+  console: {
+    log(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+  };
+  setTimeout: (cb: () => void, ms?: number) => number;
+  [key: string]: unknown;
+};
+
+if (typeof __DEV__ !== 'undefined' && __DEV__) {
+  install();
+}
+
+function install(): void {
+  // `react-refresh/runtime` must resolve from a node_modules visible to the
+  // consumer's bundle. Consumers using pnpm need to add `react-refresh` as
+  // an explicit dep (it's a transitive of react-native but pnpm strict
+  // mode doesn't hoist transitives). See example/package.json.
+  let refresh: RefreshRuntime;
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    refresh = require('react-refresh/runtime') as RefreshRuntime;
+  } catch (e) {
+    g.console.warn(
+      '@appsent-co/react-native-watchos: react-refresh/runtime not found — HMR disabled. ' +
+        'Add `react-refresh` to your app dependencies.'
+    );
+    return;
+  }
+
+  refresh.injectIntoGlobalHook(globalThis);
+
+  const refreshGlobal: ReactRefreshGlobal = {
+    register: refresh.register,
+    createSignatureFunctionForTransform:
+      refresh.createSignatureFunctionForTransform,
+    isLikelyComponentType: refresh.isLikelyComponentType,
+    getFamilyByType: refresh.getFamilyByType,
+    performReactRefresh() {
+      refresh.performReactRefresh();
+    },
+    performFullRefresh(reason: string) {
+      // The Swift host installs `__RNW_RELOAD` — fire-and-forget; it hops
+      // off the JS callstack and triggers a fresh bundle download + eval.
+      // Fall back to a console warning + the shake-to-reload dev menu if
+      // we're somehow running against an older host.
+      const reload = (g as { __RNW_RELOAD?: () => void }).__RNW_RELOAD;
+      if (typeof reload === 'function') {
+        g.console.warn(`Fast Refresh: full reload (${reason})`);
+        reload();
+        return;
+      }
+      g.console.warn(
+        `@appsent-co/react-native-watchos: full refresh requested (${reason}) — no ` +
+          'reload handler installed; shake the watch to reload.'
+      );
+    },
+  };
+  const prefix = g.__METRO_GLOBAL_PREFIX__ ?? '';
+  g[prefix + '__ReactRefresh'] = refreshGlobal;
+
+  const dev = g.__RNW_DEV_SERVER;
+  if (!dev) {
+    // Either the consumer is using a static bundle, or the Swift host is
+    // older than this dev-support module. Refresh hooks are still installed,
+    // so a manual reload still picks up new component definitions.
+    return;
+  }
+  if (typeof g.WebSocket !== 'function') {
+    g.console.warn(
+      '@appsent-co/react-native-watchos: globalThis.WebSocket missing — HMR transport disabled.'
+    );
+    return;
+  }
+  connect(dev);
+}
+
+// Minimal HMR client. The wire format mirrors `metro-runtime`'s HMRClient
+// exactly — `register-entrypoints`, `update`, `update-done`, `error` —
+// but we inline it here so the library doesn't need `metro-runtime` to be
+// resolvable from its own package directory.
+function connect(dev: DevServerInfo): void {
+  const scheme = dev.scheme === 'https' ? 'wss' : 'ws';
+  const wsURL = `${scheme}://${dev.host}:${dev.port}/hot`;
+  const entryURL =
+    `${dev.scheme}://${dev.host}:${dev.port}/hot?` +
+    `bundleEntry=${encodeURIComponent(dev.entry)}&platform=watchos`;
+
+  const WS = g.WebSocket as new (url: string) => {
+    onopen: ((e: unknown) => void) | null;
+    onmessage: ((e: { data: string }) => void) | null;
+    onerror: ((e: { message?: string }) => void) | null;
+    onclose: ((e: { code?: number; reason?: string }) => void) | null;
+    send(data: string): void;
+    close(): void;
+  };
+
+  let socket: ReturnType<typeof connectOnce> | null = null;
+  let reconnectTimer: number | undefined;
+  let attempt = 0;
+
+  // Reconnect with backoff so Metro restarts don't strand the runtime
+  // permanently. Cap at 10s to keep the dev loop snappy.
+  const scheduleReconnect = (): void => {
+    if (reconnectTimer != null) return;
+    const delay = Math.min(10000, 500 * Math.pow(2, attempt));
+    attempt += 1;
+    reconnectTimer = g.setTimeout(() => {
+      reconnectTimer = undefined;
+      socket = connectOnce();
+    }, delay);
+  };
+
+  const connectOnce = (): { ws: InstanceType<typeof WS> } => {
+    const ws = new WS(wsURL);
+    let open = false;
+
+    ws.onopen = () => {
+      open = true;
+      attempt = 0;
+      ws.send(
+        JSON.stringify({
+          type: 'register-entrypoints',
+          entryPoints: [entryURL],
+        })
+      );
+      // Opt into log forwarding so the dev server can surface client logs.
+      ws.send(JSON.stringify({ type: 'log-opt-in' }));
+    };
+
+    ws.onmessage = (event) => {
+      let msg: { type: string; body?: unknown };
+      try {
+        msg = JSON.parse(event.data);
+      } catch {
+        return;
+      }
+      switch (msg.type) {
+        case 'bundle-registered':
+        case 'update-start':
+        case 'update-done':
+          break;
+        case 'update': {
+          const body = msg.body as
+            | undefined
+            | {
+                added?: { module: [number, string]; sourceURL: string }[];
+                modified?: { module: [number, string]; sourceURL: string }[];
+                deleted?: number[];
+              };
+          if (!body) break;
+          const inject = (item: {
+            module: [number, string];
+            sourceURL: string;
+          }): void => {
+            const [id, code] = item.module;
+            try {
+              const evalWithUrl = (
+                g as unknown as {
+                  globalEvalWithSourceUrl?: (
+                    code: string,
+                    sourceURL: string
+                  ) => unknown;
+                }
+              ).globalEvalWithSourceUrl;
+              if (typeof evalWithUrl === 'function') {
+                evalWithUrl(code, item.sourceURL);
+              } else {
+                // Hermes always provides eval(); fall back to it. Stack
+                // traces just lose their sourceURL annotation.
+                // eslint-disable-next-line no-eval
+                (0, eval)(code);
+              }
+            } catch (e) {
+              const err = e as { message?: string; stack?: string };
+              g.console.error(
+                `HMR eval failed for module ${id}: ${err?.message ?? e}`
+              );
+              if (err?.stack) g.console.error(err.stack);
+            }
+          };
+          body.added?.forEach(inject);
+          body.modified?.forEach(inject);
+          // Metro's HMRClient ignores `deleted` IDs — the module's
+          // accept-handler stops re-running its body, which is enough.
+          break;
+        }
+        case 'error':
+          g.console.error('HMR error', msg.body);
+          break;
+        default:
+          break;
+      }
+    };
+
+    ws.onerror = (e) => {
+      if (!open) {
+        // Connect failure (Metro not up yet, or wrong host). Reconnect
+        // attempts will keep trying until Metro shows up.
+        g.console.warn('HMR connect failed:', e?.message ?? 'unknown');
+      }
+    };
+
+    ws.onclose = () => {
+      open = false;
+      scheduleReconnect();
+    };
+
+    return { ws };
+  };
+
+  socket = connectOnce();
+  // Touch `socket` to keep TS happy — the reference is held implicitly
+  // by the WebSocket itself (URLSession retains the task), but we want
+  // a JS reference too so it isn't collected if the runtime ever adds a
+  // GC roundtrip beyond the WHATWG spec.
+  (g as { __RNW_HMR_SOCKET?: typeof socket }).__RNW_HMR_SOCKET = socket;
+}

package/src/eventRegistry.ts

@@ -0,0 +1,110 @@
+/// JS-side bridge endpoint for native → JS events.
+///
+/// Two parallel registries live behind `globalThis.__RNW_EVENTS`:
+///
+///   - `dispatch(id, payload)` — id-keyed table, used by SwiftUI action
+///     closures (`onPress`, `onChange`, …). The renderer registers a
+///     callback via `registerHandler` and embeds the returned numeric id
+///     in the shadow node prop. Numbers cross the FFI cleanly; closures
+///     don't.
+///
+///   - `dispatchEvent(name, payload)` — name-keyed fan-out, used by
+///     `RCTEventEmitter sendEventWithName:body:` on the native side and
+///     the `NativeEventEmitter` shim on the JS side. Multiple listeners
+///     per name are supported; the fan-out iterates the set.
+///
+/// The bridge install is idempotent — `installEventBridge` is safe to
+/// call multiple times (the render module does it on import).
+
+type Handler = (payload?: unknown) => void;
+
+const handlers = new Map<number, Handler>();
+let nextId = 1;
+
+/// Register a JS callback and get a stable numeric id back. The returned
+/// id is what gets sent across the bridge as the `onPress` / `onChange`
+/// prop value. Call `unregisterHandler` on unmount to free the slot.
+export function registerHandler(fn: Handler): number {
+  const id = nextId++;
+  handlers.set(id, fn);
+  return id;
+}
+
+export function unregisterHandler(id: number): void {
+  handlers.delete(id);
+}
+
+const eventListeners = new Map<string, Set<Handler>>();
+
+/// Register a listener for events fired by name (via the native
+/// `RCTEventEmitter`). Returns a disposer; many listeners can share one
+/// name and all of them fire on dispatch.
+export function registerEventListener(name: string, fn: Handler): () => void {
+  let set = eventListeners.get(name);
+  if (set == null) {
+    set = new Set();
+    eventListeners.set(name, set);
+  }
+  set.add(fn);
+  return () => {
+    const current = eventListeners.get(name);
+    if (current == null) return;
+    current.delete(fn);
+    if (current.size === 0) eventListeners.delete(name);
+  };
+}
+
+// `console` lives on globalThis (installed by RNWHermesHost) but isn't in
+// the TS lib's ESNext target. Reach for it via globalThis for the type.
+const g = globalThis as unknown as {
+  console?: { error: (...args: unknown[]) => void };
+};
+
+/// Invoked by the native side via `globalThis.__RNW_EVENTS.dispatch`.
+/// Stale ids (handlers freed between event scheduling and firing) are
+/// silently dropped — the native side doesn't know about React's
+/// unmount lifecycle.
+function dispatch(id: number, payload?: unknown): void {
+  const fn = handlers.get(id);
+  if (fn === undefined) return;
+  try {
+    fn(payload);
+  } catch (e) {
+    // Don't let a user handler error tear down the runtime. The thrown
+    // value surfaces to Metro via console.error (RNWHermesHost forwards
+    // every console.* through onConsoleLog → reportToMetro).
+    g.console?.error('event handler threw:', e);
+  }
+}
+
+/// Invoked by the native side via `globalThis.__RNW_EVENTS.dispatchEvent`.
+/// Events fired before any listener is registered are silently dropped
+/// (matches the iOS behavior of events firing before `addListener`).
+function dispatchEvent(name: string, payload?: unknown): void {
+  const set = eventListeners.get(name);
+  if (set === undefined) return;
+  for (const fn of set) {
+    try {
+      fn(payload);
+    } catch (e) {
+      g.console?.error('event listener threw:', e);
+    }
+  }
+}
+
+let installed = false;
+
+/// Install `globalThis.__RNW_EVENTS = { dispatch, dispatchEvent }` so the
+/// native side can find the dispatchers. Called once, on render-module
+/// import (and again, idempotently, from the `NativeEventEmitter` shim).
+export function installEventBridge(): void {
+  if (installed) return;
+  installed = true;
+  const g = globalThis as unknown as {
+    __RNW_EVENTS?: {
+      dispatch: typeof dispatch;
+      dispatchEvent: typeof dispatchEvent;
+    };
+  };
+  g.__RNW_EVENTS = { dispatch, dispatchEvent };
+}

package/src/index.ts

@@ -0,0 +1,160 @@
+// Side-effect import — installs `setImmediate`/`clearImmediate` globals
+// before React's scheduler captures them at module-init time.
+import './polyfills';
+
+// Components — built-in SwiftUI views.
+export { Text, type TextProps } from './components/Text';
+export { VStack, type VStackProps } from './components/VStack';
+export { HStack, type HStackProps } from './components/HStack';
+export { LazyVStack, type LazyVStackProps } from './components/LazyVStack';
+export { LazyHStack, type LazyHStackProps } from './components/LazyHStack';
+export { ZStack, type ZStackProps } from './components/ZStack';
+export { Group, type GroupProps } from './components/Group';
+export { Spacer, type SpacerProps } from './components/Spacer';
+export { Divider } from './components/Divider';
+export { Rectangle } from './components/Rectangle';
+export {
+  RoundedRectangle,
+  type RoundedRectangleProps,
+} from './components/RoundedRectangle';
+export { Circle } from './components/Circle';
+export { Ellipse } from './components/Ellipse';
+export { Capsule } from './components/Capsule';
+export { Color, type ColorProps } from './components/Color';
+export { ScrollView, type ScrollViewProps } from './components/ScrollView';
+export { ScrollViewReader } from './components/ScrollViewReader';
+export {
+  ViewThatFits,
+  type ViewThatFitsProps,
+} from './components/ViewThatFits';
+export { GeometryReader } from './components/GeometryReader';
+export { Button, type ButtonProps } from './components/Button';
+export { Toggle, type ToggleProps } from './components/Toggle';
+export { Slider, type SliderProps } from './components/Slider';
+export { Stepper, type StepperProps } from './components/Stepper';
+export { Picker, type PickerProps } from './components/Picker';
+export { DatePicker, type DatePickerProps } from './components/DatePicker';
+export { TextField, type TextFieldProps } from './components/TextField';
+export { SecureField, type SecureFieldProps } from './components/SecureField';
+export { Image, type ImageProps } from './components/Image';
+export { AsyncImage, type AsyncImageProps } from './components/AsyncImage';
+export { Label, type LabelProps } from './components/Label';
+export { List, type ListProps } from './components/List';
+export { Section, type SectionProps } from './components/Section';
+export { Form, type FormProps } from './components/Form';
+export { TabView, type TabViewProps } from './components/TabView';
+export {
+  NavigationStack,
+  type NavigationStackProps,
+} from './components/NavigationStack';
+export {
+  NavigationLink,
+  type NavigationLinkProps,
+} from './components/NavigationLink';
+export {
+  ProgressView,
+  type ProgressViewProps,
+} from './components/ProgressView';
+export { Gauge, type GaugeProps } from './components/Gauge';
+export { EmptyView } from './components/EmptyView';
+export { LazyVGrid, type LazyVGridProps } from './components/LazyVGrid';
+export { LazyHGrid, type LazyHGridProps } from './components/LazyHGrid';
+export { gridItem, type GridItem } from './types/GridItem';
+export { Grid, type GridProps } from './components/Grid';
+export { GridRow, type GridRowProps } from './components/GridRow';
+export {
+  LabeledContent,
+  type LabeledContentProps,
+} from './components/LabeledContent';
+export {
+  ContentUnavailableView,
+  type ContentUnavailableViewProps,
+} from './components/ContentUnavailableView';
+export { Link, type LinkProps } from './components/Link';
+export { ShareLink, type ShareLinkProps } from './components/ShareLink';
+export {
+  TimelineView,
+  type TimelineViewProps,
+  type TimelineSchedule,
+} from './components/TimelineView';
+export {
+  LinearGradient,
+  type LinearGradientProps,
+  type UnitPoint,
+  type UnitPointName,
+} from './components/LinearGradient';
+export {
+  RadialGradient,
+  type RadialGradientProps,
+} from './components/RadialGradient';
+export {
+  AngularGradient,
+  type AngularGradientProps,
+} from './components/AngularGradient';
+
+// Component-authoring helpers.
+export { createNativeView } from './createNativeView';
+export type { ViewModifier, CommonProps } from './types';
+
+// Modifier factories — composed via the `modifiers` prop on any view.
+export { padding, type PaddingParams } from './modifiers/padding';
+export { background } from './modifiers/background';
+export { foregroundColor } from './modifiers/foregroundColor';
+export {
+  font,
+  type FontParams,
+  type FontStyle,
+  type FontWeight,
+} from './modifiers/font';
+export { aspectRatio, type AspectRatioParams } from './modifiers/aspectRatio';
+export { resizable } from './modifiers/resizable';
+export { renderingMode, type RenderingMode } from './modifiers/renderingMode';
+export {
+  interpolation,
+  type InterpolationLevel,
+} from './modifiers/interpolation';
+export { antialiased } from './modifiers/antialiased';
+export { scaledToFit, scaledToFill } from './modifiers/scaledTo';
+export {
+  frame,
+  type FrameParams,
+  type FrameAlignment,
+} from './modifiers/frame';
+export {
+  animation,
+  type AnimationParams,
+  type AnimationCurve,
+} from './modifiers/animation';
+export { navigationTitle } from './modifiers/navigationTitle';
+
+// Modifier units (batch). Each barrel is filled by its work unit; the
+// `export *` picks up every factory + type that unit adds. Modifiers above
+// are NOT re-exported from these barrels (units skip already-shipped ones).
+export * from './modifiers/layout';
+export * from './modifiers/styling';
+export * from './modifiers/text';
+export * from './modifiers/interaction';
+export * from './modifiers/watch';
+export * from './modifiers/navigation';
+export * from './modifiers/lists';
+export * from './modifiers/componentStyles';
+export * from './modifiers/input';
+export * from './modifiers/imageSymbol';
+export * from './modifiers/accessibility';
+export * from './modifiers/filters';
+export * from './modifiers/transforms';
+export * from './modifiers/scroll';
+export * from './modifiers/toolbar';
+export * from './modifiers/presentation';
+export * from './modifiers/containerGrid';
+export * from './modifiers/theme';
+export * from './modifiers/controlsPolish';
+export * from './modifiers/textPolish';
+export * from './modifiers/search';
+export * from './modifiers/geometry';
+export * from './modifiers/gestures';
+export * from './modifiers/environment';
+export * from './modifiers/glass';
+
+// Renderer entry point.
+export { render } from './render';

package/src/modifiers/accessibility.ts

@@ -0,0 +1,27 @@
+// "Accessibility & identity" modifiers. Re-exports every factory + type
+// this unit adds; picked up by `src/index.ts` via `export *`.
+export { accessibilityLabel } from './accessibilityLabel';
+export { accessibilityHint } from './accessibilityHint';
+export { accessibilityValue } from './accessibilityValue';
+export { accessibilityIdentifier } from './accessibilityIdentifier';
+export { accessibilityHidden } from './accessibilityHidden';
+export {
+  accessibilityAddTraits,
+  type AccessibilityTrait,
+} from './accessibilityAddTraits';
+export { accessibilityRemoveTraits } from './accessibilityRemoveTraits';
+export {
+  accessibilityElement,
+  type AccessibilityChildBehavior,
+} from './accessibilityElement';
+export { id } from './id';
+export { tag } from './tag';
+export {
+  accessibilityAction,
+  type AccessibilityActionKind,
+  type AccessibilityActionParams,
+} from './accessibilityAction';
+export {
+  accessibilityActions,
+  type AccessibilityActionsParams,
+} from './accessibilityActions';

package/src/modifiers/accessibilityAction.ts

@@ -0,0 +1,22 @@
+import { createModifier } from './createModifier';
+
+/// Kind of a SwiftUI named accessibility action. Omit for the default
+/// (un-named) action.
+/// - `'default'` — the element's primary action
+/// - `'escape'` — a two-finger Z scrub / dismiss gesture
+/// - `'magicTap'` — a two-finger double-tap
+export type AccessibilityActionKind = 'default' | 'escape' | 'magicTap';
+
+export interface AccessibilityActionParams {
+  /// Which built-in action this handler responds to. Defaults to the
+  /// element's `'default'` action.
+  kind?: AccessibilityActionKind;
+  /// Invoked when the action fires.
+  handler: () => void;
+}
+
+/// SwiftUI `.accessibilityAction(_:_:)`. Registers a handler for a built-in
+/// accessibility action so assistive-technology users can trigger it.
+export function accessibilityAction(params: AccessibilityActionParams) {
+  return createModifier('accessibilityAction', params);
+}

package/src/modifiers/accessibilityActions.ts

@@ -0,0 +1,15 @@
+import type { ReactNode } from 'react';
+import { createModifier } from './createModifier';
+
+export interface AccessibilityActionsParams {
+  /// A view (typically `Button`s) declaring the actions available to
+  /// assistive technologies for this element.
+  content: ReactNode;
+}
+
+/// SwiftUI `.accessibilityActions(_:)` (watchOS 10+). Declares a set of
+/// custom accessibility actions from the provided content. On watchOS 9 the
+/// modifier is a no-op and the view is returned unchanged.
+export function accessibilityActions(params: AccessibilityActionsParams) {
+  return createModifier('accessibilityActions', params);
+}

package/src/modifiers/accessibilityAddTraits.ts

@@ -0,0 +1,23 @@
+import { createModifier } from './createModifier';
+
+/// A SwiftUI `AccessibilityTraits` member.
+export type AccessibilityTrait =
+  | 'isButton'
+  | 'isHeader'
+  | 'isImage'
+  | 'isLink'
+  | 'isSelected'
+  | 'isSummaryElement'
+  | 'startsMediaSession'
+  | 'updatesFrequently'
+  | 'playsSound'
+  | 'allowsDirectInteraction';
+
+/// SwiftUI `.accessibilityAddTraits(_:)`. Adds one or more traits that
+/// describe the view's behaviour to assistive technologies. Pass a single
+/// trait or an array; an array is combined into one `AccessibilityTraits`.
+export function accessibilityAddTraits(
+  traits: AccessibilityTrait | AccessibilityTrait[]
+) {
+  return createModifier('accessibilityAddTraits', { traits });
+}