@bareboard/react-native 0.0.0-stage → 0.1.0

package/dist/components/popover-backdrop/popover-backdrop.d.ts

@@ -0,0 +1,6 @@
+import { type ForwardRefExoticComponent, type RefAttributes } from 'react';
+import { type PressableProps, type StyleProp, type ViewStyle, type ViewInstance } from 'react-native';
+export type PopoverBackdropProps = Omit<PressableProps, 'children' | 'style'> & {
+    style?: StyleProp<ViewStyle>;
+};
+export declare const PopoverBackdrop: ForwardRefExoticComponent<PopoverBackdropProps & RefAttributes<ViewInstance>>;

package/dist/components/popover-backdrop/popover-backdrop.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from 'react';
+import { Pressable, StyleSheet, } from 'react-native';
+import { usePopoverMachineContext } from '../popover/popover-machine-glue';
+// A press on the backdrop closes the popover, which replaces the web outside-click dismissal.
+export const PopoverBackdrop = forwardRef(function PopoverBackdropFn(props, ref) {
+    let machine = usePopoverMachineContext('PopoverBackdrop');
+    let { onPress, style, ...theirProps } = props;
+    let handlePress = (event) => {
+        onPress?.(event);
+        machine.actions.close();
+    };
+    return (_jsx(Pressable, { ...theirProps, ref: ref, style: [StyleSheet.absoluteFill, style], onPress: handlePress }));
+});

package/dist/components/popover-group/popover-group.d.ts

@@ -0,0 +1,4 @@
+import { type ForwardRefExoticComponent, type RefAttributes } from 'react';
+import { type ViewProps, type ViewInstance } from 'react-native';
+export type PopoverGroupProps = ViewProps;
+export declare const PopoverGroup: ForwardRefExoticComponent<PopoverGroupProps & RefAttributes<ViewInstance>>;

package/dist/components/popover-group/popover-group.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from 'react';
+import { View } from 'react-native';
+export const PopoverGroup = forwardRef(function PopoverGroupFn(props, ref) {
+    return _jsx(View, { ...props, ref: ref });
+});

package/dist/components/popover-overlay/popover-overlay.d.ts

@@ -0,0 +1,4 @@
+import { type ForwardRefExoticComponent, type RefAttributes } from 'react';
+import { type ViewProps, type ViewInstance } from 'react-native';
+export type PopoverOverlayProps = ViewProps;
+export declare const PopoverOverlay: ForwardRefExoticComponent<PopoverOverlayProps & RefAttributes<ViewInstance>>;

package/dist/components/popover-overlay/popover-overlay.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from 'react';
+import { StyleSheet, View } from 'react-native';
+export const PopoverOverlay = forwardRef(function PopoverOverlayFn(props, ref) {
+    return (_jsx(View, { ...props, ref: ref, accessibilityElementsHidden: true, importantForAccessibility: "no-hide-descendants", style: [StyleSheet.absoluteFill, props.style] }));
+});

package/dist/components/portal/portal.d.ts

@@ -0,0 +1,9 @@
+import { type ReactNode } from 'react';
+export type PortalProps = {
+    children?: ReactNode;
+};
+export declare function Portal({ children }: PortalProps): import("react").JSX.Element;
+export type PortalGroupProps = {
+    children?: ReactNode;
+};
+export declare function PortalGroup({ children }: PortalGroupProps): import("react").JSX.Element;

package/dist/components/portal/portal.js

@@ -0,0 +1,8 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import {} from 'react';
+export function Portal({ children }) {
+    return _jsx(_Fragment, { children: children });
+}
+export function PortalGroup({ children }) {
+    return _jsx(_Fragment, { children: children });
+}

package/dist/components/radio-group/radio-group.d.ts

