@cdx-ui/components 0.0.1-beta.140 → 0.0.1-beta.141

package/src/components/DateField/index.tsx

@@ -0,0 +1,196 @@
+import { forwardRef, useMemo, type ReactNode } from 'react';
+import { View, type ViewProps } from 'react-native';
+import {
+  DateFieldInput as DateFieldInputPrimitive,
+  DateFieldRoot as DateFieldRootPrimitive,
+  DateFieldSegment as DateFieldSegmentPrimitive,
+  InputRoot as InputRootPrimitive,
+  Slot,
+  dataAttributes,
+  mergeDataAttributes,
+  type DateFieldRootProps as DateFieldRootPrimitiveProps,
+  type DateFieldSegmentProps as DateFieldSegmentPrimitiveProps,
+} from '@cdx-ui/primitives';
+import type { DateComponentLabels } from '@cdx-ui/formatters';
+import { cn, ParentContext, useParentContext } from '@cdx-ui/utils';
+import {
+  dateFieldGroupVariants,
+  dateFieldInputVariants,
+  dateFieldRootVariants,
+  dateFieldSegmentVariants,
+  dateFieldSuffixVariants,
+  type DateFieldGroupVariantProps,
+} from './styles';
+
+const SCOPE = 'DATE_FIELD';
+
+type DateFieldStyleContext = DateFieldGroupVariantProps & {
+  fullWidth?: boolean;
+};
+
+const useDateFieldStyleContext = (): DateFieldStyleContext =>
+  (useParentContext()[SCOPE] as DateFieldStyleContext | undefined) ?? {};
+
+export interface DateFieldProps extends DateFieldRootPrimitiveProps, DateFieldGroupVariantProps {
+  className?: string;
+  /** When true (the default), the group stretches to fill its container; when false, it hugs the segments. */
+  fullWidth?: boolean;
+  labels?: Partial<DateComponentLabels>;
+}
+
+const DateFieldRoot = forwardRef<View, DateFieldProps>(
+  (
+    {
+      mode = 'date',
+      locale = 'en-US',
+      labels,
+      variant = 'outline',
+      size = 'default',
+      fullWidth,
+      className,
+      children,
+      style,
+      ...props
+    },
+    ref,
+  ) => {
+    const parent = useParentContext();
+    const ctx = useMemo(
+      () => ({ ...parent, [SCOPE]: { variant, size, fullWidth } }),
+      [parent, variant, size, fullWidth],
+    );
+
+    return (
+      <ParentContext.Provider value={ctx}>
+        <DateFieldRootPrimitive
+          ref={ref}
+          mode={mode}
+          locale={locale}
+          labels={labels}
+          className={cn(dateFieldRootVariants(), className)}
+          style={style}
+          {...props}
+          {...mergeDataAttributes(props, dataAttributes({ slot: 'date-field' }))}
+        >
+          {children}
+        </DateFieldRootPrimitive>
+      </ParentContext.Provider>
+    );
+  },
+);
+
+DateFieldRoot.displayName = 'DateField';
+
+export interface DateFieldGroupProps extends ViewProps, DateFieldGroupVariantProps {
+  className?: string;
+  children?: ReactNode;
+  fullWidth?: boolean;
+}
+
+const DateFieldGroup = forwardRef<View, DateFieldGroupProps>(
+  ({ variant, size, fullWidth, className, children, style, ...props }, ref) => {
+    const inherited = useDateFieldStyleContext();
+    const resolvedVariant = variant ?? inherited.variant ?? 'outline';
+    const resolvedSize = size ?? inherited.size ?? 'default';
+    const resolvedFullWidth = fullWidth ?? inherited.fullWidth ?? true;
+    const computedClassName = cn(
+      dateFieldGroupVariants({ variant: resolvedVariant, size: resolvedSize }),
+      !resolvedFullWidth && 'w-auto self-start',
+      className,
+    );
+
+    return (
+      <InputRootPrimitive ref={ref} className={computedClassName} style={style} {...props}>
+        {children}
+      </InputRootPrimitive>
+    );
+  },
+);
+
+DateFieldGroup.displayName = 'DateField.Group';
+
+export interface DateFieldInputProps extends Omit<ViewProps, 'children'> {
+  children?: (segment: DateFieldSegmentPrimitiveProps['segment']) => ReactNode;
+  slot?: 'start' | 'end';
+  className?: string;
+}
+
+export interface DateFieldSegmentProps extends DateFieldSegmentPrimitiveProps {
+  className?: string;
+}
+
+const DateFieldSegment = forwardRef<View, DateFieldSegmentProps>(
+  ({ segment, className, style, ...props }, ref) => (
+    <DateFieldSegmentPrimitive
+      ref={ref}
+      segment={segment}
+      className={cn(dateFieldSegmentVariants({ literal: !segment.isEditable }), className)}
+      style={style}
+      {...props}
+      {...mergeDataAttributes(props, dataAttributes({ slot: 'date-field-segment' }))}
+    />
+  ),
+);
+
+DateFieldSegment.displayName = 'DateField.Segment';
+
+const renderDefaultDateFieldSegment = (segment: DateFieldSegmentPrimitiveProps['segment']) => (
+  <DateFieldSegment segment={segment} />
+);
+
+const DateFieldInput = forwardRef<View, DateFieldInputProps>(
+  ({ children = renderDefaultDateFieldSegment, className, style, ...props }, ref) => {
+    const { size } = useDateFieldStyleContext();
+    return (
+      <DateFieldInputPrimitive
+        ref={ref}
+        className={cn(dateFieldInputVariants({ size: size ?? 'default' }), className)}
+        style={style}
+        {...props}
+      >
+        {children}
+      </DateFieldInputPrimitive>
+    );
+  },
+);
+
+DateFieldInput.displayName = 'DateField.Input';
+
+export interface DateFieldSuffixProps extends ViewProps {
+  asChild?: boolean;
+  className?: string;
+  children?: ReactNode;
+}
+
+const DateFieldSuffix = forwardRef<View, DateFieldSuffixProps>(
+  ({ asChild, className, children, style, ...props }, ref) => {
+    const Comp = asChild ? Slot : View;
+    return (
+      <Comp
+        ref={ref}
+        className={cn(dateFieldSuffixVariants(), className)}
+        style={style}
+        {...props}
+        {...mergeDataAttributes(props, dataAttributes({ slot: 'date-field-suffix' }))}
+      >
+        {children}
+      </Comp>
+    );
+  },
+);
+
+DateFieldSuffix.displayName = 'DateField.Suffix';
+
+type DateFieldCompound = typeof DateFieldRoot & {
+  Group: typeof DateFieldGroup;
+  Input: typeof DateFieldInput;
+  Segment: typeof DateFieldSegment;
+  Suffix: typeof DateFieldSuffix;
+};
+
+export const DateField = Object.assign(DateFieldRoot, {
+  Group: DateFieldGroup,
+  Input: DateFieldInput,
+  Segment: DateFieldSegment,
+  Suffix: DateFieldSuffix,
+}) as DateFieldCompound;

