@primitiv-ui/react 0.1.0 → 0.1.2

package/src/Modal/ModalContext.ts

@@ -1,13 +1,20 @@
-import { createStrictContext } from "../utils";
+import type { Context, Provider } from "react";
+import { createStrictContext } from "../utils/index.ts";
 
 import { ModalContextValue } from "./types";
 
-export const [ModalContext, useModalContext] =
-  createStrictContext<ModalContextValue>(
-    "Component must be rendered as a child of Modal.Root",
-    "ModalContext",
-  );
+const modalContextPair = createStrictContext<ModalContextValue>(
+  "Component must be rendered as a child of Modal.Root",
+  "ModalContext",
+);
 
-const ModalProvider = ModalContext.Provider;
+/** React context carrying the shared {@link ModalContextValue} for a modal. */
+export const ModalContext: Context<ModalContextValue | null> =
+  modalContextPair[0];
+/** Hook returning the nearest {@link ModalContextValue}; throws outside `Modal.Root`. */
+export const useModalContext: () => ModalContextValue = modalContextPair[1];
+
+/** Context provider for {@link ModalContext}, rendered internally by `Modal.Root`. */
+const ModalProvider: Provider<ModalContextValue | null> = ModalContext.Provider;
 
 export { ModalProvider };

package/src/Modal/hooks/useModalRoot.ts

@@ -8,7 +8,7 @@ import {
   useState,
 } from "react";
 