@@ -0,0 +1,29 @@
+import { type ReactNode } from 'react';
+import { type PressableProps, type ViewProps } from 'react-native';
+import { type RenderChildren } from '../../utils/render';
+import { Description } from '../description/description';
+import { Label } from '../label/label';
+export type RadioGroupProps<TValue> = Omit<ViewProps, 'children'> & {
+    value?: TValue;
+    defaultValue?: TValue;
+    onChange?: (value: TValue) => void;
+    disabled?: boolean;
+    children?: ReactNode;
+};
+declare function RadioGroupRoot<TValue>({ value: controlledValue, defaultValue, onChange, disabled, children, ...theirProps }: RadioGroupProps<TValue>): import("react").JSX.Element;
+export declare const RadioGroup: typeof RadioGroupRoot & {
+    Label: typeof Label;
+    Description: typeof Description;
+};
+export type RadioRenderPropArg = {
+    checked: boolean;
+    disabled: boolean;
+    active: boolean;
+};
+export type RadioProps<TValue> = Omit<PressableProps, 'children' | 'disabled'> & {
+    value: TValue;
+    disabled?: boolean;
+    children?: RenderChildren<RadioRenderPropArg>;
+};
+export declare function Radio<TValue>({ value, disabled: radioDisabled, children, onPress, ...theirProps }: RadioProps<TValue>): import("react").JSX.Element;
+export {};

package/dist/components/radio-group/radio-group.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from 'react';
+import { Pressable, View, } from 'react-native';
+import { useControllable } from '../../hooks/use-controllable';
+import { resolveChildren } from '../../utils/render';
+import { Description } from '../description/description';
+import { Label } from '../label/label';
+let RadioGroupContext = createContext(null);
+function useRadioGroupContext(componentName) {
+    let context = useContext(RadioGroupContext);
+    if (context === null) {
+        throw new Error(`<${componentName} /> must be rendered inside a <RadioGroup /> component.`);
+    }
+    return context;
+}
+function RadioGroupRoot({ value: controlledValue, defaultValue, onChange, disabled = false, children, ...theirProps }) {
+    let [value, select] = useControllable(controlledValue, onChange, defaultValue);
+    return (_jsx(RadioGroupContext.Provider, { value: { value, disabled, select }, children: _jsx(View, { ...theirProps, accessibilityRole: "radiogroup", children: children }) }));
+}
+export const RadioGroup = Object.assign(RadioGroupRoot, {
+    /** @deprecated use `<Label>` instead of `<RadioGroup.Label>` */
+    Label,
+    /** @deprecated use `<Description>` instead of `<RadioGroup.Description>` */
+    Description,
+});
+export function Radio({ value, disabled: radioDisabled = false, children, onPress, ...theirProps }) {
+    let group = useRadioGroupContext('Radio');
+    let checked = group.value === value;
+    let disabled = group.disabled || radioDisabled;
+    let handlePress = (event) => {
+        onPress?.(event);
+        if (!checked)
+            group.select(value);
+    };
+    return (_jsx(Pressable, { ...theirProps, disabled: disabled, accessibilityRole: "radio", accessibilityState: { ...theirProps.accessibilityState, checked, disabled }, onPress: handlePress, children: ({ pressed }) => resolveChildren(children, { checked, disabled, active: pressed }) }));
+}

package/dist/components/select/select.d.ts

@@ -0,0 +1,7 @@
+import { Label } from '../label/label';
+import { Listbox, ListboxButton, ListboxOption, ListboxOptions } from '../listbox/listbox';
+export declare const Select: typeof Listbox;
+export declare const SelectButton: typeof ListboxButton;
+export declare const SelectOptions: typeof ListboxOptions;
+export declare const SelectOption: typeof ListboxOption;
+export declare const SelectLabel: typeof Label;

package/dist/components/select/select.js

@@ -0,0 +1,10 @@
+import { Label } from '../label/label';
+import { Listbox, ListboxButton, ListboxOption, ListboxOptions } from '../listbox/listbox';
+// The web Select wraps a native `<select>`, which React Native does not have. The Select here is the
+// Listbox pattern: a button that shows the current value and a list of `SelectOption`s. Each option
+// takes a `value`, and the `onChange` handler receives the value rather than a DOM event.
+export const Select = Listbox;
+export const SelectButton = ListboxButton;
+export const SelectOptions = ListboxOptions;
+export const SelectOption = ListboxOption;
+export const SelectLabel = Label;

