@cdx-ui/components 0.0.1-beta.17 → 0.0.1-beta.170

package/src/components/Carousel/index.tsx

@@ -0,0 +1,268 @@
+import {
+  forwardRef,
+  useCallback,
+  useRef,
+  type ReactElement,
+  type ReactNode,
+  type Ref,
+  type RefObject,
+} from 'react';
+import type { AccessibilityRole, AccessibilityState, ViewStyle } from 'react-native';
+import { useSharedValue } from 'react-native-reanimated';
+import type { SharedValue } from 'react-native-reanimated';
+import RNCarousel, {
+  Pagination as RNCarouselPagination,
+  type ICarouselInstance,
+  type TCarouselProps,
+} from 'react-native-reanimated-carousel';
+import { useResolveClassNames } from 'uniwind';
+import { cn, mergeRefs } from '@cdx-ui/utils';
+import {
+  CarouselProgressProvider,
+  useCarouselProgressContext,
+  type CarouselContextValue,
+} from './context';
+import { CarouselNextButton, CarouselPrevButton } from './navButton';
+import { resolveCarouselPaginationScrollAction } from './paginationNavigation';
+import { carouselPaginationContainerClassName, carouselPaginationDotVariants } from './styles';
+
+export type { CarouselNavButtonProps } from './navButton';
+
+export type CarouselRef = ICarouselInstance;
+
+/**
+ * Full passthrough of `react-native-reanimated-carousel`'s own props (per `01-api-design.md`,
+ * Resolved Question #1) — re-exported under a Forge-owned name so consumers never import the
+ * adopted library directly. A type alias (not `interface extends`) because `TCarouselProps<T>`
+ * is itself a union-containing type (vertical/mode discriminants), which interfaces cannot extend.
+ */
+export type CarouselProps<T> = TCarouselProps<T> & {
+  className?: string;
+  /** Rendered inside the carousel's progress-sharing provider — use to compose `Carousel.Pagination`, `Carousel.PrevButton`, and `Carousel.NextButton`. */
+  children?: ReactNode;
+};
+
+/** Mirrors the adopted library's private `DotStyle` shape (not exported) without importing it. */
+type CarouselDotStyle = Omit<ViewStyle, 'width' | 'height' | 'backgroundColor' | 'borderRadius'> & {
+  width?: number;
+  height?: number;
+  backgroundColor?: string;
+  borderRadius?: number;
+};
+
+function isSharedValueProgress(value: unknown): value is SharedValue<number> {
+  return typeof value === 'object' && value !== null && 'value' in value;
+}
+
+function CarouselInner<T>(
+  {
+    className,
+    style,
+    onProgressChange,
+    children,
+    loop = true,
+    defaultIndex = 0,
+    ...rest
+  }: CarouselProps<T>,
+  ref: Ref<ICarouselInstance>,
+) {
+  const internalRef = useRef<ICarouselInstance>(null);
+  const internalProgress = useSharedValue(defaultIndex);
+  const resolvedClassNameStyle = useResolveClassNames(cn(className));
+  const vertical = rest.vertical ?? false;
+  const itemCount = rest.data.length;
+
+  const handleProgressChange = useCallback(
+    (offsetProgress: number, absoluteProgress: number) => {
+      internalProgress.value = absoluteProgress;
+      if (typeof onProgressChange === 'function') {
+        onProgressChange(offsetProgress, absoluteProgress);
+      }
+    },
+    [onProgressChange, internalProgress],
+  );
+
+  const consumerProgress = isSharedValueProgress(onProgressChange) ? onProgressChange : undefined;
+  const contextValue: CarouselContextValue = {
+    progress: consumerProgress ?? internalProgress,
+    carouselRef: internalRef,
+    loop,
+    itemCount,
+    vertical,
+  };
+
+  return (
+    <CarouselProgressProvider value={contextValue}>
+      <RNCarousel
+        ref={mergeRefs(ref, internalRef)}
+        style={[resolvedClassNameStyle, style]}
+        onProgressChange={consumerProgress ?? handleProgressChange}
+        loop={loop}
+        defaultIndex={defaultIndex}
+        {...rest}
+      />
+      {children}
+    </CarouselProgressProvider>
+  );
+}
+
+const CarouselRoot = forwardRef(CarouselInner) as <T>(
+  props: CarouselProps<T> & { ref?: Ref<ICarouselInstance> },
+) => ReactElement | null;
+
+// =============================================================================
+// PAGINATION
+// =============================================================================
+
+export interface CarouselPaginationItemAccessibilityOverrides {
+  accessibilityLabel?: string;
+  accessibilityHint?: string;
+  accessibilityRole?: AccessibilityRole;
+  accessibilityState?: AccessibilityState;
+}
+
+export interface CarouselPaginationProps<T = unknown> {
+  /** Carousel items — must be the same array (or same length) passed to `Carousel`'s `data`. */
+  data: T[];
+  /** Lay dots out vertically instead of horizontally. @default true (horizontal) */
+  horizontal?: boolean;
+  /** Custom content per dot; defaults to the library's built-in dot rendering. */
+  renderItem?: (item: T, index: number) => ReactNode;
+  /** Dot size in pixels (both width and height). */
+  size?: number;
+  /** Included in the default accessibility label, e.g. `"Slide 1 of 4 - {carouselName}"`. */
+  carouselName?: string;
+  /** Per-dot accessibility overrides. Defaults to `"Slide N of M"` / `"Go to Slide N of M"`. */
+  paginationItemAccessibility?: (
+    index: number,
+    length: number,
+  ) => CarouselPaginationItemAccessibilityOverrides;
+  className?: string;
+  /** Explicit progress value — only required when rendered outside `<Carousel>` (sibling composition). */
+  progress?: SharedValue<number>;
+  /** Explicit carousel ref for the default press-to-navigate behavior — only required outside `<Carousel>`. */
+  carouselRef?: RefObject<ICarouselInstance | null>;
+  /**
+   * Mirrors `Carousel`'s `loop` prop for shortest-path dot navigation.
+   * Defaults to `true` (same as `Carousel`) when omitted outside context.
+   */
+  loop?: boolean;
+  /** Overrides the default press-to-navigate behavior (`scrollTo({ index })`). */
+  onPress?: (index: number) => void;
+}
+
+function CarouselPaginationComponent<T extends object>({
+  className,
+  progress: progressProp,
+  carouselRef: carouselRefProp,
+  loop: loopProp,
+  onPress,
+  ...rest
+}: CarouselPaginationProps<T>) {
+  // `strict: false` with no `defaultValue` means this returns `undefined` outside a
+  // `<Carousel>` provider at runtime; cast to communicate that to TypeScript, since
+  // `createContext`'s helper type always reports `T` (see `@cdx-ui/utils`).
+  const context = useCarouselProgressContext() as CarouselContextValue | undefined;
+  const progress = progressProp ?? context?.progress;
+  const carouselRef = carouselRefProp ?? context?.carouselRef;
+  const loop = loopProp ?? context?.loop ?? true;
+
+  if (!progress) {
+    throw new Error(
+      'Carousel.Pagination must be rendered inside <Carousel> or receive an explicit `progress` prop.',
+    );
+  }
+
+  if (!onPress && !carouselRef) {
+    throw new Error(
+      'Carousel.Pagination must be rendered inside <Carousel> or receive an explicit `carouselRef` prop (or a custom `onPress`).',
+    );
+  }
+
+  const handlePress = useCallback(
+    (index: number) => {
+      if (onPress) {
+        onPress(index);
+        return;
+      }
+
+      const carousel = carouselRef?.current;
+      if (!carousel) return;
+
+      const scrollAction = resolveCarouselPaginationScrollAction(
+        carousel.getCurrentIndex(),
+        index,
+        rest.data.length,
+        loop,
+      );
+
+      if (scrollAction) {
+        carousel.scrollTo(scrollAction);
+      }
+    },
+    [onPress, carouselRef, loop, rest.data.length],
+  );
+
+  const containerStyle = useResolveClassNames(cn(carouselPaginationContainerClassName, className));
+  const dotStyle = useResolveClassNames(carouselPaginationDotVariants({ active: false }));
+  const activeDotStyle = useResolveClassNames(carouselPaginationDotVariants({ active: true }));
+
+  return (
+    <RNCarouselPagination.Custom
+      {...rest}
+      progress={progress}
+      onPress={handlePress}
+      containerStyle={containerStyle}
+      dotStyle={{
+        width: 6,
+        height: 6,
+        ...(dotStyle as CarouselDotStyle),
+      }}
+      activeDotStyle={{
+        width: 18,
+        height: 6,
+        ...(activeDotStyle as CarouselDotStyle),
+      }}
+    />
+  );
+}
+
+CarouselPaginationComponent.displayName = 'Carousel.Pagination';
+
+const CarouselPagination = CarouselPaginationComponent as <T>(
+  props: CarouselPaginationProps<T>,
+) => ReactElement | null;
+
+type CarouselCompoundComponent = typeof CarouselRoot & {
+  Pagination: typeof CarouselPagination;
+  PrevButton: typeof CarouselPrevButton;
+  NextButton: typeof CarouselNextButton;
+};
+
+export const Carousel = Object.assign(CarouselRoot, {
+  Pagination: CarouselPagination,
+  PrevButton: CarouselPrevButton,
+  NextButton: CarouselNextButton,
+}) as CarouselCompoundComponent;
+
+// =============================================================================
+// HOOK
+// =============================================================================
+
+export interface UseCarouselOptions {
+  /** Seed `progress` to match `Carousel`'s `defaultIndex` in sibling composition. @default 0 */
+  defaultIndex?: number;
+}
+
+export function useCarousel(options?: UseCarouselOptions) {
+  const ref = useRef<ICarouselInstance>(null);
+  const progress = useSharedValue(options?.defaultIndex ?? 0);
+  return {
+    ref,
+    /** Bind to `Carousel`'s `onProgressChange` and sibling `Carousel.Pagination`'s `progress`. */
+    progress,
+    next: (opts?: Parameters<ICarouselInstance['next']>[0]) => ref.current?.next(opts),
+    prev: (opts?: Parameters<ICarouselInstance['prev']>[0]) => ref.current?.prev(opts),
+    scrollTo: (opts?: Parameters<ICarouselInstance['scrollTo']>[0]) => ref.current?.scrollTo(opts),
+  };
+}

