@cdx-ui/primitives 0.0.1-beta.1 → 0.0.1-beta.100

package/src/radio/useRadioRoot.ts

@@ -0,0 +1,69 @@
+import { useContext, useRef } from 'react';
+import { mergeRefs, useFormControlContext } from '@cdx-ui/utils';
+import { useRadio } from '@react-native-aria/radio';
+import { useHover } from '@react-native-aria/interactions';
+import { RadioGroupContext } from './context';
+import type { IRadioProps } from './types';
+
+interface UseRadioRootOptions {
+  useInputRefForAria?: boolean;
+}
+
+export function useRadioRoot(
+  props: IRadioProps,
+  ref?: React.Ref<unknown>,
+  { useInputRefForAria = false }: UseRadioRootOptions = {},
+) {
+  const formControlContext = useFormControlContext();
+
+  const { isInvalid, isReadOnly, ...combinedProps } = {
+    ...formControlContext,
+    ...props,
+  };
+
+  const radioGroupContext = useContext(RadioGroupContext);
+
+  if (!radioGroupContext) {
+    throw new Error(
+      'Radio must be rendered inside a Radio.Group. Standalone Radio is not supported.',
+    );
+  }
+
+  const rootRef = useRef(null);
+  const inputRef = useRef<HTMLInputElement | null>(null);
+  const mergedRootRef = mergeRefs(ref as any, rootRef as any);
+  const ariaLabel = combinedProps['aria-label'] || combinedProps.value || 'Radio';
+
+  const radio = useRadio(
+    {
+      ...combinedProps,
+      'aria-label': ariaLabel,
+      isReadOnly: isReadOnly || radioGroupContext.state.isReadOnly,
+      isDisabled: combinedProps.isDisabled || radioGroupContext.state.isDisabled,
+    } as any,
+    radioGroupContext.radioGroupState,
+    (useInputRefForAria ? inputRef : rootRef) as any,
+  );
+
+  const { inputProps, labelProps } = radio as typeof radio & {
+    labelProps?: Record<string, unknown>;
+  };
+
+  const { checked: isChecked, disabled: isDisabled } = inputProps;
+
+  const { hoverProps, isHovered } = useHover({}, rootRef);
+
+  return {
+    combinedProps,
+    isInvalid: isInvalid || radioGroupContext.state.isInvalid,
+    isReadOnly: isReadOnly || radioGroupContext.state.isReadOnly,
+    inputProps,
+    labelProps: labelProps ?? {},
+    isChecked,
+    isDisabled,
+    isHovered,
+    hoverProps,
+    mergedRef: mergedRootRef,
+    inputRef,
+  };
+}

package/src/select/SelectContent.tsx

@@ -0,0 +1,120 @@
+import React, { forwardRef, useCallback, useRef, type ComponentRef } from 'react';
+import { Platform, ScrollView, View } from 'react-native';
+import { FadeIn, FadeOut } from 'react-native-reanimated';
+import { composeEventHandlers, mergeRefs } from '@cdx-ui/utils';
+import {
+  OverlayContainer,
+  useAnchorPosition,
+  useDismissOverlay,
+  useOverlayPosition,
+} from '../overlay';
+import { Slot } from '../slot';
+import { dataAttributes, mergeDataAttributes } from '../utils/dataAttributes';
+import { useSelectContext } from './context';
+import type { ISelectContentProps } from './types';
+import { useContentFocus } from './useContentFocus';
+import { useListboxNavigation } from './useListboxNavigation';
+
+export interface SelectContentProps extends ISelectContentProps {
+  asChild?: boolean;
+  className?: string;
+}
+
+export const SelectContent = forwardRef<ComponentRef<typeof View>, SelectContentProps>(
+  ({ asChild, children, enteringAnimation, exitingAnimation, ...props }, ref) => {
+    const {
+      open,
+      setOpen,
+      contentId,
+      triggerId,
+      activeValue,
+      setActiveValue,
+      value,
+      onValueChange,
+      native,
+      triggerRef,
+      items,
+    } = useSelectContext();
+
+    const contentRef = useRef<HTMLElement | null>(null);
+
+    const focusOnMount = useCallback((node: unknown) => {
+      contentRef.current = node as HTMLElement | null;
+      if (node && Platform.OS === 'web') {
+        requestAnimationFrame(() => {
+          setTimeout(() => {
+            (node as HTMLElement).focus?.();
+          }, 100);
+        });
+      }
+    }, []);
+
+    const mergedRef = mergeRefs(ref, focusOnMount as unknown as React.Ref<View>);
+
+    const dismiss = useCallback(() => setOpen(false), [setOpen]);
+
+    const anchorLayout = useAnchorPosition(triggerRef, open);
+    const position = useOverlayPosition(anchorLayout);
+
+    useDismissOverlay(open, contentRef, [triggerRef], dismiss);
+
+    const { handleKeyDown } = useListboxNavigation({
+      items,
+      activeValue,
+      setActiveValue,
+      onSelect: (val) => {
+        onValueChange(val);
+        setOpen(false);
+      },
+      onDismiss: dismiss,
+    });
+
+    useContentFocus({
+      open,
+      triggerRef,
+      items,
+      value,
+      setActiveValue,
+    });
+
+    if (native || !open || !position) {
+      return null;
+    }
+
+    const webProps =
+      Platform.OS === 'web'
+        ? {
+            onKeyDown: composeEventHandlers(
+              (props as { onKeyDown?: (e: KeyboardEvent) => void }).onKeyDown,
+              handleKeyDown,
+            ),
+            tabIndex: -1,
+          }
+        : {};
+
+    const Comp = asChild ? Slot : View;
+
+    return (
+      <OverlayContainer
+        onDismiss={dismiss}
+        entering={enteringAnimation ?? FadeIn.duration(150)}
+        exiting={exitingAnimation ?? FadeOut.duration(100)}
+        style={position.style}
+      >
+        <Comp
+          ref={mergedRef}
+          role="listbox"
+          id={contentId}
+          aria-labelledby={triggerId}
+          {...props}
+          {...mergeDataAttributes(props, dataAttributes({ state: 'open' }))}
+          {...webProps}
+        >
+          <ScrollView scrollEventThrottle={16}>{children}</ScrollView>
+        </Comp>
+      </OverlayContainer>
+    );
+  },
+);
+
+SelectContent.displayName = 'SelectContent';