package/dist/components/switch/switch.d.ts

@@ -0,0 +1,20 @@
+import { type ForwardRefExoticComponent, type RefAttributes } from 'react';
+import { type ViewInstance } from 'react-native';
+import { type ToggleProps } from '../../internal/toggle';
+import { Description } from '../description/description';
+import { Field } from '../field/field';
+import { Label } from '../label/label';
+export type SwitchProps = Omit<ToggleProps, 'role'>;
+declare const SwitchRoot: ForwardRefExoticComponent<SwitchProps & RefAttributes<ViewInstance>>;
+/** @deprecated use `<Field>` instead of `<Switch.Group>` */
+export declare const SwitchGroup: typeof Field;
+/** @deprecated use `<Label>` instead of `<Switch.Label>` */
+export declare const SwitchLabel: typeof Label;
+/** @deprecated use `<Description>` instead of `<Switch.Description>` */
+export declare const SwitchDescription: typeof Description;
+export declare const Switch: typeof SwitchRoot & {
+    Group: typeof SwitchGroup;
+    Label: typeof SwitchLabel;
+    Description: typeof SwitchDescription;
+};
+export {};

package/dist/components/switch/switch.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from 'react';
+import {} from 'react-native';
+import { Toggle } from '../../internal/toggle';
+import { Description } from '../description/description';
+import { Field } from '../field/field';
+import { Label } from '../label/label';
+const SwitchRoot = forwardRef(function SwitchFn(props, ref) {
+    return _jsx(Toggle, { ...props, ref: ref, role: "switch" });
+});
+/** @deprecated use `<Field>` instead of `<Switch.Group>` */
+export const SwitchGroup = Field;
+/** @deprecated use `<Label>` instead of `<Switch.Label>` */
+export const SwitchLabel = Label;
+/** @deprecated use `<Description>` instead of `<Switch.Description>` */
+export const SwitchDescription = Description;
+export const Switch = Object.assign(SwitchRoot, {
+    /** @deprecated use `<Field>` instead of `<Switch.Group>` */
+    Group: SwitchGroup,
+    /** @deprecated use `<Label>` instead of `<Switch.Label>` */
+    Label: SwitchLabel,
+    /** @deprecated use `<Description>` instead of `<Switch.Description>` */
+    Description: SwitchDescription,
+});

package/dist/components/tab-panels/tab-panels.d.ts

@@ -0,0 +1,4 @@
+import { type ForwardRefExoticComponent, type RefAttributes } from 'react';
+import { type ViewProps, type ViewInstance } from 'react-native';
+export type TabPanelsProps = ViewProps;
+export declare const TabPanels: ForwardRefExoticComponent<TabPanelsProps & RefAttributes<ViewInstance>>;

package/dist/components/tab-panels/tab-panels.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from 'react';
+import { View } from 'react-native';
+export const TabPanels = forwardRef(function TabPanelsFn(props, ref) {
+    return _jsx(View, { ...props, ref: ref });
+});

package/dist/components/tabs/tabs.d.ts

@@ -0,0 +1,29 @@
+import { type PressableProps, type ViewProps } from 'react-native';
+import { type RenderChildren } from '../../utils/render';
+export type TabGroupProps<TValue> = Omit<ViewProps, 'children'> & {
+    value?: TValue;
+    defaultValue?: TValue;
+    onChange?: (value: TValue) => void;
+    children?: RenderChildren<{
+        value: TValue | undefined;
+    }>;
+};
+export declare function TabGroup<TValue>({ value: controlledValue, defaultValue, onChange, children, ...theirProps }: TabGroupProps<TValue>): import("react").JSX.Element;
+export type TabListProps = ViewProps;
+export declare function TabList(props: TabListProps): import("react").JSX.Element;
+export type TabRenderPropArg = {
+    selected: boolean;
+    disabled: boolean;
+    active: boolean;
+};
+export type TabProps<TValue> = Omit<PressableProps, 'children' | 'disabled'> & {
+    value: TValue;
+    disabled?: boolean;
+    children?: RenderChildren<TabRenderPropArg>;
+};
+export declare function Tab<TValue>({ value, disabled: tabDisabled, children, onPress, ...theirProps }: TabProps<TValue>): import("react").JSX.Element;
+export type TabPanelProps<TValue> = ViewProps & {
+    value: TValue;
+    unmount?: boolean;
+};
+export declare function TabPanel<TValue>({ value, unmount, ...theirProps }: TabPanelProps<TValue>): import("react").JSX.Element | null;