package/src/components/Carousel/navButton.tsx

@@ -0,0 +1,160 @@
+import { useCallback } from 'react';
+import type { RefObject } from 'react';
+import type { SharedValue } from 'react-native-reanimated';
+import type { ICarouselInstance } from 'react-native-reanimated-carousel';
+import {
+  ChevronLeft,
+  ChevronRight,
+  KeyboardArrowDown,
+  KeyboardArrowUp,
+  type ForgeIcon,
+} from '@cdx-ui/icons';
+import { dataAttributes, mergeDataAttributes } from '@cdx-ui/primitives';
+import { cn } from '@cdx-ui/utils';
+import { IconButton, type IconButtonProps } from '../IconButton';
+import { useCarouselProgressContext } from './context';
+import { carouselNavButtonIconVariants, carouselNavButtonRootVariants } from './styles';
+import { useCarouselActiveIndex } from './useCarouselActiveIndex';
+
+export interface CarouselNavButtonProps extends Omit<
+  IconButtonProps,
+  'as' | 'variant' | 'onPress' | 'disabled' | 'isDisabled'
+> {
+  /** Mirrors `Carousel`'s `data.length` — only required when rendered outside `<Carousel>`. */
+  itemCount?: number;
+  /** Explicit progress value — only required when rendered outside `<Carousel>`. */
+  progress?: SharedValue<number>;
+  /** Explicit carousel ref — only required outside `<Carousel>` (unless `onPress` is provided). */
+  carouselRef?: RefObject<ICarouselInstance | null>;
+  /**
+   * Mirrors `Carousel`'s `loop` prop for bounds-aware disabled state.
+   * Defaults to `true` (same as `Carousel`) when omitted outside context.
+   */
+  loop?: boolean;
+  /**
+   * Mirrors `Carousel`'s `vertical` prop for default icons and accessibility labels.
+   * Defaults to `false` when omitted outside context.
+   */
+  vertical?: boolean;
+  /** Overrides the default press-to-navigate behavior (`prev` / `next` with `{ animated: true }`). */
+  onPress?: () => void;
+  /** Manual override; when omitted, derived from `loop` and `progress` at bounds. */
+  disabled?: boolean;
+  /** Forge icon component — defaults to direction-appropriate chevrons or arrows. */
+  as?: ForgeIcon;
+  /** Overrides default `"Previous slide"` / `"Next slide"` (or item labels when `vertical`). */
+  accessibilityLabel?: string;
+}
+
+interface CarouselNavButtonInternalProps extends CarouselNavButtonProps {
+  direction: 'prev' | 'next';
+}
+
+function resolveDefaultIcon(vertical: boolean, direction: 'prev' | 'next'): ForgeIcon {
+  if (vertical) {
+    return direction === 'prev' ? KeyboardArrowUp : KeyboardArrowDown;
+  }
+  return direction === 'prev' ? ChevronLeft : ChevronRight;
+}
+
+function resolveDefaultAccessibilityLabel(vertical: boolean, direction: 'prev' | 'next'): string {
+  if (vertical) {
+    return direction === 'prev' ? 'Previous item' : 'Next item';
+  }
+  return direction === 'prev' ? 'Previous slide' : 'Next slide';
+}
+
+function CarouselNavButton({
+  direction,
+  progress: progressProp,
+  carouselRef: carouselRefProp,
+  itemCount: itemCountProp,
+  loop: loopProp,
+  vertical: verticalProp,
+  onPress,
+  disabled: disabledProp,
+  as,
+  accessibilityLabel,
+  color = 'neutral',
+  size = 'default',
+  className,
+  iconClassName,
+  ...iconButtonProps
+}: CarouselNavButtonInternalProps) {
+  const context = useCarouselProgressContext();
+  const progress = progressProp ?? context?.progress;
+  const carouselRef = carouselRefProp ?? context?.carouselRef;
+  const itemCount = itemCountProp ?? context?.itemCount;
+  const loop = loopProp ?? context?.loop ?? true;
+  const vertical = verticalProp ?? context?.vertical ?? false;
+
+  if (!progress) {
+    throw new Error(
+      `Carousel.${direction === 'prev' ? 'PrevButton' : 'NextButton'} must be rendered inside <Carousel> or receive an explicit \`progress\` prop.`,
+    );
+  }
+
+  if (!onPress && !carouselRef) {
+    throw new Error(
+      `Carousel.${direction === 'prev' ? 'PrevButton' : 'NextButton'} must be rendered inside <Carousel> or receive an explicit \`carouselRef\` prop (or a custom \`onPress\`).`,
+    );
+  }
+
+  if (itemCount == null) {
+    throw new Error(
+      `Carousel.${direction === 'prev' ? 'PrevButton' : 'NextButton'} must be rendered inside <Carousel> or receive an explicit \`itemCount\` prop.`,
+    );
+  }
+
+  const activeIndex = useCarouselActiveIndex(progress);
+  const atStart = activeIndex <= 0;
+  const atEnd = activeIndex >= itemCount - 1;
+  const autoDisabled = !loop && (direction === 'prev' ? atStart : atEnd);
+  const disabled = disabledProp ?? autoDisabled;
+
+  const handlePress = useCallback(() => {
+    if (onPress) {
+      onPress();
+      return;
+    }
+
+    if (direction === 'prev') {
+      carouselRef?.current?.prev({ animated: true });
+    } else {
+      carouselRef?.current?.next({ animated: true });
+    }
+  }, [onPress, carouselRef, direction]);
+
+  const dataSlot = direction === 'prev' ? 'carousel-prev-button' : 'carousel-next-button';
+
+  return (
+    <IconButton
+      as={as ?? resolveDefaultIcon(vertical, direction)}
+      variant="ghost"
+      color={color}
+      size={size}
+      isDisabled={disabled}
+      onPress={handlePress}
+      accessibilityLabel={
+        accessibilityLabel ?? resolveDefaultAccessibilityLabel(vertical, direction)
+      }
+      accessibilityState={{ disabled }}
+      className={cn(carouselNavButtonRootVariants({ disabled }), className)}
+      iconClassName={cn(carouselNavButtonIconVariants({ disabled }), iconClassName)}
+      {...iconButtonProps}
+      {...mergeDataAttributes(iconButtonProps, dataAttributes({ slot: dataSlot }))}
+    />
+  );
+}
+
+export function CarouselPrevButton(props: CarouselNavButtonProps) {
+  return <CarouselNavButton direction="prev" {...props} />;
+}
+
+CarouselPrevButton.displayName = 'Carousel.PrevButton';
+
+export function CarouselNextButton(props: CarouselNavButtonProps) {
+  return <CarouselNavButton direction="next" {...props} />;
+}
+
+CarouselNextButton.displayName = 'Carousel.NextButton';

