@cdx-ui/primitives 0.0.1-beta.7 → 0.0.1-beta.71

package/src/input/types.ts

@@ -1,3 +1,4 @@
+import type { ReactNode } from 'react';
 import type { TextInputProps, ViewProps } from 'react-native';
 
 export interface InputContext {
@@ -7,48 +8,35 @@ export interface InputContext {
   isRequired?: boolean;
   isHovered?: boolean;
   isFocused?: boolean;
-  handleFocus?: any;
+  handleFocus?: (focusState: boolean, callback: () => void) => void;
   isFocusVisible?: boolean;
   isFullWidth?: boolean;
   inputRef?: any;
-  setIsFocused?: any;
+  setIsFocused?: (focused: boolean) => void;
   inputFieldRef?: any;
 }
 
 export interface IInputFieldProps {
-  /**
-   * If true, the input will indicate an error.
-   */
+  /** If true, the input will indicate an error. */
   isInvalid?: boolean;
-  /**
-   * 	If true, the input will be disabled.
-   */
+  /** If true, the input will be disabled. */
   isDisabled?: boolean;
-  /**
-   * 	If true, the input will be hovered.
-   */
+  /** If true, the input will be hovered. */
   isHovered?: boolean;
-
-  /**
-   * 	If true, the input will be focused.
-   */
+  /** If true, the input will be focused. */
   isFocused?: boolean;
-  /**
-   * This will set aria-required="true" on web when passed in formcontrol.
-   */
+  /** Sets `aria-required="true"` on web when passed in form control. */
   isRequired?: boolean;
-  /**
-   * If true, prevents the value of the input from being edited.
-   */
+  /** If true, prevents the value of the input from being edited. */
   isReadOnly?: boolean;
-  /**
-   * If true, the input element will span the full width of its parent
-   */
+  /** If true, the input element will span the full width of its parent. */
   isFullWidth?: boolean;
 }
-export interface IInputRootProps extends IInputFieldProps {
-  children?: React.ReactNode;
+
+export interface IInputRootProps extends ViewProps, IInputFieldProps {
+  children?: ReactNode;
   isFocusVisible?: boolean;
+  asChild?: boolean;
 }
 
 interface IInputBaseProps extends TextInputProps {
@@ -57,6 +45,12 @@ interface IInputBaseProps extends TextInputProps {
   isInvalid?: boolean;
   isReadOnly?: boolean;
   isRequired?: boolean;
+  /**
+   * Render the consumer's child element in place of the default host. The
+   * primitive merges its wired behavior (focus/blur, ARIA props, refs) onto
+   * the child. When set, the `type="file"` web branch is bypassed.
+   */
+  asChild?: boolean;
 }
 
 interface IInputTextProps extends IInputBaseProps {
@@ -76,34 +70,8 @@ interface IInputFileProps extends IInputBaseProps {
 }
 
 export type IInputProps = IInputTextProps | IInputFileProps;
-export interface IInputIconProps extends ViewProps {
-  children?: React.ReactNode;
-}
 
 export interface IInputSlotProps extends ViewProps {
-  children?: React.ReactNode;
-  onPress?: () => void;
+  children?: ReactNode;
   isDisabled?: boolean;
-  /**
-   * If true, the input will be focused on press.
-   * @default true
-   */
-  focusOnPress?: boolean;
 }
-
-export type IInputComponentType<
-  RootProps,
-  SlotProps,
-  FieldProps,
-  RootRef = unknown,
-  FieldRef = unknown,
-> = React.ForwardRefExoticComponent<
-  React.PropsWithoutRef<RootProps & IInputFieldProps> & React.RefAttributes<RootRef>
-> & {
-  Slot: React.ForwardRefExoticComponent<
-    React.PropsWithoutRef<SlotProps & IInputSlotProps> & React.RefAttributes<unknown>
-  >;
-  Field: React.ForwardRefExoticComponent<
-    React.PropsWithoutRef<FieldProps & IInputProps> & React.RefAttributes<FieldRef>
-  >;
-};

package/src/link/LinkRoot.tsx

@@ -0,0 +1,108 @@
+import type React from 'react';
+import { forwardRef, useMemo } from 'react';
+import { Pressable, type PressableProps } 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 { LinkInteractionProvider, type LinkInteractionState } from './context';
+import { useLink } from './useLink';
+import type { ILinkProps } from './types';
+
+export interface LinkRootProps extends Omit<ILinkProps, 'children'> {
+  asChild?: boolean;
+  children?: ((state: LinkInteractionState) => React.ReactNode) | React.ReactNode;
+}
+
+export const LinkRoot = forwardRef<React.ComponentRef<typeof Pressable>, LinkRootProps>(
+  (
+    {
+      asChild,
+      children,
+      isHovered: isHoveredProp,
+      isPressed: isPressedProp,
+      isFocused: isFocusedProp,
+      isFocusVisible: isFocusVisibleProp,
+      isVisited: isVisitedProp,
+      href,
+      onPress,
+      action,
+      webProps,
+      ...props
+    },
+    ref,
+  ) => {
+    const { isFocused, focusProps } = useFocus();
+    const { isFocusVisible, focusProps: focusRingProps } = useFocusRing() as {
+      isFocusVisible: boolean;
+      focusProps: typeof focusProps;
+    };
+    const { pressProps, isPressed } = usePress({});
+    const { isHovered, hoverProps } = useHover();
+
+    const { linkProps } = useLink({
+      href,
+      onPress,
+      action,
+      webProps,
+    });
+
+    const hover = isHoveredProp || isHovered;
+    const visited = isVisitedProp ?? false;
+    const focusVisible = isFocusVisibleProp || isFocusVisible;
+
+    const contextValue = useMemo(
+      () => ({
+        hover,
+        visited,
+        focusVisible,
+      }),
+      [hover, visited, focusVisible],
+    );
+
+    const Comp = asChild ? Slot : Pressable;
+
+    return (
+      <LinkInteractionProvider value={contextValue}>
+        <Comp
+          ref={ref}
+          {...linkProps}
+          {...(props as PressableProps)}
+          {...mergeDataAttributes(
+            props,
+            dataAttributes({
+              hover,
+              focus: isFocusedProp || isFocused,
+              active: isPressedProp || isPressed,
+              focusVisible,
+              visited,
+            }),
+          )}
+          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,
+          )}
+        >
+          {typeof children === 'function' ? children(contextValue) : children}
+        </Comp>
+      </LinkInteractionProvider>
+    );
+  },
+);
+
+LinkRoot.displayName = 'LinkRoot';

package/src/link/context.tsx

@@ -0,0 +1,10 @@
+import { createContext } from '@cdx-ui/utils';
+
+export interface LinkInteractionState {
+  hover: boolean;
+  visited: boolean;
+  focusVisible: boolean;
+}
+
+export const [LinkInteractionProvider, useLinkInteractionContext] =
+  createContext<LinkInteractionState>('LinkInteractionContext');

package/src/link/index.tsx

@@ -1,4 +1,6 @@
-export { createLink } from './createLink';
+export { LinkRoot, type LinkRootProps } from './LinkRoot';
+export { LinkInteractionProvider, useLinkInteractionContext } from './context';
+export type { LinkInteractionState } from './context';
 export { LinkProvider } from './LinkProvider';
 export type { LinkConfig } from './LinkProvider';
 export { useLink } from './useLink';

package/src/link/types.ts

@@ -32,6 +32,7 @@ export interface ILinkProps extends PressableProps {
   isHovered?: boolean;
   isFocused?: boolean;
   isFocusVisible?: boolean;
+  isVisited?: boolean;
   /**
    * HTML anchor attributes applied only on web. Ignored on native platforms.
    * `target`, `rel`, and `download` are forwarded via react-native-web's `hrefAttrs`.

package/src/list-item/ListItemRoot.tsx

@@ -0,0 +1,183 @@
+import React, { forwardRef, useMemo, type ComponentRef } from 'react';
+import { Pressable, View, type PressableProps, type ViewProps } 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 type { InteractionState } from '../types';
+import { Slot } from '../slot';
+import { dataAttributes, mergeDataAttributes } from '../utils/dataAttributes';
+import { ListItemProvider } from './context';
+import type { IListItemPressablePassthrough, IListItemProps, ListItemCrossAlign } from './types';
+
+function rowStyleForCrossAlign(crossAlign: ListItemCrossAlign) {
+  return {
+    flexDirection: 'row' as const,
+    alignSelf: 'stretch' as const,
+    alignItems: crossAlign === 'start' ? ('flex-start' as const) : ('center' as const),
+  };
+}
+
+export interface ListItemRootProps extends IListItemProps {}
+
+export const ListItemRoot = forwardRef<ComponentRef<typeof View>, ListItemRootProps>(
+  (
+    {
+      asChild = false,
+      children,
+      onPress,
+      crossAlign = 'center',
+      isDisabled = false,
+      style,
+      ...restProps
+    },
+    ref,
+  ) => {
+    const asChildInteractive = asChild && React.isValidElement(children);
+    const isPressableRoot = !!onPress && !asChildInteractive;
+
+    const pressState = usePress({
+      isDisabled: !isPressableRoot || isDisabled,
+    });
+    const isPressed = pressState.isPressed;
+    const pressProps = pressState.pressProps as Pick<PressableProps, 'onPressIn' | 'onPressOut'>;
+    const { hoverProps, isHovered } = useHover();
+    const { isFocused, focusProps } = useFocus();
+    const { isFocusVisible, focusProps: focusRingProps } = useFocusRing() as {
+      isFocusVisible: boolean;
+      focusProps: typeof focusProps;
+    };
+
+    const childDisabled =
+      asChildInteractive &&
+      !!(
+        (children as React.ReactElement<{ disabled?: boolean; isDisabled?: boolean }>).props
+          .isDisabled ??
+        (children as React.ReactElement<{ disabled?: boolean; isDisabled?: boolean }>).props
+          .disabled
+      );
+    const resolvedDisabled = isDisabled || childDisabled;
+
+    const contextValue = useMemo<InteractionState>(
+      () => ({
+        hover: isPressableRoot ? isHovered : false,
+        focus: isPressableRoot ? isFocused : false,
+        active: isPressableRoot ? isPressed : false,
+        disabled: isPressableRoot ? isDisabled : resolvedDisabled,
+        focusVisible: isPressableRoot ? isFocusVisible : false,
+      }),
+      [
+        isPressableRoot,
+        isHovered,
+        isFocused,
+        isPressed,
+        isDisabled,
+        resolvedDisabled,
+        isFocusVisible,
+      ],
+    );
+
+    if (asChildInteractive) {
+      const slotMergeProps: Record<string, unknown> = {
+        ...restProps,
+        ...(resolvedDisabled && { accessibilityState: { disabled: true } }),
+        disabled: resolvedDisabled,
+        style: [rowStyleForCrossAlign(crossAlign), style],
+      };
+
+      // Only set onPress when we have a parent handler to compose. Slot merges this
+      // with the child's own onPress (child first, then ours). When there is no parent
+      // onPress, omitting it preserves the child's internal handler (e.g. Link's useLink).
+      // When disabled, `disabled` prop suppresses press events on the child.
+      if (!resolvedDisabled && onPress) {
+        slotMergeProps.onPress = onPress;
+      }
+
+      return (
+        <ListItemProvider value={contextValue}>
+          <Slot
+            ref={ref as React.Ref<View>}
+            {...(slotMergeProps as PressableProps)}
+            {...mergeDataAttributes(
+              restProps,
+              dataAttributes({
+                active: false,
+                hover: false,
+                focus: false,
+                focusVisible: false,
+                disabled: resolvedDisabled,
+              }),
+            )}
+          >
+            {children}
+          </Slot>
+        </ListItemProvider>
+      );
+    }
+
+    if (isPressableRoot) {
+      const {
+        onPressIn: onPressInProp,
+        onPressOut: onPressOutProp,
+        onHoverIn: onHoverInProp,
+        onHoverOut: onHoverOutProp,
+        onFocus: onFocusProp,
+        onBlur: onBlurProp,
+      } = restProps as IListItemPressablePassthrough & Pick<PressableProps, 'onFocus' | 'onBlur'>;
+
+      return (
+        <ListItemProvider value={contextValue}>
+          <Pressable
+            {...(restProps as PressableProps)}
+            ref={ref}
+            {...(isDisabled && { accessibilityState: { disabled: true } })}
+            disabled={isDisabled}
+            style={[rowStyleForCrossAlign(crossAlign), style]}
+            onPress={isDisabled ? undefined : onPress}
+            onPressIn={composeEventHandlers(onPressInProp, pressProps.onPressIn)}
+            onPressOut={composeEventHandlers(onPressOutProp, pressProps.onPressOut)}
+            onHoverIn={composeEventHandlers(onHoverInProp, hoverProps.onHoverIn)}
+            onHoverOut={composeEventHandlers(onHoverOutProp, hoverProps.onHoverOut)}
+            onFocus={composeEventHandlers(
+              composeEventHandlers(onFocusProp, focusProps.onFocus),
+              focusRingProps.onFocus,
+            )}
+            onBlur={composeEventHandlers(
+              composeEventHandlers(onBlurProp, focusProps.onBlur),
+              focusRingProps.onBlur,
+            )}
+            {...mergeDataAttributes(
+              restProps,
+              dataAttributes({
+                active: isPressed,
+                hover: isHovered,
+                focus: isFocused,
+                focusVisible: isFocusVisible,
+                disabled: isDisabled,
+              }),
+            )}
+          >
+            {children}
+          </Pressable>
+        </ListItemProvider>
+      );
+    }
+
+    return (
+      <ListItemProvider value={contextValue}>
+        <View
+          {...(restProps as ViewProps)}
+          ref={ref}
+          style={[rowStyleForCrossAlign(crossAlign), style]}
+          {...mergeDataAttributes(
+            restProps,
+            isDisabled ? dataAttributes({ disabled: true }) : undefined,
+          )}
+        >
+          {children}
+        </View>
+      </ListItemProvider>
+    );
+  },
+);
+
+ListItemRoot.displayName = 'ListItemRoot';

package/src/list-item/context.tsx

@@ -1,5 +1,5 @@
 import { createContext } from '@cdx-ui/utils';
-import type { IListItemContextValue } from './types';
+import type { InteractionState } from '../types';
 
 export const [ListItemProvider, useListItemContext] =
-  createContext<IListItemContextValue>('ListItemContext');
+  createContext<InteractionState>('ListItemContext');

package/src/list-item/index.ts

@@ -1,88 +1,10 @@
-import type React from 'react';
-import { createListItemContent } from './createListItemContent';
-import { createListItemDescription } from './createListItemDescription';
-import { createListItemLeadingSlot } from './createListItemLeadingSlot';
-import { createListItemMeta } from './createListItemMeta';
-import { createListItemRoot } from './createListItemRoot';
-import { createListItemSectionHeader } from './createListItemSectionHeader';
-import { createListItemTitle } from './createListItemTitle';
-import { createListItemTrailingSlot } from './createListItemTrailingSlot';
-import type { IListItemComponentType } from './types';
-
 export type {
-  IListItemComponentType,
-  IListItemContentProps,
-  IListItemContextValue,
-  IListItemDescriptionProps,
-  IListItemLeadingSlotProps,
-  IListItemMetaProps,
   IListItemPressablePassthrough,
   IListItemProps,
-  IListItemSectionHeaderProps,
-  IListItemTitleProps,
-  IListItemTrailingSlotProps,
+  InterfaceListItemProps,
   ListItemCrossAlign,
   ListItemSize,
-  ListItemSurface,
 } from './types';
 
 export { ListItemProvider, useListItemContext } from './context';
-
-export function createListItem<
-  ViewComponent,
-  PressableComponent,
-  LeadingSlot,
-  Content,
-  Title,
-  Description,
-  Meta,
-  TrailingSlot,
-  SectionHeader,
->(BaseComponents: {
-  View: React.ComponentType<ViewComponent>;
-  Pressable: React.ComponentType<PressableComponent>;
-  LeadingSlot: React.ComponentType<LeadingSlot>;
-  Content: React.ComponentType<Content>;
-  Title: React.ComponentType<Title>;
-  Description: React.ComponentType<Description>;
-  Meta: React.ComponentType<Meta>;
-  TrailingSlot: React.ComponentType<TrailingSlot>;
-  SectionHeader: React.ComponentType<SectionHeader>;
-}) {
-  const ListItem = createListItemRoot(BaseComponents.View, BaseComponents.Pressable);
-  const LeadingSlot = createListItemLeadingSlot(BaseComponents.LeadingSlot);
-  const Content = createListItemContent(BaseComponents.Content);
-  const Title = createListItemTitle(BaseComponents.Title);
-  const Description = createListItemDescription(BaseComponents.Description);
-  const Meta = createListItemMeta(BaseComponents.Meta);
-  const TrailingSlot = createListItemTrailingSlot(BaseComponents.TrailingSlot);
-  const SectionHeader = createListItemSectionHeader(BaseComponents.SectionHeader);
-
-  ListItem.displayName = 'ListItemPrimitive';
-  LeadingSlot.displayName = 'ListItemPrimitive.LeadingSlot';
-  Content.displayName = 'ListItemPrimitive.Content';
-  Title.displayName = 'ListItemPrimitive.Title';
-  Description.displayName = 'ListItemPrimitive.Description';
-  Meta.displayName = 'ListItemPrimitive.Meta';
-  TrailingSlot.displayName = 'ListItemPrimitive.TrailingSlot';
-  SectionHeader.displayName = 'ListItemPrimitive.SectionHeader';
-
-  return Object.assign(ListItem, {
-    LeadingSlot,
-    Content,
-    Title,
-    Description,
-    Meta,
-    TrailingSlot,
-    SectionHeader,
-  }) as IListItemComponentType<
-    ViewComponent | PressableComponent,
-    LeadingSlot,
-    Content,
-    Title,
-    Description,
-    Meta,
-    TrailingSlot,
-    SectionHeader
-  >;
-}
+export { ListItemRoot, type ListItemRootProps } from './ListItemRoot';

package/src/list-item/types.ts

@@ -1,10 +1,7 @@
-import type { ForwardRefExoticComponent, PropsWithoutRef, ReactNode, RefAttributes } from 'react';
-import type { PressableProps, TextProps, ViewProps } from 'react-native';
+import type { PressableProps, ViewProps } from 'react-native';
 
 export type ListItemSize = 'default' | 'compact';
 
-export type ListItemSurface = 'default' | 'negative';
-
 /**
  * Cross-axis alignment for the row (`flex-direction: row`).
  * - **center**: Leading, content, and trailing are vertically centered (typical transactions).
@@ -16,32 +13,18 @@ export type IListItemPressablePassthrough = Partial<
   Pick<PressableProps, 'onPressIn' | 'onPressOut' | 'onHoverIn' | 'onHoverOut'>
 >;
 
-export interface IListItemProps extends ViewProps, IListItemPressablePassthrough {
+export interface InterfaceListItemProps extends ViewProps, IListItemPressablePassthrough {
   /**
    * Disables press handling when the root is pressable (maps to Pressable `disabled`).
    */
-  disabled?: boolean;
+  isDisabled?: boolean;
   /**
    * When set (and `asChild` is not used), root renders as pressable with interaction props.
    */
   onPress?: PressableProps['onPress'];
-  /**
-   * Vertical density; mapped at styled layer via `data-size`.
-   * @default 'default'
-   */
-  size?: ListItemSize;
-  /**
-   * Semantic row surface (e.g. canceled transaction); mapped via `data-surface`.
-   * @default 'default'
-   */
-  surface?: ListItemSurface;
-  /**
-   * Whether the row shows a bottom separator; mapped via `data-separator`.
-   * @default true
-   */
-  showSeparator?: boolean;
   /**
    * Vertical alignment of leading / content / trailing along the row cross axis.
+   * Drives the primitive's inline row style and the styled-layer CVA in tandem.
    * @default 'center'
    */
   crossAlign?: ListItemCrossAlign;
@@ -52,71 +35,4 @@ export interface IListItemProps extends ViewProps, IListItemPressablePassthrough
   asChild?: boolean;
 }
 
-export interface IListItemContextValue {
-  isPressed: boolean;
-  isHovered: boolean;
-  isDisabled: boolean;
-  crossAlign: ListItemCrossAlign;
-}
-
-export interface IListItemLeadingSlotProps extends ViewProps {
-  /**
-   * Decorative leading content defaults to hidden from the accessibility tree.
-   * Set to `false` when the leading region contains meaningful controls.
-   * @default true
-   */
-  'aria-hidden'?: boolean;
-}
-
-export type IListItemContentProps = ViewProps;
-
-export type IListItemTitleProps = TextProps;
-
-export type IListItemDescriptionProps = TextProps;
-
-export type IListItemMetaProps = TextProps;
-
-export type IListItemTrailingSlotProps = ViewProps;
-
-export interface IListItemSectionHeaderProps extends ViewProps {
-  /** Primary section label (e.g. date heading). */
-  children: ReactNode;
-  /** Optional right-aligned adornment (e.g. section Chip). */
-  trailing?: ReactNode;
-  /**
-   * Whether to expose the top divider marker for styling (`data-divider`).
-   * @default true
-   */
-  showDivider?: boolean;
-}
-
-export type IListItemComponentType<
-  RootRef,
-  LeadingSlot,
-  Content,
-  Title,
-  Description,
-  Meta,
-  TrailingSlot,
-  SectionHeader,
-> = ForwardRefExoticComponent<RefAttributes<RootRef> & IListItemProps> & {
-  LeadingSlot: ForwardRefExoticComponent<
-    RefAttributes<LeadingSlot> & PropsWithoutRef<LeadingSlot> & IListItemLeadingSlotProps
-  >;
-  Content: ForwardRefExoticComponent<
-    RefAttributes<Content> & PropsWithoutRef<Content> & IListItemContentProps
-  >;
-  Title: ForwardRefExoticComponent<
-    RefAttributes<Title> & PropsWithoutRef<Title> & IListItemTitleProps
-  >;
-  Description: ForwardRefExoticComponent<
-    RefAttributes<Description> & PropsWithoutRef<Description> & IListItemDescriptionProps
-  >;
-  Meta: ForwardRefExoticComponent<RefAttributes<Meta> & PropsWithoutRef<Meta> & IListItemMetaProps>;
-  TrailingSlot: ForwardRefExoticComponent<
-    RefAttributes<TrailingSlot> & PropsWithoutRef<TrailingSlot> & IListItemTrailingSlotProps
-  >;
-  SectionHeader: ForwardRefExoticComponent<
-    RefAttributes<SectionHeader> & PropsWithoutRef<SectionHeader> & IListItemSectionHeaderProps
-  >;
-};
+export type IListItemProps = InterfaceListItemProps;