package/dist/components/tabs/tabs.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from 'react';
+import { Pressable, View, } from 'react-native';
+import { useControllable } from '../../hooks/use-controllable';
+import { useDisabled } from '../../internal/disabled';
+import { resolveChildren } from '../../utils/render';
+let TabGroupContext = createContext(null);
+function useTabGroupContext(componentName) {
+    let context = useContext(TabGroupContext);
+    if (context === null) {
+        throw new Error(`<${componentName} /> must be rendered inside a <TabGroup /> component.`);
+    }
+    return context;
+}
+export function TabGroup({ value: controlledValue, defaultValue, onChange, children, ...theirProps }) {
+    let [value, select] = useControllable(controlledValue, onChange, defaultValue);
+    return (_jsx(TabGroupContext.Provider, { value: { value, select }, children: _jsx(View, { ...theirProps, children: resolveChildren(children, { value }) }) }));
+}
+export function TabList(props) {
+    return _jsx(View, { ...props, accessibilityRole: "tablist" });
+}
+export function Tab({ value, disabled: tabDisabled, children, onPress, ...theirProps }) {
+    let group = useTabGroupContext('Tab');
+    let providedDisabled = useDisabled();
+    let selected = group.value === value;
+    let disabled = tabDisabled ?? providedDisabled ?? false;
+    let handlePress = (event) => {
+        onPress?.(event);
+        if (!disabled)
+            group.select(value);
+    };
+    return (_jsx(Pressable, { ...theirProps, disabled: disabled, accessibilityRole: "tab", accessibilityState: { ...theirProps.accessibilityState, selected, disabled }, onPress: handlePress, children: ({ pressed }) => resolveChildren(children, { selected, disabled, active: pressed }) }));
+}
+export function TabPanel({ value, unmount = true, ...theirProps }) {
+    let group = useTabGroupContext('TabPanel');
+    let selected = group.value === value;
+    if (!selected && unmount)
+        return null;
+    return _jsx(View, { ...theirProps, style: [theirProps.style, !selected && { display: 'none' }] });
+}

package/dist/components/textarea/textarea.d.ts

@@ -0,0 +1,5 @@
+import { type ForwardRefExoticComponent, type RefAttributes } from 'react';
+import { type TextInputInstance } from 'react-native';
+import { type InputProps } from '../input/input';
+export type TextareaProps = Omit<InputProps, 'multiline'>;
+export declare const Textarea: ForwardRefExoticComponent<TextareaProps & RefAttributes<TextInputInstance>>;

package/dist/components/textarea/textarea.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from 'react';
+import {} from 'react-native';
+import { Input } from '../input/input';
+export const Textarea = forwardRef(function TextareaFn(props, ref) {
+    return _jsx(Input, { ...props, ref: ref, multiline: true });
+});

package/dist/components/transition/transition.d.ts

@@ -0,0 +1,21 @@
+import { type ReactNode } from 'react';
+import { type ViewProps } from 'react-native';
+type TransitionTiming = {
+    unmount?: boolean;
+    enter?: number;
+    leave?: number;
+};
+type TransitionViewProps = ViewProps & TransitionTiming & {
+    show: boolean;
+    children?: ReactNode;
+};
+export type TransitionRootProps = TransitionViewProps;
+export declare function TransitionRoot({ show, ...theirProps }: TransitionRootProps): import("react").JSX.Element;
+export type TransitionChildProps = Omit<TransitionViewProps, 'show'> & {
+    show?: boolean;
+};
+export declare function TransitionChild({ show, ...theirProps }: TransitionChildProps): import("react").JSX.Element;
+export declare const Transition: typeof TransitionRoot & {
+    Child: typeof TransitionChild;
+};
+export {};