package/src/components/DateField/styles.ts

@@ -0,0 +1,51 @@
+import { cva, type VariantProps } from '@cdx-ui/utils';
+import { inputRootVariants, inputSlotVariants } from '../Input/styles';
+
+export const dateFieldRootVariants = cva('gap-1.5');
+
+export const dateFieldGroupVariants = inputRootVariants;
+
+export const dateFieldInputVariants = cva(
+  [
+    'flex-1 min-w-0 flex-row flex-wrap items-center gap-px bg-transparent p-0',
+    'text-content-primary',
+    'web:outline-none',
+    'tracking-normal',
+    'tabular-nums',
+  ],
+  {
+    variants: {
+      size: {
+        default: 'text-[0.875rem]',
+        small: 'text-[0.75rem]',
+      },
+    },
+    defaultVariants: {
+      size: 'default',
+    },
+  },
+);
+
+export const dateFieldSegmentVariants = cva(
+  [
+    'body-md shrink-0 rounded-[var(--border-radius-default)] px-0.5 text-end tabular-nums',
+    'text-content-primary',
+    'data-[placeholder=true]:text-content-tertiary',
+    'data-[focus=true]:bg-surface-action-subtle data-[focus=true]:text-content-primary',
+  ],
+  {
+    variants: {
+      literal: {
+        true: 'text-content-secondary px-0',
+        false: '',
+      },
+    },
+    defaultVariants: {
+      literal: false,
+    },
+  },
+);
+
+export const dateFieldSuffixVariants = inputSlotVariants;
+
+export type DateFieldGroupVariantProps = VariantProps<typeof dateFieldGroupVariants>;

package/src/components/DatePicker/index.tsx