package/src/select/SelectItem.tsx

@@ -0,0 +1,139 @@
+import { forwardRef, useCallback, useMemo, type ComponentRef, type ReactNode } from 'react';
+import { Pressable } from 'react-native';
+import { composeEventHandlers } from '@cdx-ui/utils';
+import { useFocus, useFocusRing } from '@react-native-aria/focus';
+import { useHover, usePress } from '@react-native-aria/interactions';
+import { Slot } from '../slot';
+import { dataAttributes, mergeDataAttributes } from '../utils/dataAttributes';
+import { SelectItemProvider, useSelectContext } from './context';
+import type { ISelectItemProps } from './types';
+
+export interface SelectItemProps extends Omit<ISelectItemProps, 'children'> {
+  asChild?: boolean;
+  children?: ReactNode;
+}
+
+export const SelectItem = forwardRef<ComponentRef<typeof Pressable>, SelectItemProps>(
+  (
+    {
+      asChild,
+      children,
+      value: itemValue,
+      disabled: disabledProp = false,
+      isHovered: isHoveredProp,
+      isActive: isActiveProp,
+      isFocused: isFocusedProp,
+      isFocusVisible: isFocusVisibleProp,
+      isDisabled: isDisabledProp,
+      ...props
+    },
+    ref,
+  ) => {
+    const {
+      value: selectedValue,
+      onValueChange,
+      setOpen,
+      activeValue,
+      contentId,
+      disabled: contextDisabled,
+    } = useSelectContext();
+
+    const disabled = contextDisabled || !!disabledProp || !!isDisabledProp;
+    const checked = selectedValue === itemValue;
+    const highlighted = activeValue === itemValue;
+
+    const { isFocusVisible, focusProps: focusRingProps } = useFocusRing() as {
+      isFocusVisible: boolean;
+      focusProps: {
+        onFocus?: (...args: unknown[]) => unknown;
+        onBlur?: (...args: unknown[]) => unknown;
+      };
+    };
+    const { pressProps, isPressed: isActive } = usePress({ isDisabled: disabled });
+    const { isFocused, focusProps } = useFocus();
+    const { isHovered, hoverProps } = useHover();
+
+    const handlePress = useCallback(() => {
+      if (!disabled) {
+        onValueChange(itemValue);
+        setOpen(false);
+      }
+    }, [disabled, itemValue, onValueChange, setOpen]);
+
+    const interactionState = useMemo(
+      () => ({
+        hover: !!(isHoveredProp || isHovered),
+        focus: !!(isFocusedProp || isFocused),
+        active: !!(isActiveProp || isActive),
+        disabled: !!disabled,
+        focusVisible: !!(isFocusVisibleProp || isFocusVisible),
+        highlighted,
+        checked,
+      }),
+      [
+        isHoveredProp,
+        isHovered,
+        isFocusedProp,
+        isFocused,
+        isActiveProp,
+        isActive,
+        disabled,
+        isFocusVisibleProp,
+        isFocusVisible,
+        highlighted,
+        checked,
+      ],
+    );
+
+    const Comp = asChild ? Slot : Pressable;
+
+    return (
+      <SelectItemProvider value={interactionState}>
+        <Comp
+          ref={ref}
+          role="option"
+          id={`${contentId}-option-${itemValue}`}
+          aria-selected={checked}
+          aria-disabled={disabled}
+          disabled={disabled}
+          {...props}
+          {...mergeDataAttributes(
+            props,
+            dataAttributes({
+              hover: interactionState.hover,
+              focus: interactionState.focus,
+              active: interactionState.active,
+              disabled: interactionState.disabled,
+              focusVisible: interactionState.focusVisible,
+              highlighted: interactionState.highlighted,
+              state: checked ? 'checked' : 'unchecked',
+            }),
+          )}
+          onPress={composeEventHandlers(props?.onPress, handlePress)}
+          onPressIn={composeEventHandlers(props?.onPressIn, pressProps.onPressIn)}
+          onPressOut={composeEventHandlers(props?.onPressOut, pressProps.onPressOut)}
+          onHoverIn={composeEventHandlers(props?.onHoverIn, hoverProps.onHoverIn)}
+          onHoverOut={composeEventHandlers(props?.onHoverOut, hoverProps.onHoverOut)}
+          onFocus={composeEventHandlers(
+            composeEventHandlers(
+              props?.onFocus as (...args: unknown[]) => unknown,
+              focusProps.onFocus,
+            ),
+            focusRingProps.onFocus,
+          )}
+          onBlur={composeEventHandlers(
+            composeEventHandlers(
+              props?.onBlur as (...args: unknown[]) => unknown,
+              focusProps.onBlur,
+            ),
+            focusRingProps.onBlur,
+          )}
+        >
+          {children}
+        </Comp>
+      </SelectItemProvider>
+    );
+  },
+);
+
+SelectItem.displayName = 'SelectItem';