package/dist/components/transition/transition.js

@@ -0,0 +1,34 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useRef, useState } from 'react';
+import { Animated } from 'react-native';
+let TransitionContext = createContext(null);
+// The web transition swaps CSS classes. Here the same lifecycle drives an opacity animation:
+// `enter` and `leave` are durations in milliseconds, and the element unmounts after `leave`.
+function TransitionView({ show, unmount = true, enter = 0, leave = 0, children, ...theirProps }) {
+    let [rendered, setRendered] = useState(show);
+    let opacity = useRef(new Animated.Value(show ? 1 : 0)).current;
+    useEffect(() => {
+        if (show) {
+            setRendered(true);
+            Animated.timing(opacity, { toValue: 1, duration: enter, useNativeDriver: false }).start();
+            return;
+        }
+        Animated.timing(opacity, { toValue: 0, duration: leave, useNativeDriver: false }).start(({ finished }) => {
+            if (finished && unmount)
+                setRendered(false);
+        });
+    }, [show]);
+    if (!show && unmount && !rendered)
+        return null;
+    return (_jsx(Animated.View, { ...theirProps, style: [theirProps.style, { opacity }], children: children }));
+}
+export function TransitionRoot({ show, ...theirProps }) {
+    return (_jsx(TransitionContext.Provider, { value: show, children: _jsx(TransitionView, { ...theirProps, show: show }) }));
+}
+export function TransitionChild({ show, ...theirProps }) {
+    let inheritedShow = useContext(TransitionContext);
+    return _jsx(TransitionView, { ...theirProps, show: show ?? inheritedShow ?? true });
+}
+export const Transition = Object.assign(TransitionRoot, {
+    Child: TransitionChild,
+});

package/dist/hooks/use-controllable.d.ts

@@ -0,0 +1 @@
+export declare function useControllable<T>(controlledValue: T | undefined, onChange?: (value: T) => void, defaultValue?: T): readonly [NonNullable<T>, (value: any) => void | undefined];

package/dist/hooks/use-controllable.js

@@ -0,0 +1,34 @@
+import { useRef, useState } from 'react';
+import { useEvent } from './use-event';
+export function useControllable(controlledValue, onChange, defaultValue) {
+    let [internalValue, setInternalValue] = useState(defaultValue);
+    let isControlled = controlledValue !== undefined;
+    let wasControlled = useRef(isControlled);
+    let didWarnOnUncontrolledToControlled = useRef(false);
+    let didWarnOnControlledToUncontrolled = useRef(false);
+    if (isControlled && !wasControlled.current && !didWarnOnUncontrolledToControlled.current) {
+        didWarnOnUncontrolledToControlled.current = true;
+        wasControlled.current = isControlled;
+        console.error('A component is changing from uncontrolled to controlled. This may be caused by the value changing from undefined to a defined value, which should not happen.');
+    }
+    else if (!isControlled && wasControlled.current && !didWarnOnControlledToUncontrolled.current) {
+        didWarnOnControlledToUncontrolled.current = true;
+        wasControlled.current = isControlled;
+        console.error('A component is changing from controlled to uncontrolled. This may be caused by the value changing from a defined value to undefined, which should not happen.');
+    }
+    return [
+        (isControlled ? controlledValue : internalValue),
+        useEvent((value) => {
+            if (isControlled) {
+                return onChange?.(value);
+            }
+            else {
+                // Ensure internal state is up to date with the value, before calling
+                // onChange. `flushSync` is not available in React Native, so the state
+                // update is simply scheduled before `onChange` runs.
+                setInternalValue(value);
+                return onChange?.(value);
+            }
+        }),
+    ];
+}

package/dist/hooks/use-event.d.ts

@@ -0,0 +1 @@
+export declare let useEvent: <F extends (...args: any[]) => any, P extends any[] = Parameters<F>, R = ReturnType<F>>(cb: (...args: P) => R) => (...args: P) => R;