package/src/components/Carousel/paginationNavigation.ts

@@ -0,0 +1,32 @@
+import type { ICarouselInstance } from 'react-native-reanimated-carousel';
+
+type CarouselPaginationScrollAction = NonNullable<Parameters<ICarouselInstance['scrollTo']>[0]>;
+
+/**
+ * Resolves the shortest `scrollTo` action for pagination dot presses.
+ *
+ * In loop mode the library's absolute `scrollTo({ index })` can animate through every
+ * slide when the current index is past the halfway point of the loop buffer (e.g. index 2 → 3
+ * with four items). Relative `count` navigation avoids that wrap-around path.
+ */
+export function resolveCarouselPaginationScrollAction(
+  currentIndex: number,
+  targetIndex: number,
+  dataLength: number,
+  loop: boolean,
+): CarouselPaginationScrollAction | null {
+  if (currentIndex === targetIndex) return null;
+
+  if (!loop) {
+    return { index: targetIndex, animated: true };
+  }
+
+  const forwardDelta = (targetIndex - currentIndex + dataLength) % dataLength;
+  const backwardDelta = (currentIndex - targetIndex + dataLength) % dataLength;
+
+  if (forwardDelta <= backwardDelta) {
+    return { count: forwardDelta, animated: true };
+  }
+
+  return { count: -backwardDelta, animated: true };
+}