package/src/select/SelectRoot.tsx

@@ -0,0 +1,154 @@
+import {
+  forwardRef,
+  useCallback,
+  useId,
+  useMemo,
+  useRef,
+  useState,
+  type ComponentRef,
+} from 'react';
+import { View, type ViewProps } from 'react-native';
+import { useControllableState, useFormControl } from '@cdx-ui/utils';
+import { Slot } from '../slot';
+import { dataAttributes, mergeDataAttributes } from '../utils/dataAttributes';
+import { SelectProvider } from './context';
+import type { ISelectProps } from './types';
+
+export interface SelectRootProps extends ISelectProps, Omit<ViewProps, 'children'> {
+  asChild?: boolean;
+  className?: string;
+}
+
+export const SelectRoot = forwardRef<ComponentRef<typeof View>, SelectRootProps>(
+  (
+    {
+      asChild,
+      children,
+      items,
+      value: valueProp,
+      defaultValue,
+      onValueChange,
+      open: openProp,
+      defaultOpen = false,
+      onOpenChange,
+      disabled = false,
+      isRequired,
+      isInvalid,
+      isReadOnly,
+      native = false,
+      accessibilityLabel,
+      ...props
+    },
+    ref,
+  ) => {
+    const formControlProps = useFormControl({
+      isDisabled: disabled,
+      isRequired,
+      isInvalid,
+      isReadOnly,
+    });
+
+    const isEffectivelyDisabled = !!formControlProps.disabled;
+    const isEffectivelyRequired = !!formControlProps.required;
+    const isEffectivelyInvalid = !!formControlProps['aria-invalid'];
+    const isEffectivelyReadOnly = !!formControlProps.readOnly;
+
+    const [value, setValue] = useControllableState<string | undefined>({
+      prop: valueProp,
+      defaultProp: defaultValue,
+      onChange: (newValue) => {
+        if (newValue !== undefined) {
+          onValueChange?.(newValue);
+        }
+      },
+    });
+
+    const [open, setOpenState] = useControllableState<boolean>({
+      prop: openProp,
+      defaultProp: defaultOpen,
+      onChange: onOpenChange,
+    });
+
+    const setOpen = useCallback(
+      (newOpen: boolean) => {
+        if ((isEffectivelyDisabled || isEffectivelyReadOnly) && newOpen) {
+          return;
+        }
+        setOpenState(newOpen);
+      },
+      [isEffectivelyDisabled, isEffectivelyReadOnly, setOpenState],
+    );
+
+    const [activeValue, setActiveValue] = useState<string | undefined>(undefined);
+
+    const triggerRef = useRef<ComponentRef<typeof View> | null>(null);
+    const reactId = useId();
+    /** Align with `useFormControl` default id (`${field.id}-input`) when inside `Form.Field`. */
+    const triggerId = formControlProps.id ?? `select-trigger-${reactId}`;
+    const contentId = `select-content-${reactId}`;
+    const ariaDescribedBy = formControlProps['aria-describedby'];
+
+    const contextValue = useMemo(
+      () => ({
+        open: open ?? false,
+        items,
+        setOpen,
+        value,
+        onValueChange: setValue,
+        disabled: isEffectivelyDisabled,
+        required: isEffectivelyRequired,
+        invalid: isEffectivelyInvalid,
+        readOnly: isEffectivelyReadOnly,
+        native,
+        triggerRef,
+        contentId,
+        triggerId,
+        activeValue,
+        setActiveValue,
+        accessibilityLabel,
+        ariaDescribedBy,
+      }),
+      [
+        open,
+        items,
+        setOpen,
+        value,
+        setValue,
+        isEffectivelyDisabled,
+        isEffectivelyRequired,
+        isEffectivelyInvalid,
+        isEffectivelyReadOnly,
+        native,
+        contentId,
+        triggerId,
+        activeValue,
+        accessibilityLabel,
+        ariaDescribedBy,
+      ],
+    );
+
+    const Comp = asChild ? Slot : View;
+
+    return (
+      <SelectProvider value={contextValue}>
+        <Comp
+          ref={ref}
+          {...props}
+          {...mergeDataAttributes(
+            props,
+            dataAttributes({
+              disabled: isEffectivelyDisabled,
+              required: isEffectivelyRequired,
+              invalid: isEffectivelyInvalid,
+              readonly: isEffectivelyReadOnly,
+            }),
+          )}
+        >
+          {children}
+        </Comp>
+      </SelectProvider>
+    );
+  },
+);
+
+SelectRoot.displayName = 'SelectRoot';