package/dist/hooks/use-event.js

@@ -0,0 +1,8 @@
+import React from 'react';
+import { useLatestValue } from './use-latest-value';
+export let useEvent = 
+// TODO: Add React.useEvent ?? once the useEvent hook is available
+function useEvent(cb) {
+    let cache = useLatestValue(cb);
+    return React.useCallback((...args) => cache.current(...args), [cache]);
+};

package/dist/hooks/use-iso-morphic-effect.d.ts

@@ -0,0 +1,2 @@
+import { useLayoutEffect } from 'react';
+export declare let useIsoMorphicEffect: typeof useLayoutEffect;

package/dist/hooks/use-iso-morphic-effect.js

@@ -0,0 +1,3 @@
+import { useLayoutEffect } from 'react';
+// React Native has no server rendering, so layout effects are always safe to use.
+export let useIsoMorphicEffect = useLayoutEffect;

package/dist/hooks/use-latest-value.d.ts

@@ -0,0 +1 @@
+export declare function useLatestValue<T>(value: T): import("react").RefObject<T>;

package/dist/hooks/use-latest-value.js

@@ -0,0 +1,9 @@
+import { useRef } from 'react';
+import { useIsoMorphicEffect } from './use-iso-morphic-effect';
+export function useLatestValue(value) {
+    let cache = useRef(value);
+    useIsoMorphicEffect(() => {
+        cache.current = value;
+    }, [value]);
+    return cache;
+}

package/dist/hooks/use-on-unmount.d.ts

@@ -0,0 +1 @@
+export declare function useOnUnmount(cb: () => void): void;

package/dist/hooks/use-on-unmount.js

@@ -0,0 +1,18 @@
+import { useEffect, useRef } from 'react';
+import { microTask } from '../utils/micro-task';
+import { useEvent } from './use-event';
+export function useOnUnmount(cb) {
+    let stableCb = useEvent(cb);
+    let trulyUnmounted = useRef(false);
+    useEffect(() => {
+        trulyUnmounted.current = false;
+        return () => {
+            trulyUnmounted.current = true;
+            microTask(() => {
+                if (!trulyUnmounted.current)
+                    return;
+                stableCb();
+            });
+        };
+    }, [stableCb]);
+}

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+export * from './components/button/button';
+export * from './components/checkbox/checkbox';
+export * from './components/close-button/close-button';
+export * from './components/combobox/combobox';
+export * from './components/data-interactive/data-interactive';
+export * from './components/description/description';
+export * from './components/dialog/dialog';
+export * from './components/disclosure/disclosure';
+export * from './components/field/field';
+export * from './components/fieldset/fieldset';
+export * from './components/focus-trap/focus-trap';
+export * from './components/input/input';
+export * from './components/label/label';
+export * from './components/legend/legend';
+export * from './components/listbox-label/listbox-label';
+export * from './components/listbox-selected-option/listbox-selected-option';
+export * from './components/listbox/listbox';
+export * from './components/menu-heading/menu-heading';
+export * from './components/menu-section/menu-section';
+export * from './components/menu-separator/menu-separator';
+export * from './components/menu/menu';
+export * from './components/popover-backdrop/popover-backdrop';
+export * from './components/popover-group/popover-group';
+export * from './components/popover-overlay/popover-overlay';
+export * from './components/popover/popover';
+export * from './components/portal/portal';
+export * from './components/radio-group/radio-group';
+export * from './components/select/select';
+export * from './components/switch/switch';
+export * from './components/tab-panels/tab-panels';
+export * from './components/tabs/tabs';
+export * from './components/textarea/textarea';
+export * from './components/transition/transition';

package/dist/index.js

