react-native-platform-components 1.4.0 → 1.6.0

package/lib/module/jest.js

@@ -0,0 +1,840 @@
+"use strict";
+
+// jest.tsx
+//
+// Jest mock of the library, published as `react-native-platform-components/jest`:
+//
+//   jest.mock('react-native-platform-components', () =>
+//     require('react-native-platform-components/jest')
+//   );
+//
+// The native components can't render under Jest, so each one is rebuilt from
+// React Native primitives (TextInput, Pressable, Text, View) that
+// @testing-library/react-native can query and drive. Props are typed against
+// the real components, and the pure helpers are the real ones.
+
+import React, { forwardRef, useCallback, useImperativeHandle, useRef, useState } from 'react';
+import { Pressable, Text, TextInput, View } from 'react-native';
+import { resolveIcon } from "./icons.js";
+import { resolveSubmitBehavior } from "./submitBehavior.js";
+import { nextSelection } from "./web/ButtonGroup.js";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+export * from "./icons.js";
+export * from "./labelStyle.js";
+
+/** Same as the real export: an alias of {@link resolveIcon}. */
+export const resolveSegmentIcon = resolveIcon;
+
+/**
+ * Props that are handlers but not React Native view props, passed onto a
+ * host view so `fireEvent(element, 'select', ...)` can reach them.
+ */
+function handlers(props) {
+  const out = {};
+  for (const [key, value] of Object.entries(props)) {
+    if (typeof value === 'function') out[key] = value;
+  }
+  return out;
+}
+function withText(event, extra) {
+  const base = event ?? {};
+  return {
+    ...base,
+    nativeEvent: {
+      ...base.nativeEvent,
+      ...extra
+    }
+  };
+}
+
+// ---------------------------------------------------------------------------
+// TextField
+
+/**
+ * A `TextInput` carrying `testID`, with the label, prefix, suffix, supporting
+ * or error text and character count as `Text`. A trailing icon renders as a
+ * button with the test ID `trailingIconTestID`, else
+ * `${testID}-trailing-icon`; a leading icon with `leadingIconTestID` renders
+ * as a view with that ID. A non-editable field with `onPress` calls it when
+ * the input is pressed. The iOS keyboard toolbar's buttons render as
+ * buttons with their `testID`, else `${testID}-toolbar-${id}`; Done
+ * (`doneTestID`, else `${testID}-toolbar-done`) calls `onBlur`.
+ */
+export const TextField = /*#__PURE__*/forwardRef(function TextFieldMock(props, ref) {
+  const {
+    value,
+    defaultValue,
+    onChangeText,
+    onChange,
+    onFocus,
+    onBlur,
+    onSubmitEditing,
+    submitBehavior,
+    onSelectionChange,
+    selection,
+    label,
+    placeholder,
+    supportingText,
+    error,
+    prefix,
+    suffix,
+    leadingIcon,
+    trailingIcon,
+    onTrailingIconPress,
+    leadingIconTestID,
+    leadingIconAccessibilityLabel,
+    trailingIconTestID,
+    trailingIconAccessibilityLabel,
+    onPress,
+    activeColor,
+    outlineColor,
+    errorColor,
+    containerColor,
+    textColor,
+    placeholderTextColor,
+    maxFontSizeMultiplier,
+    textAlign,
+    minLines,
+    maxLines,
+    clearButtonMode,
+    passwordToggle,
+    showCharacterCount,
+    maxLength,
+    keyboardType,
+    returnKeyType,
+    autoCapitalize,
+    autoCorrect,
+    secureTextEntry,
+    multiline,
+    editable,
+    autoFocus,
+    selectTextOnFocus,
+    autoComplete,
+    keyboardAppearance,
+    textStyle,
+    accessibilityLabel,
+    ios,
+    android,
+    testID,
+    ...viewProps
+  } = props;
+  const inputRef = useRef(null);
+  const focused = useRef(false);
+  const eventCount = useRef(0);
+  const [uncontrolled, setUncontrolled] = useState(defaultValue ?? '');
+  const text = value ?? uncontrolled;
+  const handleChangeText = useCallback(next => {
+    eventCount.current += 1;
+    setUncontrolled(next);
+    onChange?.(withText(undefined, {
+      text: next,
+      eventCount: eventCount.current
+    }));
+    onChangeText?.(next);
+  }, [onChange, onChangeText]);
+  useImperativeHandle(ref, () => ({
+    focus: () => {
+      focused.current = true;
+      inputRef.current?.focus?.();
+    },
+    blur: () => {
+      focused.current = false;
+      inputRef.current?.blur?.();
+    },
+    clear: () => handleChangeText(''),
+    isFocused: () => focused.current,
+    setSelection: (start, end) => {
+      inputRef.current?.setSelection?.(start, end ?? start);
+    }
+  }), [handleChangeText]);
+  const handleFocus = event => {
+    focused.current = true;
+    onFocus?.(withText(event, {
+      text
+    }));
+  };
+  const handleBlur = event => {
+    focused.current = false;
+    onBlur?.(withText(event, {
+      text
+    }));
+  };
+  const handleSubmit = event => {
+    onSubmitEditing?.(withText(event, {
+      text
+    }));
+  };
+  const helper = typeof error === 'string' && error ? error : supportingText;
+  const toolbar = ios?.keyboardToolbar;
+  return /*#__PURE__*/_jsxs(View, {
+    ...viewProps,
+    children: [label ? /*#__PURE__*/_jsx(Text, {
+      children: label
+    }) : null, leadingIconTestID ? /*#__PURE__*/_jsx(View, {
+      testID: leadingIconTestID,
+      accessibilityLabel: leadingIconAccessibilityLabel
+    }) : null, prefix ? /*#__PURE__*/_jsx(Text, {
+      children: prefix
+    }) : null, /*#__PURE__*/_jsx(TextInput, {
+      ref: inputRef,
+      testID: testID,
+      value: text,
+      onChangeText: handleChangeText,
+      onFocus: handleFocus,
+      onBlur: handleBlur,
+      onSubmitEditing: handleSubmit,
+      submitBehavior: resolveSubmitBehavior(submitBehavior, multiline),
+      selection: selection ? {
+        start: selection.start,
+        end: selection.end ?? selection.start
+      } : undefined,
+      onSelectionChange: onSelectionChange,
+      placeholder: placeholder,
+      editable: editable,
+      onPress: editable === false ? onPress : undefined,
+      multiline: multiline,
+      secureTextEntry: secureTextEntry,
+      maxLength: maxLength,
+      keyboardType: keyboardType,
+      returnKeyType: returnKeyType,
+      autoCapitalize: autoCapitalize,
+      autoCorrect: autoCorrect,
+      autoFocus: autoFocus,
+      selectTextOnFocus: selectTextOnFocus,
+      autoComplete: autoComplete,
+      keyboardAppearance: keyboardAppearance,
+      accessibilityLabel: accessibilityLabel ?? label,
+      accessibilityState: {
+        disabled: editable === false
+      },
+      "aria-invalid": error ? true : undefined
+    }), suffix ? /*#__PURE__*/_jsx(Text, {
+      children: suffix
+    }) : null, trailingIcon || onTrailingIconPress ? /*#__PURE__*/_jsx(Pressable, {
+      testID: trailingIconTestID ?? (testID ? `${testID}-trailing-icon` : undefined),
+      accessibilityLabel: trailingIconAccessibilityLabel,
+      accessibilityRole: "button",
+      onPress: () => onTrailingIconPress?.()
+    }) : null, helper ? /*#__PURE__*/_jsx(Text, {
+      children: helper
+    }) : null, toolbar?.items?.map((item, index) => item === 'flexibleSpace' ? null : /*#__PURE__*/_jsx(Pressable, {
+      testID: item.testID ?? (testID ? `${testID}-toolbar-${item.id}` : undefined),
+      accessibilityLabel: item.accessibilityLabel ?? item.title,
+      accessibilityRole: "button",
+      onPress: () => toolbar.onItemPress?.(item.id)
+    }, `${item.id}-${index}`)), toolbar?.done ? /*#__PURE__*/_jsx(Pressable, {
+      testID: toolbar.doneTestID ?? (testID ? `${testID}-toolbar-done` : undefined),
+      accessibilityLabel: typeof toolbar.done === 'string' ? toolbar.done : 'Done',
+      accessibilityRole: "button",
+      onPress: () => {
+        focused.current = false;
+        onBlur?.(withText(undefined, {
+          text
+        }));
+      }
+    }) : null, showCharacterCount ? /*#__PURE__*/_jsx(Text, {
+      children: maxLength ? `${text.length} / ${maxLength}` : `${text.length}`
+    }) : null]
+  });
+});
+TextField.displayName = 'TextField';
+
+// ---------------------------------------------------------------------------
+// Button, ButtonGroup, SegmentedControl
+
+/**
+ * A `Pressable` with the button role and the label as `Text`. While
+ * `loading` it ignores presses and reports `busy`. With `selected` it is a
+ * `togglebutton` (`accessibilityState.checked`) and a press calls
+ * `onSelectedChange(!selected)`. A button with a `menu` doesn't call
+ * `onPress`; `fireEvent(button, 'menuSelect', id, title)`, `'menuOpen'` and
+ * `'menuClose'` reach the menu callbacks.
+ */
+export function Button(props) {
+  const {
+    label,
+    icon,
+    iconPosition,
+    variant,
+    size,
+    shape,
+    cornerRadius,
+    disabled,
+    loading,
+    color,
+    tintColor,
+    disabledColor,
+    disabledTintColor,
+    labelStyle,
+    maxFontSizeMultiplier,
+    accessibilityLabel,
+    accessibilityState,
+    haptics,
+    onPress,
+    selected,
+    onSelectedChange,
+    menu,
+    onMenuSelect,
+    onMenuOpen,
+    onMenuClose,
+    ios,
+    android,
+    ...viewProps
+  } = props;
+  const isToggle = selected !== undefined;
+  const hasMenu = !!menu && menu.length > 0;
+  return /*#__PURE__*/_jsx(Pressable, {
+    ...viewProps,
+    ...handlers({
+      onMenuSelect,
+      onMenuOpen,
+      onMenuClose
+    }),
+    accessibilityRole: isToggle && !hasMenu ? 'togglebutton' : 'button',
+    accessibilityLabel: accessibilityLabel ?? label,
+    accessibilityState: {
+      ...accessibilityState,
+      disabled: !!disabled,
+      busy: loading ? true : accessibilityState?.busy,
+      ...(isToggle ? {
+        checked: selected
+      } : null)
+    },
+    disabled: disabled || loading,
+    onPress: () => {
+      if (hasMenu) return;
+      if (isToggle) onSelectedChange?.(!selected);
+      onPress?.();
+    },
+    children: label ? /*#__PURE__*/_jsx(Text, {
+      children: label
+    }) : null
+  });
+}
+
+/**
+ * A `Pressable` with the button role, labeled by `accessibilityLabel` or
+ * `label`, showing the label as `Text` while extended.
+ */
+export function FloatingActionButton(props) {
+  const {
+    icon,
+    label,
+    extended,
+    size,
+    color,
+    tintColor,
+    disabled,
+    accessibilityLabel,
+    haptics,
+    onPress,
+    scrollViewNativeID,
+    accessibilityState,
+    ...viewProps
+  } = props;
+  return /*#__PURE__*/_jsx(Pressable, {
+    ...viewProps,
+    accessibilityRole: "button",
+    accessibilityLabel: accessibilityLabel ?? label,
+    accessibilityState: {
+      ...accessibilityState,
+      disabled: !!disabled
+    },
+    disabled: disabled,
+    onPress: () => onPress?.(),
+    children: label && extended !== false ? /*#__PURE__*/_jsx(Text, {
+      children: label
+    }) : null
+  });
+}
+
+/**
+ * A view of `Pressable`s, one per button, with the test ID
+ * `${testID}-${value}`. Selection follows the native rules.
+ */
+export function ButtonGroup(props) {
+  const {
+    buttons,
+    selection = 'none',
+    selectedValues = [],
+    selectionRequired,
+    disabled,
+    onPress,
+    onSelectionChange,
+    testID,
+    variant,
+    size,
+    shape,
+    connected,
+    spacing,
+    color,
+    tintColor,
+    labelStyle,
+    overflow,
+    haptics,
+    android,
+    ...viewProps
+  } = props;
+  const selected = selection === 'single' ? selectedValues.slice(0, 1) : selectedValues;
+  const required = selectionRequired ?? selection === 'single';
+  const handlePress = (value, index) => {
+    onPress?.(value, index);
+    if (selection === 'none') return;
+    const next = nextSelection(buttons.map(b => b.value), selected, value, selection, required);
+    if (next.join('\u0000') !== selected.join('\u0000')) {
+      onSelectionChange?.(next);
+    }
+  };
+  return /*#__PURE__*/_jsx(View, {
+    ...viewProps,
+    testID: testID,
+    accessibilityRole: "toolbar",
+    children: buttons.map((button, index) => {
+      const isDisabled = !!(disabled || button.disabled);
+      const isSelected = selected.includes(button.value);
+      return /*#__PURE__*/_jsx(Pressable, {
+        testID: testID ? `${testID}-${button.value}` : undefined,
+        accessibilityRole: selection === 'none' ? 'button' : 'togglebutton',
+        accessibilityLabel: button.accessibilityLabel ?? button.label,
+        accessibilityState: {
+          disabled: isDisabled,
+          ...(selection === 'none' ? null : {
+            checked: isSelected
+          })
+        },
+        disabled: isDisabled,
+        onPress: () => handlePress(button.value, index),
+        children: button.label ? /*#__PURE__*/_jsx(Text, {
+          children: button.label
+        }) : null
+      }, button.value);
+    })
+  });
+}
+
+/**
+ * A `Pressable` with the button role, `testID` and the label as `Text`, for
+ * the main button. Pressing it calls `onPress`. The menu isn't rendered;
+ * `fireEvent(button, 'menuSelect', id, title)`, `'menuOpen'` and
+ * `'menuClose'` reach the menu callbacks.
+ */
+export function SplitButton(props) {
+  const {
+    label,
+    icon,
+    accessibilityLabel,
+    menu,
+    menuAccessibilityLabel,
+    variant,
+    size,
+    disabled,
+    color,
+    tintColor,
+    labelStyle,
+    haptics,
+    onPress,
+    onMenuSelect,
+    onMenuOpen,
+    onMenuClose,
+    android,
+    ...viewProps
+  } = props;
+  return /*#__PURE__*/_jsx(Pressable, {
+    ...viewProps,
+    ...handlers({
+      onMenuSelect,
+      onMenuOpen,
+      onMenuClose
+    }),
+    accessibilityRole: "button",
+    accessibilityLabel: accessibilityLabel ?? label,
+    accessibilityState: {
+      disabled: !!disabled
+    },
+    disabled: disabled,
+    onPress: () => onPress?.(),
+    children: label ? /*#__PURE__*/_jsx(Text, {
+      children: label
+    }) : null
+  });
+}
+
+/**
+ * A `tablist` view of `Pressable` tabs (at most five), each with its
+ * `testID`, else `${testID}-${value}`. Pressing a tab calls `onSelect`, or
+ * `onReselect` when it is the selected one. The `accessory` renders before
+ * the tab list.
+ */
+export function TabBar(props) {
+  const {
+    items,
+    selectedValue,
+    onSelect,
+    onReselect,
+    testID,
+    labelVisibility,
+    activeTintColor,
+    inactiveTintColor,
+    barColor,
+    badgeStyle,
+    labelStyle,
+    maxFontSizeMultiplier,
+    minimizeBehavior,
+    scrollViewNativeID,
+    accessory,
+    onAccessoryEnvironmentChange,
+    haptics,
+    android,
+    ...viewProps
+  } = props;
+  return /*#__PURE__*/_jsxs(_Fragment, {
+    children: [accessory, /*#__PURE__*/_jsx(View, {
+      ...viewProps,
+      testID: testID,
+      accessibilityRole: "tablist",
+      children: items.slice(0, 5).map((item, index) => {
+        const selected = item.value === selectedValue;
+        return /*#__PURE__*/_jsxs(Pressable, {
+          testID: item.testID ?? (testID ? `${testID}-${item.value}` : undefined),
+          accessibilityRole: "tab",
+          accessibilityLabel: item.accessibilityLabel ?? item.label,
+          accessibilityState: {
+            selected,
+            disabled: !!item.disabled
+          },
+          disabled: item.disabled,
+          onPress: () => selected ? onReselect?.(item.value, index) : onSelect?.(item.value, index),
+          children: [/*#__PURE__*/_jsx(Text, {
+            children: item.label
+          }), item.badge != null && item.badge !== '' ? /*#__PURE__*/_jsx(Text, {
+            children: String(item.badge)
+          }) : null]
+        }, item.value);
+      })
+    })]
+  });
+}
+
+/**
+ * A vertical `tablist` view carrying `testID`: the header, then a
+ * `Pressable` per destination with its `testID`, else `${testID}-${value}`.
+ * Pressing a destination calls `onSelect`, or `onReselect` when it is the
+ * selected one.
+ */
+export function NavigationRail(props) {
+  const {
+    items,
+    selectedValue,
+    onSelect,
+    onReselect,
+    haptics,
+    header,
+    testID,
+    labelVisibility,
+    menuGravity,
+    expanded,
+    activeTintColor,
+    inactiveTintColor,
+    railColor,
+    badgeStyle,
+    labelStyle,
+    maxFontSizeMultiplier,
+    android,
+    ...viewProps
+  } = props;
+  return /*#__PURE__*/_jsxs(View, {
+    ...viewProps,
+    testID: testID,
+    children: [header, /*#__PURE__*/_jsx(View, {
+      accessibilityRole: "tablist",
+      children: items.map((item, index) => {
+        const selected = item.value === selectedValue;
+        return /*#__PURE__*/_jsxs(Pressable, {
+          testID: item.testID ?? (testID ? `${testID}-${item.value}` : undefined),
+          accessibilityRole: "tab",
+          accessibilityLabel: item.accessibilityLabel ?? item.label,
+          accessibilityState: {
+            selected,
+            disabled: !!item.disabled
+          },
+          disabled: item.disabled,
+          onPress: () => selected ? onReselect?.(item.value, index) : onSelect?.(item.value, index),
+          children: [/*#__PURE__*/_jsx(Text, {
+            children: item.label
+          }), item.badge != null && item.badge !== '' ? /*#__PURE__*/_jsx(Text, {
+            children: String(item.badge)
+          }) : null]
+        }, item.value);
+      })
+    })]
+  });
+}
+
+/**
+ * A view of `Pressable` tabs, one per segment, with the test ID
+ * `${testID}-${value}`. Pressing an unselected segment calls `onSelect`;
+ * pressing the selected one calls `onDeselect` only when
+ * `android.selectionRequired` is `false`.
+ */
+export function SegmentedControl(props) {
+  const {
+    segments,
+    selectedValue,
+    onSelect,
+    onDeselect,
+    disabled,
+    testID,
+    haptics,
+    ios,
+    android,
+    labelVisibility,
+    selectedSegmentColor,
+    activeTintColor,
+    inactiveTintColor,
+    labelStyle,
+    maxFontSizeMultiplier,
+    badgeStyle,
+    ...viewProps
+  } = props;
+  const handlePress = (value, index) => {
+    if (value !== selectedValue || ios?.momentary) {
+      onSelect?.(value, index);
+    } else if (android?.selectionRequired === false) {
+      onDeselect?.();
+    }
+  };
+  return /*#__PURE__*/_jsx(View, {
+    ...viewProps,
+    testID: testID,
+    accessibilityRole: "tablist",
+    children: segments.map((segment, index) => {
+      const isDisabled = !!(disabled || segment.disabled);
+      return /*#__PURE__*/_jsxs(Pressable, {
+        testID: segment.testID ?? (testID ? `${testID}-${segment.value}` : undefined),
+        accessibilityRole: "tab",
+        accessibilityLabel: segment.accessibilityLabel ?? segment.label,
+        accessibilityState: {
+          selected: segment.value === selectedValue,
+          disabled: isDisabled
+        },
+        disabled: isDisabled,
+        onPress: () => handlePress(segment.value, index),
+        children: [/*#__PURE__*/_jsx(Text, {
+          children: segment.label
+        }), segment.badge != null && segment.badge !== '' ? /*#__PURE__*/_jsx(Text, {
+          children: String(segment.badge)
+        }) : null]
+      }, segment.value);
+    })
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Pickers and menus
+
+/**
+ * A view carrying `testID`. Its handlers are on the view, so
+ * `fireEvent(picker, 'confirm', date, true, 0)` and `fireEvent(picker, 'closed')`
+ * reach `onConfirm` and `onClosed` (the third `confirm` argument is
+ * `durationSeconds`: pass the duration for `countDownTimer`, 0 otherwise).
+ */
+export function DatePicker(props) {
+  const {
+    style,
+    testID,
+    onConfirm,
+    onClosed
+  } = props;
+  return /*#__PURE__*/_jsx(View, {
+    style: style,
+    testID: testID,
+    ...handlers({
+      onConfirm,
+      onClosed
+    })
+  });
+}
+
+/**
+ * A view with `testID` that takes `onConfirm` (with `{ startDate, endDate }`)
+ * and `onClosed` through `fireEvent`. The mock renders on every platform.
+ */
+export function DateRangePicker(props) {
+  const {
+    style,
+    testID,
+    onConfirm,
+    onClosed
+  } = props;
+  return /*#__PURE__*/_jsx(View, {
+    style: style,
+    testID: testID,
+    ...handlers({
+      onConfirm,
+      onClosed
+    })
+  });
+}
+
+/** The mock renders `DateRangePicker` everywhere. */
+export const isDateRangePickerSupported = true;
+
+/**
+ * A view carrying `testID` that shows the selected option's label (or the
+ * placeholder). While the menu is open (embedded, or modal with `visible`),
+ * each option is a `Pressable` with the test ID `${testID}-${data}` that calls
+ * `onSelect` and shows its label and subtitle. `fireEvent(menu, 'select',
+ * data, label, index)` and `fireEvent(menu, 'requestClose')` also work.
+ */
+export function SelectionMenu(props) {
+  const {
+    options,
+    selected,
+    disabled,
+    placeholder,
+    presentation,
+    visible,
+    haptics,
+    onSelect,
+    onRequestClose,
+    testID,
+    ios,
+    android,
+    ...viewProps
+  } = props;
+  const current = options.find(option => option.data === selected);
+  const open = presentation === 'embedded' || !!visible;
+  return /*#__PURE__*/_jsxs(View, {
+    ...viewProps,
+    testID: testID,
+    accessibilityState: {
+      disabled: !!disabled,
+      expanded: open
+    },
+    ...handlers({
+      onSelect,
+      onRequestClose
+    }),
+    children: [current || placeholder ? /*#__PURE__*/_jsx(Text, {
+      children: current ? current.label : placeholder
+    }) : null, open && !disabled ? options.map((option, index) => /*#__PURE__*/_jsxs(Pressable, {
+      testID: testID ? `${testID}-${option.data}` : undefined,
+      accessibilityRole: "menuitem",
+      accessibilityState: {
+        selected: option.data === selected
+      },
+      onPress: () => onSelect?.(option.data, option.label, index),
+      children: [/*#__PURE__*/_jsx(Text, {
+        children: option.label
+      }), option.subtitle ? /*#__PURE__*/_jsx(Text, {
+        children: option.subtitle
+      }) : null]
+    }, option.data)) : null]
+  });
+}
+
+/**
+ * Its children in a view carrying `testID`. The menu itself isn't rendered;
+ * `fireEvent(menu, 'pressAction', id, title)`, `'menuOpen'`, `'menuClose'`
+ * and `'previewPress'` reach the callbacks.
+ */
+export function ContextMenu(props) {
+  const {
+    children,
+    onPressAction,
+    onMenuOpen,
+    onMenuClose,
+    onPreviewPress,
+    title,
+    actions,
+    disabled,
+    trigger,
+    haptics,
+    ios,
+    android,
+    ...viewProps
+  } = props;
+  return /*#__PURE__*/_jsx(View, {
+    ...viewProps,
+    ...handlers({
+      onPressAction,
+      onMenuOpen,
+      onMenuClose,
+      onPreviewPress
+    }),
+    children: children
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Containers
+
+/** A view with the toolbar's children. */
+export function FloatingToolbar(props) {
+  const {
+    orientation,
+    color,
+    scrollViewNativeID,
+    hideOnScroll,
+    ios,
+    android,
+    children,
+    ...viewProps
+  } = props;
+  return /*#__PURE__*/_jsx(View, {
+    ...viewProps,
+    children: children
+  });
+}
+
+/** A view with its children; a `Pressable` when `onPress` is set. */
+export function LiquidGlass(props) {
+  const {
+    cornerRadius,
+    cornerStyle,
+    ios,
+    android,
+    onPress,
+    children,
+    ...viewProps
+  } = props;
+  if (!onPress) return /*#__PURE__*/_jsx(View, {
+    ...viewProps,
+    children: children
+  });
+  return /*#__PURE__*/_jsx(Pressable, {
+    ...viewProps,
+    onPress: event => onPress({
+      x: event?.nativeEvent?.locationX ?? 0,
+      y: event?.nativeEvent?.locationY ?? 0
+    }),
+    children: children
+  });
+}
+
+/** A view with its children. */
+export function LiquidGlassContainer(props) {
+  const {
+    spacing,
+    children,
+    ...viewProps
+  } = props;
+  return /*#__PURE__*/_jsx(View, {
+    ...viewProps,
+    children: children
+  });
+}
+
+/** Always `false` under Jest. */
+export const isLiquidGlassSupported = false;
+
+// ---------------------------------------------------------------------------
+// Theme
+
+/** No-op under Jest. */
+export function setNativeTheme(_theme) {}
+
+/** No-op under Jest. */
+export function useNativeTheme(_theme) {}
+export { PlatformComponentsProvider } from "./PlatformComponentsProvider.js";
+//# sourceMappingURL=jest.js.map