package/src/components/Carousel/styles.ts

@@ -0,0 +1,45 @@
+import { cva, type VariantProps } from '@cdx-ui/utils';
+
+/** Small default gap between dots — the library ships no default spacing between pagination items. */
+export const carouselPaginationContainerClassName = 'gap-2 py-1';
+
+export const carouselPaginationDotVariants = cva('rounded-full', {
+  variants: {
+    active: {
+      true: 'bg-surface-neutral-strong',
+      false: 'bg-surface-neutral-subtle',
+    },
+  },
+  defaultVariants: {
+    active: false,
+  },
+});
+
+export type CarouselPaginationDotVariants = VariantProps<typeof carouselPaginationDotVariants>;
+
+/** Overrides IconButton's default disabled opacity so tertiary icon color reads clearly at bounds. */
+export const carouselNavButtonRootVariants = cva([], {
+  variants: {
+    disabled: {
+      true: 'data-[disabled=true]:opacity-100',
+      false: '',
+    },
+  },
+  defaultVariants: {
+    disabled: false,
+  },
+});
+
+export const carouselNavButtonIconVariants = cva([], {
+  variants: {
+    disabled: {
+      true: 'text-content-tertiary',
+      false: '',
+    },
+  },
+  defaultVariants: {
+    disabled: false,
+  },
+});
+
+export type CarouselNavButtonVariants = VariantProps<typeof carouselNavButtonRootVariants>;