@@ -0,0 +1,33 @@
+export * from './components/button/button';
+export * from './components/checkbox/checkbox';
+export * from './components/close-button/close-button';
+export * from './components/combobox/combobox';
+export * from './components/data-interactive/data-interactive';
+export * from './components/description/description';
+export * from './components/dialog/dialog';
+export * from './components/disclosure/disclosure';
+export * from './components/field/field';
+export * from './components/fieldset/fieldset';
+export * from './components/focus-trap/focus-trap';
+export * from './components/input/input';
+export * from './components/label/label';
+export * from './components/legend/legend';
+export * from './components/listbox-label/listbox-label';
+export * from './components/listbox-selected-option/listbox-selected-option';
+export * from './components/listbox/listbox';
+export * from './components/menu-heading/menu-heading';
+export * from './components/menu-section/menu-section';
+export * from './components/menu-separator/menu-separator';
+export * from './components/menu/menu';
+export * from './components/popover-backdrop/popover-backdrop';
+export * from './components/popover-group/popover-group';
+export * from './components/popover-overlay/popover-overlay';
+export * from './components/popover/popover';
+export * from './components/portal/portal';
+export * from './components/radio-group/radio-group';
+export * from './components/select/select';
+export * from './components/switch/switch';
+export * from './components/tab-panels/tab-panels';
+export * from './components/tabs/tabs';
+export * from './components/textarea/textarea';
+export * from './components/transition/transition';

package/dist/internal/close-provider.d.ts

@@ -0,0 +1,6 @@
+import { type ReactNode } from 'react';
+export declare function useClose(): () => void;
+export declare function CloseProvider({ value, children }: {
+    value: () => void;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/internal/close-provider.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from 'react';
+let CloseContext = createContext(() => { });
+export function useClose() {
+    return useContext(CloseContext);
+}
+export function CloseProvider({ value, children }) {
+    return _jsx(CloseContext.Provider, { value: value, children: children });
+}

package/dist/internal/disabled.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare function useDisabled(): boolean | undefined;
+export declare function DisabledProvider({ value, children, }: React.PropsWithChildren<{
+    value?: boolean;
+}>): React.JSX.Element;

package/dist/internal/disabled.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React, { createContext, useContext } from 'react';
+let DisabledContext = createContext(undefined);
+export function useDisabled() {
+    return useContext(DisabledContext);
+}
+export function DisabledProvider({ value, children, }) {
+    return _jsx(DisabledContext.Provider, { value: value, children: children });
+}

package/dist/internal/toggle.d.ts

@@ -0,0 +1,17 @@
+import { type ForwardRefExoticComponent, type RefAttributes } from 'react';
+import { type PressableProps, type ViewInstance } from 'react-native';
+import { type RenderChildren } from '../utils/render';
+export type ToggleRenderPropArg = {
+    checked: boolean;
+    disabled: boolean;
+    active: boolean;
+};
+export type ToggleProps = Omit<PressableProps, 'children' | 'disabled'> & {
+    role: 'switch' | 'checkbox';
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    children?: RenderChildren<ToggleRenderPropArg>;
+};
+export declare const Toggle: ForwardRefExoticComponent<ToggleProps & RefAttributes<ViewInstance>>;

package/dist/internal/toggle.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from 'react';
+import { Pressable, } from 'react-native';
+import { useControllable } from '../hooks/use-controllable';
+import { useEvent } from '../hooks/use-event';
+import { resolveChildren } from '../utils/render';
+import { useDisabled } from './disabled';
+export const Toggle = forwardRef(function ToggleFn(props, ref) {
+    let providedDisabled = useDisabled();
+    let { role, checked: controlledChecked, defaultChecked, onChange: controlledOnChange, disabled = providedDisabled || false, children, onPress, ...theirProps } = props;
+    let [checked, onChange] = useControllable(controlledChecked, controlledOnChange, defaultChecked ?? false);
+    let handlePress = useEvent((event) => {
+        onPress?.(event);
+        onChange(!checked);
+    });
+    return (_jsx(Pressable, { ...theirProps, ref: ref, disabled: disabled, accessibilityRole: role, accessibilityState: { ...theirProps.accessibilityState, checked, disabled }, onPress: handlePress, children: ({ pressed }) => resolveChildren(children, { checked, disabled, active: pressed }) }));
+});