package/src/select/SelectTrigger.tsx

@@ -0,0 +1,82 @@
+import React, { forwardRef, type ComponentRef, type ReactNode } from 'react';
+import { Pressable } from 'react-native';
+import { Slot } from '../slot';
+import type { InteractionState } from '../types';
+import { dataAttributes, mergeDataAttributes } from '../utils/dataAttributes';
+import type { ISelectTriggerProps } from './types';
+import { useSelectTrigger } from './useSelectTrigger';
+
+export interface SelectTriggerProps extends Omit<ISelectTriggerProps, 'children'> {
+  asChild?: boolean;
+  children?: ((state: InteractionState) => ReactNode) | ReactNode;
+}
+
+export const SelectTrigger = forwardRef<ComponentRef<typeof Pressable>, SelectTriggerProps>(
+  (
+    {
+      asChild,
+      children,
+      isHovered,
+      isActive,
+      isFocused,
+      isFocusVisible,
+      isDisabled,
+      'aria-describedby': ariaDescribedBy,
+      onPress,
+      onPressIn,
+      onPressOut,
+      onHoverIn,
+      onHoverOut,
+      onFocus,
+      onBlur,
+      ...rest
+    },
+    ref,
+  ) => {
+    const { ariaProps, dataAttrValues, mergedRef, handlers, interactionState } = useSelectTrigger(
+      ref as React.ForwardedRef<unknown>,
+      {
+        asChild,
+        isHovered,
+        isActive,
+        isFocused,
+        isFocusVisible,
+        isDisabled,
+        ariaDescribedBy,
+        onPress,
+        onPressIn,
+        onPressOut,
+        onHoverIn,
+        onHoverOut,
+        onFocus: onFocus as (...args: unknown[]) => unknown,
+        onBlur: onBlur as (...args: unknown[]) => unknown,
+        onKeyDown: (rest as { onKeyDown?: (e: KeyboardEvent) => void }).onKeyDown,
+      },
+    );
+
+    const Comp = asChild ? Slot : Pressable;
+
+    return (
+      <Comp
+        ref={mergedRef}
+        {...ariaProps}
+        {...rest}
+        {...mergeDataAttributes(
+          rest,
+          dataAttributes(dataAttrValues as unknown as Record<string, boolean | string | undefined>),
+        )}
+        onPress={handlers.onPress}
+        onPressIn={handlers.onPressIn}
+        onPressOut={handlers.onPressOut}
+        onHoverIn={handlers.onHoverIn}
+        onHoverOut={handlers.onHoverOut}
+        onFocus={handlers.onFocus}
+        onBlur={handlers.onBlur}
+      >
+        {typeof children === 'function' ? children(interactionState) : children}
+      </Comp>
+    );
+  },
+);
+
+SelectTrigger.displayName = 'SelectTrigger';