package/src/components/Carousel/useCarouselActiveIndex.ts

@@ -0,0 +1,54 @@
+import { useEffect, useRef, useState } from 'react';
+import { useAnimatedReaction, type SharedValue } from 'react-native-reanimated';
+import { scheduleOnRN } from 'react-native-worklets';
+
+let nextListenerId = 1;
+
+/**
+ * Syncs `Math.round(progress)` into React state for bounds-aware disabled state.
+ * Do not call `getCurrentIndex()` during render — the adopted library warns against it.
+ *
+ * Uses both:
+ * - `useAnimatedReaction` + `scheduleOnRN` (native / Babel-transformed web worklets)
+ * - SharedValue `addListener` (JS-thread fallback for web hosts that serve bob-built
+ *   `lib/` without the Reanimated Babel plugin — e.g. the docs Vite SPA)
+ */
+export function useCarouselActiveIndex(progress: SharedValue<number>): number {
+  const [activeIndex, setActiveIndex] = useState(() => Math.round(progress.get()));
+  const setActiveIndexRef = useRef(setActiveIndex);
+  setActiveIndexRef.current = setActiveIndex;
+
+  useAnimatedReaction(
+    () => Math.round(progress.get()),
+    (current, previous) => {
+      if (current !== previous) {
+        scheduleOnRN(setActiveIndexRef.current, current);
+      }
+    },
+  );
+
+  useEffect(() => {
+    const listenerId = nextListenerId++;
+    const onChange = (value: number) => {
+      const next = Math.round(value);
+      setActiveIndexRef.current((prev) => (prev === next ? prev : next));
+    };
+
+    try {
+      progress.addListener(listenerId, onChange);
+    } catch {
+      // Native JS runtime rejects addListener — the worklet path above handles it.
+      return;
+    }
+
+    return () => {
+      try {
+        progress.removeListener(listenerId);
+      } catch {
+        // ignore
+      }
+    };
+  }, [progress]);
+
+  return activeIndex;
+}