@@ -0,0 +1,187 @@
+import { forwardRef, useCallback, useMemo, type ReactNode } from 'react';
+import { View, type ViewProps } from 'react-native';
+import { CalendarToday } from '@cdx-ui/icons';
+import type { DateId } from '@cdx-ui/formatters';
+import {
+  dataAttributes,
+  DatePickerContext,
+  DatePickerRoot as DatePickerRootPrimitive,
+  mergeDataAttributes,
+  useDatePickerContext,
+  type DatePickerRootProps as DatePickerRootPrimitiveProps,
+} from '@cdx-ui/primitives';
+import { cn, ParentContext, useParentContext } from '@cdx-ui/utils';
+import { Dialog } from '../Dialog';
+import { Icon } from '../Icon';
+import { Calendar, type CalendarProps } from '../Calendar';
+import { PickerTrigger, type PickerTriggerProps } from '../picker/PickerTrigger';
+import {
+  PickerBottomSheetSurface,
+  PickerDialogSurface,
+  PickerPopoverSurface,
+} from '../picker/surfaces';
+
+export interface DatePickerProps extends DatePickerRootPrimitiveProps, Omit<ViewProps, 'children'> {
+  className?: string;
+  children?: ReactNode;
+}
+
+const DATE_FIELD_SCOPE = 'DATE_FIELD';
+
+const DatePickerRoot = forwardRef<View, DatePickerProps>(
+  ({ className, children, style, ...props }, ref) => {
+    const parent = useParentContext();
+    const ctx = useMemo(
+      () => ({
+        ...parent,
+        [DATE_FIELD_SCOPE]: { variant: 'outline', size: 'default', fullWidth: true },
+      }),
+      [parent],
+    );
+
+    return (
+      <ParentContext.Provider value={ctx}>
+        <DatePickerRootPrimitive
+          ref={ref}
+          className={cn('gap-2', className)}
+          style={style}
+          {...props}
+          {...mergeDataAttributes(props, dataAttributes({ slot: 'date-picker' }))}
+        >
+          {children}
+        </DatePickerRootPrimitive>
+      </ParentContext.Provider>
+    );
+  },
+);
+
+DatePickerRoot.displayName = 'DatePicker';
+
+type DatePickerTriggerProps = Omit<
+  PickerTriggerProps,
+  'open' | 'setOpen' | 'disabled' | 'triggerRef' | 'accessibilityLabel'
+> & {
+  accessibilityLabel?: string;
+};
+
+const DatePickerTrigger = forwardRef<View, DatePickerTriggerProps>(
+  ({ accessibilityLabel, ...props }, ref) => {
+    const { open, setOpen, disabled, triggerRef, labels } = useDatePickerContext();
+    return (
+      <PickerTrigger
+        ref={ref}
+        open={open}
+        setOpen={setOpen}
+        disabled={disabled}
+        triggerRef={triggerRef}
+        accessibilityLabel={accessibilityLabel ?? labels.openDatePicker}
+        {...props}
+      />
+    );
+  },
+);
+
+DatePickerTrigger.displayName = 'DatePicker.Trigger';
+
+const DatePickerTriggerIndicator = () => (
+  <Icon as={CalendarToday} className="text-content-secondary" />
+);
+
+DatePickerTriggerIndicator.displayName = 'DatePicker.TriggerIndicator';
+
+type DatePickerCalendarProps = Omit<
+  CalendarProps,
+  'value' | 'onValueChange' | 'minValue' | 'maxValue'
+>;
+
+const DatePickerCalendar = forwardRef<View, DatePickerCalendarProps>(({ ...props }, ref) => {
+  const { value, onValueChange, open, setOpen, minValue, maxValue, locale, labels } =
+    useDatePickerContext();
+
+  const handleValueChange = useCallback(
+    (next: DateId | undefined) => {
+      onValueChange?.(next);
+      if (open) {
+        setOpen(false);
+      }
+    },
+    [onValueChange, open, setOpen],
+  );
+
+  return (
+    <Calendar
+      ref={ref}
+      value={value}
+      onValueChange={handleValueChange}
+      minValue={minValue}
+      maxValue={maxValue}
+      locale={locale}
+      labels={labels}
+      {...props}
+    />
+  );
+});
+
+DatePickerCalendar.displayName = 'DatePicker.Calendar';
+
+function DatePickerDialog({ children }: { children: ReactNode }) {
+  const ctx = useDatePickerContext();
+  return (
+    <PickerDialogSurface
+      open={ctx.open}
+      setOpen={ctx.setOpen}
+      registerSurface={ctx.registerSurface}
+    >
+      <Dialog.Popup className="p-4">
+        <DatePickerContext.Provider value={ctx}>{children}</DatePickerContext.Provider>
+      </Dialog.Popup>
+    </PickerDialogSurface>
+  );
+}
+
+function DatePickerBottomSheet({ children }: { children: ReactNode }) {
+  const ctx = useDatePickerContext();
+  return (
+    <PickerBottomSheetSurface
+      open={ctx.open}
+      setOpen={ctx.setOpen}
+      registerSurface={ctx.registerSurface}
+    >
+      <DatePickerContext.Provider value={ctx}>{children}</DatePickerContext.Provider>
+    </PickerBottomSheetSurface>
+  );
+}
+
+function DatePickerPopover({ children, className }: { children: ReactNode; className?: string }) {
+  const ctx = useDatePickerContext();
+  return (
+    <PickerPopoverSurface
+      open={ctx.open}
+      setOpen={ctx.setOpen}
+      registerSurface={ctx.registerSurface}
+      anchorRef={ctx.anchorRef}
+      triggerRef={ctx.triggerRef}
+      className={className}
+    >
+      <DatePickerContext.Provider value={ctx}>{children}</DatePickerContext.Provider>
+    </PickerPopoverSurface>
+  );
+}
+
+type DatePickerCompound = typeof DatePickerRoot & {
+  Trigger: typeof DatePickerTrigger;
+  TriggerIndicator: typeof DatePickerTriggerIndicator;
+  Calendar: typeof DatePickerCalendar;
+  Popover: typeof DatePickerPopover;
+  Dialog: typeof DatePickerDialog;
+  BottomSheet: typeof DatePickerBottomSheet;
+};
+
+export const DatePicker = Object.assign(DatePickerRoot, {
+  Trigger: DatePickerTrigger,
+  TriggerIndicator: DatePickerTriggerIndicator,
+  Calendar: DatePickerCalendar,
+  Popover: DatePickerPopover,
+  Dialog: DatePickerDialog,
+  BottomSheet: DatePickerBottomSheet,
+}) as DatePickerCompound;