-import { useControllableState } from "../../hooks";
+import { useControllableState } from "../../hooks/index.ts";
 
 import {
   ModalContentCallbacks,

package/src/Modal/hooks/useModalTrigger.ts

@@ -1,6 +1,6 @@
 import { MouseEventHandler } from "react";
-import { useModalContext } from ".";
-import { composeEventHandlers } from "../../Slot";
+import { useModalContext } from "./index.ts";
+import { composeEventHandlers } from "../../Slot/index.ts";
 import type { ModalTriggerProps } from "../types";
 
 export function useModalTrigger(

package/src/Modal/types.ts

@@ -6,71 +6,120 @@ import {
   RefObject,
 } from "react";
 
+/**
+ * Imperative handle exposed on `Modal.Root`'s `ref`, letting callers open
+ * and close the modal programmatically.
+ */
 export type ModalImperativeApi = {
+  /** Opens the modal. */
   open: () => void;
+  /** Closes the modal. */
   close: () => void;
 };
 
+/**
+ * Optional escape-hatch callbacks accepted by `Modal.Content` for
+ * intercepting dismissal gestures.
+ */
 export type ModalContentCallbacks = {
+  /** Fires when the user presses Escape; call `preventDefault` to keep the modal open. */
   onEscapeKeyDown?: (event: Event) => void;
+  /** Fires on a pointer-down outside the content; call `preventDefault` to keep the modal open. */
   onPointerDownOutside?: (event: PointerEvent) => void;
 };
 
+/**
+ * Shared context value published by `Modal.Root` and consumed by every
+ * sub-component to coordinate open state, ids, and ARIA wiring.
+ */
 export type ModalContextValue = {
+  /** Whether the modal is currently open. */
   open: boolean;
+  /** Sets the open state. */
   setOpen: (open: boolean) => void;
+  /** Generated id of the dialog content element. */
   contentId: string;
+  /** Mutable ref holding the current content callbacks. */
   contentCallbacksRef: RefObject<ModalContentCallbacks>;
+  /** Id of the registered title, or `undefined` when none is rendered. */
   titleId: string | undefined;
+  /** Id of the registered description, or `undefined` when none is rendered. */
   descriptionId: string | undefined;
+  /** Registers (or clears) the title id for `aria-labelledby`. */
   registerTitle: (id: string | undefined) => void;
+  /** Registers (or clears) the description id for `aria-describedby`. */
   registerDescription: (id: string | undefined) => void;
 };
 
+/** Props for `Modal.Content` — native `<dialog>` props plus dismissal callbacks. */
 export type ModalContentProps = ComponentProps<"dialog"> &
   ModalContentCallbacks;
 
-type UncontrolledModalRootProps = {
+/** `Modal.Root` props for the uncontrolled (self-managed) open state. */
+export type UncontrolledModalRootProps = {
+  /** Initial open state when uncontrolled. */
   defaultOpen?: boolean;
   open?: never;
+  /** Called whenever the open state changes. */
   onOpenChange?: (open: boolean) => void;
 };
 
-type ControlledModalRootProps = {
+/** `Modal.Root` props for the controlled open state. */
+export type ControlledModalRootProps = {
+  /** Controlled open state. */
   open: boolean;
+  /** Called whenever the modal requests an open-state change. */
   onOpenChange: (open: boolean) => void;
   defaultOpen?: never;
 };
 
+/** Props for `Modal.Root`, in either the controlled or uncontrolled mode. */
 export type ModalRootProps = {
+  /** Modal sub-components. */
   children?: ReactNode;
 } & (UncontrolledModalRootProps | ControlledModalRootProps) & {
+    /** Ref receiving the imperative open/close handle. */
     ref?: Ref<ModalImperativeApi>;
   };
 
+/** Props for `Modal.Trigger` — a `<button>` that opens the modal. */
 export type ModalTriggerProps = ComponentProps<"button"> & {
+  /** Render into the consumer's own element instead of a `<button>`. */
   asChild?: boolean;
 };
 
+/** Props for `Modal.Close` — a `<button>` that closes the modal. */
 export type ModalCloseProps = ComponentProps<"button"> & {
+  /** Render into the consumer's own element instead of a `<button>`. */
   asChild?: boolean;
 };
 
+/** Props for `Modal.Portal` — renders its children into `container`. */
 export type ModalPortalProps = {
+  /** Content to portal. */
   children?: ReactNode;
+  /** Target element to portal into. Defaults to `document.body`. */
   container?: HTMLElement;
+  /** Keep the portal mounted even while the modal is closed. */
   forceMount?: boolean;
 };
 
+/** Props for `Modal.Overlay` — the click-outside backdrop. */
 export type ModalOverlayProps = ComponentProps<"div"> & {
+  /** Render into the consumer's own element instead of a `<div>`. */
   asChild?: boolean;
+  /** Keep the overlay mounted even while the modal is closed. */
   forceMount?: boolean;
 };
 
+/** Props for `Modal.Title` — supplies the dialog's accessible name. */
 export type ModalTitleProps = HTMLAttributes<HTMLElement> & {
+  /** Render into the consumer's own element instead of an `<h2>`. */
   asChild?: boolean;
 };
 
+/** Props for `Modal.Description` — supplies the dialog's accessible description. */
 export type ModalDescriptionProps = HTMLAttributes<HTMLElement> & {
+  /** Render into the consumer's own element instead of a `<p>`. */
   asChild?: boolean;
 };

package/src/Portal/Portal.tsx

@@ -1,3 +1,4 @@
+import type { ReactPortal } from "react";
 import { createPortal } from "react-dom";
 
 import type { PortalProps } from "./types";
@@ -19,10 +20,11 @@ import type { PortalProps } from "./types";
  *   <div role="dialog">…</div>
  * </Portal>
  */
-function Portal({ children, container }: PortalProps) {
+function Portal({ children, container }: PortalProps): ReactPortal {
   return createPortal(children, container ?? document.body);
 }
 
+/** @internal */
 Portal.displayName = "Portal";
 
 export { Portal };

package/src/Portal/types.ts

@@ -1,5 +1,9 @@
 import { ReactNode } from "react";
 
+/**
+ * Props for {@link Portal} — the `children` to teleport and an optional
+ * `container` to render into (defaults to `document.body`).
+ */
 export type PortalProps = {
   children?: ReactNode;
   container?: HTMLElement;

package/src/Progress/Progress.tsx

@@ -1,9 +1,10 @@
 import { useMemo } from "react";
+import type { ReactElement } from "react";
 
-import { Slot } from "../Slot";
+import { Slot } from "../Slot/index.ts";
 
 import { ProgressContext } from "./ProgressContext";
-import { useProgressContext, useProgressRoot } from "./hooks";
+import { useProgressContext, useProgressRoot } from "./hooks/index.ts";
 import { ProgressIndicatorProps, ProgressRootProps } from "./types";
 
 function defaultGetValueLabel(value: number, max: number): string {
@@ -46,14 +47,14 @@ function defaultGetValueLabel(value: number, max: number): string {
  * </Progress.Root>
  * ```
  */
-function ProgressRoot({
+export function ProgressRoot({
   value,
   max,
   getValueLabel = defaultGetValueLabel,
   asChild = false,
   children,
   ...rest
-}: ProgressRootProps) {
+}: ProgressRootProps): ReactElement {
   const resolved = useProgressRoot({ value, max });
   const { state } = resolved;
 
@@ -92,6 +93,7 @@ function ProgressRoot({
   );
 }
 
+/** @internal */
 ProgressRoot.displayName = "ProgressRoot";
 
 /**
@@ -116,11 +118,11 @@ ProgressRoot.displayName = "ProgressRoot";
  *
  * @throws if rendered outside a `Progress.Root`.
  */
-function ProgressIndicator({
+export function ProgressIndicator({
   asChild = false,
   children,
   ...rest
-}: ProgressIndicatorProps) {
+}: ProgressIndicatorProps): ReactElement {
   const { value, max, state } = useProgressContext();
   const indicatorProps = {
     ...rest,
@@ -134,9 +136,11 @@ function ProgressIndicator({
   return <div {...indicatorProps}>{children}</div>;
 }
 
+/** @internal */
 ProgressIndicator.displayName = "ProgressIndicator";
 
-type TProgressCompound = typeof ProgressRoot & {
+/** Type of the {@link Progress} compound: the root callable plus its attached sub-components. */
+export type TProgressCompound = typeof ProgressRoot & {
   Root: typeof ProgressRoot;
   Indicator: typeof ProgressIndicator;
 };
@@ -173,6 +177,7 @@ const ProgressCompound: TProgressCompound = Object.assign(ProgressRoot, {
   Indicator: ProgressIndicator,
 });
 
+/** @internal */
 ProgressCompound.displayName = "Progress";
 
 export { ProgressCompound as Progress };

package/src/Progress/ProgressContext.ts

@@ -1,15 +1,27 @@
-import { createStrictContext } from "../utils";
+import type { Context } from "react";
+import { createStrictContext } from "../utils/index.ts";
 
 import { ProgressState } from "./types";
 
+/**
+ * Context value published by {@link Progress.Root} and consumed by
+ * {@link Progress.Indicator} — the current `value` (or `null` while
+ * indeterminate), the `max`, and the derived loading `state`.
+ */
 export type ProgressContextValue = {
   value: number | null;
   max: number;
   state: ProgressState;
 };
 
-export const [ProgressContext, useProgressContext] =
-  createStrictContext<ProgressContextValue>(
-    "Progress.Indicator must be rendered inside a <Progress.Root>.",
-    "ProgressContext",
-  );
+const progressContextPair = createStrictContext<ProgressContextValue>(
+  "Progress.Indicator must be rendered inside a <Progress.Root>.",
+  "ProgressContext",
+);
+
+/** React context carrying the {@link ProgressContextValue}; `null` when no provider is present. */
+export const ProgressContext: Context<ProgressContextValue | null> =
+  progressContextPair[0];
+/** Reads the {@link ProgressContextValue}; throws if used outside a {@link Progress.Root}. */
+export const useProgressContext: () => ProgressContextValue =
+  progressContextPair[1];

package/src/RadioCard/RadioCard.tsx

@@ -1,8 +1,9 @@
 import { useEffect, useMemo, useRef } from "react";
+import type { ReactElement } from "react";
 
-import { useDirection } from "../DirectionProvider";
-import { useRovingTabindex } from "../hooks";
-import { Slot, composeEventHandlers, composeRefs } from "../Slot";
+import { useDirection } from "../DirectionProvider/index.ts";
+import { useRovingTabindex } from "../hooks/index.ts";
+import { Slot, composeEventHandlers, composeRefs } from "../Slot/index.ts";
 
 import { RadioCardContext } from "./RadioCardContext";
 import { RadioCardItemContext } from "./RadioCardItemContext";
@@ -10,7 +11,7 @@ import {
   useRadioCardContext,
   useRadioCardItemContext,
   useRadioCardRoot,
-} from "./hooks";
+} from "./hooks/index.ts";
 import {
   RadioCardIndicatorProps,
   RadioCardItemProps,
@@ -72,7 +73,7 @@ import {
  * </RadioCard.Root>
  * ```
  */
-function RadioCardRoot({
+export function RadioCardRoot({
   defaultValue,
   value: controlledValue,
   onValueChange,
@@ -81,7 +82,7 @@ function RadioCardRoot({
   asChild = false,
   children,
   ...rest
-}: RadioCardRootProps) {
+}: RadioCardRootProps): ReactElement {
   const resolvedDir = dir ?? useDirection();
   const { value, select, registerItem, itemValues, disabledValues, focusItem } =
     useRadioCardRoot({
@@ -128,6 +129,7 @@ function RadioCardRoot({
   );
 }
 
+/** @internal */
 RadioCardRoot.displayName = "RadioCardRoot";
 
 /**
@@ -157,7 +159,7 @@ RadioCardRoot.displayName = "RadioCardRoot";
  *
  * @throws if rendered outside a `RadioCard.Root`.
  */
-function RadioCardItem({
+export function RadioCardItem({
   value,
   children,
   onClick,
@@ -166,7 +168,7 @@ function RadioCardItem({
   asChild = false,
   ref,
   ...rest
-}: RadioCardItemProps) {
+}: RadioCardItemProps): ReactElement {
   const {
     value: selectedValue,
     select,
@@ -231,6 +233,7 @@ function RadioCardItem({
   );
 }
 
+/** @internal */
 RadioCardItem.displayName = "RadioCardItem";
 
 /**
@@ -259,12 +262,12 @@ RadioCardItem.displayName = "RadioCardItem";
  *
  * @throws if rendered outside a `RadioCard.Item`.
  */
-function RadioCardIndicator({
+export function RadioCardIndicator({
   children,
   forceMount,
   asChild = false,
   ...rest
-}: RadioCardIndicatorProps) {
+}: RadioCardIndicatorProps): ReactElement | null {
   const { checked } = useRadioCardItemContext();
   if (!checked && !forceMount) return null;
   const indicatorProps = {
@@ -278,9 +281,12 @@ function RadioCardIndicator({
   return <span {...indicatorProps}>{children}</span>;
 }
 
+/** @internal */
 RadioCardIndicator.displayName = "RadioCardIndicator";
 
-type TRadioCardCompound = typeof RadioCardRoot & {
+/** Type of the {@link RadioCard} compound: the callable `RadioCard.Root`
+ * component augmented with its sub-components as static properties. */
+export type TRadioCardCompound = typeof RadioCardRoot & {
   Root: typeof RadioCardRoot;
   Item: typeof RadioCardItem;
   Indicator: typeof RadioCardIndicator;

package/src/RadioCard/RadioCardContext.ts

@@ -1,7 +1,11 @@
-import { createStrictContext } from "../utils";
+import type { Context } from "react";
+import { createStrictContext } from "../utils/index.ts";
 
 import { RadioCardOrientation, RadioCardReadingDirection } from "./types";
 
+/** The value shared by `RadioCard.Root` with its items through context: the
+ * current selection and setter, the item registry used for roving focus and
+ * keyboard navigation, and the resolved orientation/direction. */
 export type RadioCardContextValue = {
   value: string | undefined;
   select: (value: string) => void;
@@ -17,7 +21,15 @@ export type RadioCardContextValue = {
   dir: RadioCardReadingDirection;
 };
 
-export const [RadioCardContext, useRadioCardContext] =
-  createStrictContext<RadioCardContextValue>(
-    "RadioCard sub-components must be rendered inside a <RadioCard.Root>.",
-  );
+const radioCardContextPair = createStrictContext<RadioCardContextValue>(
+  "RadioCard sub-components must be rendered inside a <RadioCard.Root>.",
+);
+
+/** Strict React context carrying the {@link RadioCardContextValue} from
+ * `RadioCard.Root` to its items. `null` when read outside a `RadioCard.Root`. */
+export const RadioCardContext: Context<RadioCardContextValue | null> =
+  radioCardContextPair[0];
+/** Reads the {@link RadioCardContextValue}; throws when used outside a
+ * `RadioCard.Root`. */
+export const useRadioCardContext: () => RadioCardContextValue =
+  radioCardContextPair[1];

package/src/RadioCard/RadioCardItemContext.ts

@@ -1,10 +1,23 @@
-import { createStrictContext } from "../utils";
+import type { Context } from "react";
+import { createStrictContext } from "../utils/index.ts";
 
+/** The value shared by `RadioCard.Item` with its `RadioCard.Indicator`,
+ * exposing whether the item is currently selected. */
 export type RadioCardItemContextValue = {
+  /** Whether the enclosing item is the selected card. */
   checked: boolean;
 };
 
-export const [RadioCardItemContext, useRadioCardItemContext] =
-  createStrictContext<RadioCardItemContextValue>(
-    "RadioCard.Indicator must be rendered inside a <RadioCard.Item>.",
-  );
+const radioCardItemContextPair = createStrictContext<RadioCardItemContextValue>(
+  "RadioCard.Indicator must be rendered inside a <RadioCard.Item>.",
+);
+
+/** Strict React context carrying the {@link RadioCardItemContextValue} from
+ * `RadioCard.Item` to its indicator. `null` when read outside a
+ * `RadioCard.Item`. */
+export const RadioCardItemContext: Context<RadioCardItemContextValue | null> =
+  radioCardItemContextPair[0];
+/** Reads the {@link RadioCardItemContextValue}; throws when used outside a
+ * `RadioCard.Item`. */
+export const useRadioCardItemContext: () => RadioCardItemContextValue =
+  radioCardItemContextPair[1];

package/src/RadioCard/__tests__/RadioCard.reading-direction.test.tsx

@@ -1,7 +1,7 @@
 import { render, screen } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 
-import { DirectionProvider } from "../../DirectionProvider";
+import { DirectionProvider } from "../../DirectionProvider/index.ts";
 import { RadioCard } from "../RadioCard";
 
 describe("RadioCard reading direction", () => {

package/src/RadioCard/hooks/useRadioCardRoot.ts

@@ -1,6 +1,6 @@
 import { useCallback, useMemo } from "react";
 
-import { useCollection, useControllableState } from "../../hooks";
+import { useCollection, useControllableState } from "../../hooks/index.ts";
 
 type UseRadioCardRootArgs = {
   defaultValue?: string;

package/src/RadioCard/types.ts

@@ -10,30 +10,48 @@ export type RadioCardOrientation = "horizontal" | "vertical" | "both";
 /** Reading direction — swaps the horizontal arrow pair when `"rtl"`. */
 export type RadioCardReadingDirection = "ltr" | "rtl";
 
-type RadioCardRootBaseProps = Omit<ComponentProps<"div">, "role"> & {
+/** Props shared by both controlled and uncontrolled `RadioCard.Root` usage.
+ * Extends the native `<div>` props (minus `role`). */
+export type RadioCardRootBaseProps = Omit<ComponentProps<"div">, "role"> & {
   children?: ReactNode;
+  /** Ref to the rendered root element. */
   ref?: Ref<HTMLDivElement>;
+  /** Render the child element instead of the default `<div>`. */
   asChild?: boolean;
+  /** Which arrow keys navigate the group. */
   orientation?: RadioCardOrientation;
+  /** Reading direction for horizontal arrow navigation. */
   dir?: RadioCardReadingDirection;
 };
 
-type RadioCardRootUncontrolledProps = RadioCardRootBaseProps & {
+/** Uncontrolled `RadioCard.Root` props: the component owns the selection,
+ * seeded by an optional `defaultValue`. */
+export type RadioCardRootUncontrolledProps = RadioCardRootBaseProps & {
+  /** Value selected on first render. */
   defaultValue?: string;
   value?: never;
+  /** Called with the value when the selection changes. */
   onValueChange?: (value: string) => void;
 };
 
-type RadioCardRootControlledProps = RadioCardRootBaseProps & {
+/** Controlled `RadioCard.Root` props: the caller owns the selection via
+ * `value` and is notified through the required `onValueChange`. */
+export type RadioCardRootControlledProps = RadioCardRootBaseProps & {
   defaultValue?: never;
+  /** Value of the currently selected card. */
   value: string;
+  /** Called with the value when the user selects a card. */
   onValueChange: (value: string) => void;
 };
 
+/** Props for `RadioCard.Root` — resolves to either the controlled or
+ * uncontrolled prop shape. */
 export type RadioCardRootProps =
   | RadioCardRootUncontrolledProps
   | RadioCardRootControlledProps;
 
+/** Props for `RadioCard.Item` — a selectable card rendered as a
+ * `role="radio"` button, identified by its required `value`. */
 export type RadioCardItemProps = Omit<
   ComponentProps<"button">,
   "type" | "role" | "aria-checked" | "value"
@@ -44,6 +62,9 @@ export type RadioCardItemProps = Omit<
   asChild?: boolean;
 };
 
+/** Props for `RadioCard.Indicator` — the visual marker rendered inside the
+ * selected item. By default it renders only when its item is checked; set
+ * `forceMount` to keep it mounted for exit transitions. */
 export type RadioCardIndicatorProps = ComponentProps<"span"> & {
   children?: ReactNode;
   forceMount?: boolean;

package/src/RadioGroup/RadioGroup.tsx

@@ -1,8 +1,9 @@
 import { useEffect, useMemo, useRef } from "react";
+import type { ReactElement } from "react";
 
-import { useDirection } from "../DirectionProvider";
-import { useRovingTabindex } from "../hooks";
-import { Slot, composeEventHandlers, composeRefs } from "../Slot";
+import { useDirection } from "../DirectionProvider/index.ts";
+import { useRovingTabindex } from "../hooks/index.ts";
+import { Slot, composeEventHandlers, composeRefs } from "../Slot/index.ts";
 
 import { RadioGroupContext } from "./RadioGroupContext";
 import { RadioGroupItemContext } from "./RadioGroupItemContext";
@@ -10,7 +11,7 @@ import {
   useRadioGroupContext,
   useRadioGroupItemContext,
   useRadioGroupRoot,
-} from "./hooks";
+} from "./hooks/index.ts";
 import {
   RadioGroupIndicatorProps,
   RadioGroupItemProps,
@@ -73,7 +74,7 @@ import {
  * </RadioGroup.Root>
  * ```
  */
-function RadioGroupRoot({
+export function RadioGroupRoot({
   defaultValue,
   value: controlledValue,
   onValueChange,
@@ -82,7 +83,7 @@ function RadioGroupRoot({
   asChild = false,
   children,
   ...rest
-}: RadioGroupRootProps) {
+}: RadioGroupRootProps): ReactElement {
   const resolvedDir = dir ?? useDirection();
   const { value, select, registerItem, itemValues, disabledValues, focusItem } =
     useRadioGroupRoot({
@@ -129,6 +130,7 @@ function RadioGroupRoot({
   );
 }
 
+/** @internal */
 RadioGroupRoot.displayName = "RadioGroupRoot";
 
 /**
@@ -163,7 +165,7 @@ RadioGroupRoot.displayName = "RadioGroupRoot";
  *
  * @throws if rendered outside a `RadioGroup.Root`.
  */
-function RadioGroupItem({
+export function RadioGroupItem({
   value,
   children,
   onClick,
@@ -172,7 +174,7 @@ function RadioGroupItem({
   asChild = false,
   ref,
   ...rest
-}: RadioGroupItemProps) {
+}: RadioGroupItemProps): ReactElement {
   const {
     value: selectedValue,
     select,
@@ -237,6 +239,7 @@ function RadioGroupItem({
   );
 }
 
+/** @internal */
 RadioGroupItem.displayName = "RadioGroupItem";
 
 /**
@@ -277,12 +280,12 @@ RadioGroupItem.displayName = "RadioGroupItem";
  *
  * @throws if rendered outside a `RadioGroup.Item`.
  */
-function RadioGroupIndicator({
+export function RadioGroupIndicator({
   children,
   forceMount,
   asChild = false,
   ...rest
-}: RadioGroupIndicatorProps) {
+}: RadioGroupIndicatorProps): ReactElement | null {
   const { checked } = useRadioGroupItemContext();
   if (!checked && !forceMount) return null;
   const indicatorProps = {
@@ -296,9 +299,11 @@ function RadioGroupIndicator({
   return <span {...indicatorProps}>{children}</span>;
 }
 
+/** @internal */
 RadioGroupIndicator.displayName = "RadioGroupIndicator";
 
-type TRadioGroupCompound = typeof RadioGroupRoot & {
+/** Type of the {@link RadioGroup} compound: the root callable plus its attached sub-components. */
+export type TRadioGroupCompound = typeof RadioGroupRoot & {
   Root: typeof RadioGroupRoot;
   Item: typeof RadioGroupItem;
   Indicator: typeof RadioGroupIndicator;
@@ -348,6 +353,7 @@ const RadioGroupCompound: TRadioGroupCompound = Object.assign(RadioGroupRoot, {
   Indicator: RadioGroupIndicator,
 });
 
+/** @internal */
 RadioGroupCompound.displayName = "RadioGroup";
 
 export { RadioGroupCompound as RadioGroup };

package/src/RadioGroup/RadioGroupContext.ts

@@ -1,4 +1,4 @@
-import { createStrictContext } from "../utils";
+import { createStrictContext } from "../utils/index.ts";
 
 import { RadioGroupOrientation, RadioGroupReadingDirection } from "./types";
 

package/src/RadioGroup/RadioGroupItemContext.ts

@@ -1,4 +1,4 @@
-import { createStrictContext } from "../utils";
+import { createStrictContext } from "../utils/index.ts";
 
 export type RadioGroupItemContextValue = {
   checked: boolean;