package/src/components/DateRangePicker/index.tsx

@@ -0,0 +1,202 @@
+import { forwardRef, useMemo, type ReactNode } from 'react';
+import { Text, View, type ViewProps } from 'react-native';
+import { CalendarToday } from '@cdx-ui/icons';
+import {
+  dataAttributes,
+  DateRangePickerContext,
+  DateRangePickerRoot as DateRangePickerRootPrimitive,
+  mergeDataAttributes,
+  useDateRangePickerContext,
+  type DateRangePickerRootProps as DateRangePickerRootPrimitiveProps,
+} from '@cdx-ui/primitives';
+import { cn, ParentContext, useParentContext } from '@cdx-ui/utils';
+import { Dialog } from '../Dialog';
+import { Icon } from '../Icon';
+import { RangeCalendar, type RangeCalendarProps } from '../RangeCalendar';
+import { PickerTrigger, type PickerTriggerProps } from '../picker/PickerTrigger';
+import {
+  PickerBottomSheetSurface,
+  PickerDialogSurface,
+  PickerPopoverSurface,
+} from '../picker/surfaces';
+
+export type { DateRangeValue } from '@cdx-ui/primitives';
+
+export interface DateRangePickerProps
+  extends DateRangePickerRootPrimitiveProps, Omit<ViewProps, 'children'> {
+  className?: string;
+  children?: ReactNode;
+}
+
+const DATE_FIELD_SCOPE = 'DATE_FIELD';
+
+const DateRangePickerRoot = forwardRef<View, DateRangePickerProps>(
+  ({ className, children, style, ...props }, ref) => {
+    const parent = useParentContext();
+    const ctx = useMemo(
+      () => ({
+        ...parent,
+        [DATE_FIELD_SCOPE]: { variant: 'outline', size: 'default', fullWidth: true },
+      }),
+      [parent],
+    );
+
+    return (
+      <ParentContext.Provider value={ctx}>
+        <DateRangePickerRootPrimitive
+          ref={ref}
+          className={cn('gap-2', className)}
+          style={style}
+          {...props}
+          {...mergeDataAttributes(props, dataAttributes({ slot: 'date-range-picker' }))}
+        >
+          {children}
+        </DateRangePickerRootPrimitive>
+      </ParentContext.Provider>
+    );
+  },
+);
+
+DateRangePickerRoot.displayName = 'DateRangePicker';
+
+type DateRangePickerTriggerProps = Omit<
+  PickerTriggerProps,
+  'open' | 'setOpen' | 'disabled' | 'triggerRef' | 'accessibilityLabel'
+> & {
+  accessibilityLabel?: string;
+};
+
+const DateRangePickerTrigger = forwardRef<View, DateRangePickerTriggerProps>(
+  ({ accessibilityLabel, ...props }, ref) => {
+    const { open, setOpen, disabled, triggerRef, labels } = useDateRangePickerContext();
+    return (
+      <PickerTrigger
+        ref={ref}
+        open={open}
+        setOpen={setOpen}
+        disabled={disabled}
+        triggerRef={triggerRef}
+        accessibilityLabel={accessibilityLabel ?? labels.openDateRangePicker}
+        {...props}
+      />
+    );
+  },
+);
+
+DateRangePickerTrigger.displayName = 'DateRangePicker.Trigger';
+
+const DateRangePickerTriggerIndicator = () => (
+  <Icon as={CalendarToday} className="text-content-secondary" />
+);
+
+DateRangePickerTriggerIndicator.displayName = 'DateRangePicker.TriggerIndicator';
+
+const DateRangePickerRangeSeparator = () => {
+  const { labels } = useDateRangePickerContext();
+  return <Text className="body-md text-content-secondary px-1">{labels.rangeSeparator}</Text>;
+};
+
+DateRangePickerRangeSeparator.displayName = 'DateRangePicker.RangeSeparator';
+
+type DateRangePickerCalendarProps = Omit<
+  RangeCalendarProps,
+  'startValue' | 'endValue' | 'onRangeChange' | 'focusedField' | 'onFocusedFieldChange'
+>;
+
+const DateRangePickerCalendar = forwardRef<View, DateRangePickerCalendarProps>(
+  ({ ...props }, ref) => {
+    const { startValue, endValue, onRangeChange, focusedField, setFocusedField, locale, labels } =
+      useDateRangePickerContext();
+
+    return (
+      <RangeCalendar
+        ref={ref}
+        startValue={startValue}
+        endValue={endValue}
+        focusedField={focusedField}
+        onFocusedFieldChange={setFocusedField}
+        locale={locale}
+        labels={labels}
+        onRangeChange={(range) => {
+          if (!range.startId) {
+            return;
+          }
+          onRangeChange?.({ startId: range.startId, endId: range.endId });
+        }}
+        {...props}
+      />
+    );
+  },
+);
+
+DateRangePickerCalendar.displayName = 'DateRangePicker.Calendar';
+
+function DateRangePickerDialog({ children }: { children: ReactNode }) {
+  const ctx = useDateRangePickerContext();
+  return (
+    <PickerDialogSurface
+      open={ctx.open}
+      setOpen={ctx.setOpen}
+      registerSurface={ctx.registerSurface}
+    >
+      <Dialog.Popup className="p-4">
+        <DateRangePickerContext.Provider value={ctx}>{children}</DateRangePickerContext.Provider>
+      </Dialog.Popup>
+    </PickerDialogSurface>
+  );
+}
+
+function DateRangePickerBottomSheet({ children }: { children: ReactNode }) {
+  const ctx = useDateRangePickerContext();
+  return (
+    <PickerBottomSheetSurface
+      open={ctx.open}
+      setOpen={ctx.setOpen}
+      registerSurface={ctx.registerSurface}
+    >
+      <DateRangePickerContext.Provider value={ctx}>{children}</DateRangePickerContext.Provider>
+    </PickerBottomSheetSurface>
+  );
+}
+
+function DateRangePickerPopover({
+  children,
+  className,
+}: {
+  children: ReactNode;
+  className?: string;
+}) {
+  const ctx = useDateRangePickerContext();
+  return (
+    <PickerPopoverSurface
+      open={ctx.open}
+      setOpen={ctx.setOpen}
+      registerSurface={ctx.registerSurface}
+      anchorRef={ctx.anchorRef}
+      triggerRef={ctx.triggerRef}
+      className={className}
+    >
+      <DateRangePickerContext.Provider value={ctx}>{children}</DateRangePickerContext.Provider>
+    </PickerPopoverSurface>
+  );
+}
+
+type DateRangePickerCompound = typeof DateRangePickerRoot & {
+  Trigger: typeof DateRangePickerTrigger;
+  TriggerIndicator: typeof DateRangePickerTriggerIndicator;
+  RangeSeparator: typeof DateRangePickerRangeSeparator;
+  Calendar: typeof DateRangePickerCalendar;
+  Popover: typeof DateRangePickerPopover;
+  Dialog: typeof DateRangePickerDialog;
+  BottomSheet: typeof DateRangePickerBottomSheet;
+};
+
+export const DateRangePicker = Object.assign(DateRangePickerRoot, {
+  Trigger: DateRangePickerTrigger,
+  TriggerIndicator: DateRangePickerTriggerIndicator,
+  RangeSeparator: DateRangePickerRangeSeparator,
+  Calendar: DateRangePickerCalendar,
+  Popover: DateRangePickerPopover,
+  Dialog: DateRangePickerDialog,
+  BottomSheet: DateRangePickerBottomSheet,
+}) as DateRangePickerCompound;