@expcat/tigercat-react 2.1.2 → 2.1.4

package/dist/chunk-LKTM4NU4.mjs

@@ -0,0 +1,315 @@
+import {
+  composeRefs
+} from "./chunk-WWZZRB7H.mjs";
+import {
+  Button
+} from "./chunk-WFLXJOFU.mjs";
+import {
+  StatusIcon
+} from "./chunk-ED7QR6PJ.mjs";
+import {
+  renderOverlayPortal,
+  useBodyScrollLock,
+  useEscapeKey,
+  useFocusTrap,
+  useOverlayPortalTarget
+} from "./chunk-OU2AV7DY.mjs";
+import {
+  useTigerConfig
+} from "./chunk-RUIFGSVN.mjs";
+
+// src/components/Tour.tsx
+import React, {
+  useState,
+  useEffect,
+  useLayoutEffect,
+  useRef,
+  useCallback,
+  useMemo,
+  useId
+} from "react";
+import {
+  classNames,
+  mergeTigerLocale,
+  captureActiveElement,
+  focusFirst,
+  restoreFocus,
+  tourPopoverClasses,
+  tourTitleClasses,
+  tourDescriptionClasses,
+  tourFooterClasses,
+  tourIndicatorClasses,
+  tourCloseButtonClasses,
+  tourMaskClasses,
+  tourPrevButtonGapClass,
+  resolveTourTarget,
+  scrollTourTargetIntoView,
+  getTourRectFromElement,
+  getTourSizeFromElement,
+  getTourPopoverStyle,
+  getTourMaskHoleStyle,
+  resolveTourNav,
+  getTourStepContext,
+  shouldLockTourOverlay,
+  tourNextEvents,
+  tourPrevEvents,
+  tourCloseEvents,
+  shouldCloseOnMaskClick,
+  getTourLabels,
+  closeIconPathD
+} from "@expcat/tigercat-core";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var Tour = React.forwardRef(function Tour2({
+  steps,
+  loadSteps,
+  open = false,
+  current: controlledCurrent,
+  nextText,
+  prevText,
+  finishText,
+  closable = true,
+  maskClosable = true,
+  keyboard = true,
+  showIndicators = true,
+  locale,
+  className,
+  style,
+  onOpenChange,
+  onClose,
+  onFinish,
+  onChange,
+  content,
+  renderTitle,
+  renderDescription,
+  renderFooter,
+  ...rest
+}, forwardedRef) {
+  const config = useTigerConfig();
+  const mergedLocale = useMemo(
+    () => mergeTigerLocale(config.locale, locale),
+    [config.locale, locale]
+  );
+  const labels = useMemo(
+    () => getTourLabels(mergedLocale, { nextText, prevText, finishText }),
+    [finishText, mergedLocale, nextText, prevText]
+  );
+  const [internalStep, setInternalStep] = useState(0);
+  const [resolvedSteps, setResolvedSteps] = useState(steps);
+  const currentStep = controlledCurrent ?? internalStep;
+  const nav = resolveTourNav(resolvedSteps, currentStep);
+  const ctx = getTourStepContext(nav);
+  const step = ctx?.step;
+  const visible = shouldLockTourOverlay(open, Boolean(step));
+  const [targetRect, setTargetRect] = useState();
+  const [popoverSize, setPopoverSize] = useState();
+  const rootRef = useRef(null);
+  const popoverRef = useRef(null);
+  const closeButtonRef = useRef(null);
+  const previousActiveElementRef = useRef(null);
+  const wasOpenRef = useRef(false);
+  if (open && !wasOpenRef.current) {
+    previousActiveElementRef.current = captureActiveElement();
+  }
+  wasOpenRef.current = open;
+  const reactId = useId();
+  const titleId = `tiger-tour-${reactId}-title`;
+  const descriptionId = `tiger-tour-${reactId}-description`;
+  const { anchorRef, target: portalTarget } = useOverlayPortalTarget();
+  useEffect(() => {
+    if (!loadSteps) {
+      setResolvedSteps(steps);
+      return;
+    }
+    if (!open) return;
+    let cancelled = false;
+    Promise.resolve(loadSteps()).then((nextSteps) => {
+      if (!cancelled) setResolvedSteps(nextSteps);
+    }).catch(() => void 0);
+    return () => {
+      cancelled = true;
+    };
+  }, [loadSteps, open, steps]);
+  useLayoutEffect(() => {
+    if (open) return;
+    restoreFocus(previousActiveElementRef.current);
+    previousActiveElementRef.current = null;
+    setInternalStep(0);
+  }, [open]);
+  useLayoutEffect(() => {
+    return () => {
+      const previous = previousActiveElementRef.current;
+      previousActiveElementRef.current = null;
+      queueMicrotask(() => restoreFocus(previous));
+    };
+  }, []);
+  const measure = useCallback(() => {
+    if (!open || !step) {
+      setTargetRect(void 0);
+      return;
+    }
+    const targetEl = resolveTourTarget(step.target);
+    if (targetEl) {
+      scrollTourTargetIntoView(targetEl);
+      setTargetRect(getTourRectFromElement(targetEl));
+    } else {
+      setTargetRect(void 0);
+    }
+    const size = getTourSizeFromElement(popoverRef.current);
+    if (size) setPopoverSize(size);
+  }, [open, step]);
+  useLayoutEffect(() => {
+    if (visible) measure();
+  }, [visible, measure]);
+  useEffect(() => {
+    if (!visible) return;
+    const handler = () => measure();
+    const observer = typeof ResizeObserver === "function" ? new ResizeObserver(handler) : void 0;
+    if (popoverRef.current) observer?.observe(popoverRef.current);
+    const targetEl = resolveTourTarget(step?.target);
+    if (targetEl) observer?.observe(targetEl);
+    window.addEventListener("resize", handler);
+    window.addEventListener("scroll", handler, true);
+    return () => {
+      observer?.disconnect();
+      window.removeEventListener("resize", handler);
+      window.removeEventListener("scroll", handler, true);
+    };
+  }, [visible, measure, step?.target]);
+  useLayoutEffect(() => {
+    if (!visible) return;
+    focusFirst([closeButtonRef.current, popoverRef.current]);
+  }, [visible]);
+  const applyNavEvents = useCallback(
+    (events) => {
+      for (const event of events) {
+        if (event.type === "change") {
+          setInternalStep(event.index);
+          onChange?.(event.index);
+        } else if (event.type === "finish") {
+          onFinish?.();
+        } else if (event.type === "close") {
+          onClose?.();
+        } else {
+          onOpenChange?.(event.open);
+        }
+      }
+    },
+    [onChange, onFinish, onClose, onOpenChange]
+  );
+  const next = useCallback(() => applyNavEvents(tourNextEvents(nav)), [applyNavEvents, nav]);
+  const prev = useCallback(() => applyNavEvents(tourPrevEvents(nav)), [applyNavEvents, nav]);
+  const close = useCallback(() => applyNavEvents(tourCloseEvents()), [applyNavEvents]);
+  const handleMaskClick = useCallback(
+    (event) => {
+      if (shouldCloseOnMaskClick(event, maskClosable)) close();
+    },
+    [close, maskClosable]
+  );
+  useEscapeKey({ enabled: visible && keyboard, onEscape: close, layerRef: rootRef });
+  useBodyScrollLock({ enabled: visible });
+  useFocusTrap({ enabled: visible, containerRef: rootRef, inert: true });
+  const {
+    ["aria-labelledby"]: ariaLabelledbyFromRest,
+    ["aria-label"]: ariaLabelFromRest,
+    ["aria-describedby"]: ariaDescribedbyFromRest,
+    role: _role,
+    tabIndex: _tabIndex,
+    ...dialogRest
+  } = rest;
+  const anchor = /* @__PURE__ */ jsx("span", { ref: anchorRef, hidden: true });
+  if (!visible || !step || !ctx) return anchor;
+  const placement = step.placement ?? "bottom";
+  const showMask = step.mask !== false;
+  const popoverStyle = {
+    ...getTourPopoverStyle(targetRect, popoverSize, placement),
+    ...style
+  };
+  const hasTitle = Boolean(renderTitle || step.title);
+  const hasDescription = Boolean(renderDescription || step.description);
+  const titleNode = renderTitle ? renderTitle(ctx) : step.title;
+  const descriptionNode = renderDescription ? renderDescription(ctx) : step.description;
+  const contentNode = typeof content === "function" ? content(ctx) : content;
+  const footerNode = renderFooter ? renderFooter(ctx) : /* @__PURE__ */ jsxs("div", { className: tourFooterClasses, children: [
+    showIndicators && /* @__PURE__ */ jsxs("span", { className: tourIndicatorClasses, "aria-live": "polite", children: [
+      ctx.position + 1,
+      " / ",
+      ctx.total
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center", children: [
+      !nav.isFirst && /* @__PURE__ */ jsx(
+        Button,
+        {
+          type: "button",
+          size: "sm",
+          variant: "secondary",
+          className: tourPrevButtonGapClass,
+          onClick: prev,
+          children: labels.prevText
+        }
+      ),
+      /* @__PURE__ */ jsx(Button, { type: "button", size: "sm", onClick: next, children: nav.isLast ? labels.finishText : labels.nextText })
+    ] })
+  ] });
+  const overlay = /* @__PURE__ */ jsxs("div", { ref: rootRef, className: "contents", "data-tiger-overlay-layer": "", "data-tiger-tour-root": "", children: [
+    showMask && /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: tourMaskClasses,
+        "data-tiger-tour-mask": "",
+        "aria-hidden": "true",
+        style: targetRect ? getTourMaskHoleStyle(targetRect) : void 0,
+        onClick: handleMaskClick
+      }
+    ),
+    /* @__PURE__ */ jsxs(
+      "div",
+      {
+        ...dialogRest,
+        ref: composeRefs(forwardedRef, popoverRef),
+        className: classNames(tourPopoverClasses, className),
+        style: popoverStyle,
+        role: "dialog",
+        "aria-modal": "true",
+        "aria-labelledby": ariaLabelledbyFromRest ?? (hasTitle ? titleId : void 0),
+        "aria-label": ariaLabelFromRest ?? (hasTitle ? void 0 : labels.dialogAriaLabel),
+        "aria-describedby": ariaDescribedbyFromRest ?? (hasDescription ? descriptionId : void 0),
+        tabIndex: -1,
+        "data-tiger-tour": "",
+        children: [
+          closable && /* @__PURE__ */ jsx(
+            "button",
+            {
+              ref: closeButtonRef,
+              className: tourCloseButtonClasses,
+              type: "button",
+              "aria-label": labels.closeAriaLabel,
+              onClick: close,
+              children: /* @__PURE__ */ jsx(
+                StatusIcon,
+                {
+                  path: closeIconPathD,
+                  className: "h-4 w-4",
+                  "aria-hidden": "true",
+                  focusable: "false"
+                }
+              )
+            }
+          ),
+          titleNode != null && titleNode !== false && /* @__PURE__ */ jsx("div", { id: titleId, className: tourTitleClasses, children: titleNode }),
+          descriptionNode != null && descriptionNode !== false && /* @__PURE__ */ jsx("div", { id: descriptionId, className: tourDescriptionClasses, children: descriptionNode }),
+          contentNode,
+          footerNode
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx("div", { className: "contents", "data-tiger-overlay-host": "" })
+  ] });
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    anchor,
+    renderOverlayPortal(overlay, portalTarget)
+  ] });
+});
+
+export {
+  Tour
+};

package/dist/{chunk-2JMI7TCM.mjs → chunk-LMSEOGKK.mjs}

@@ -1,24 +1,15 @@
 import {
   TaskBoard
-} from "./chunk-O6VYD4E4.mjs";
+} from "./chunk-X7NF2HZV.mjs";
 
 // src/components/Kanban.tsx
 import { jsx } from "react/jsx-runtime";
 var Kanban = ({
   showCardCount = true,
   allowAddCard = true,
-  allowAddColumn = false,
   ...props
 }) => {
-  return /* @__PURE__ */ jsx(
-    TaskBoard,
-    {
-      showCardCount,
-      allowAddCard,
-      allowAddColumn,
-      ...props
-    }
-  );
+  return /* @__PURE__ */ jsx(TaskBoard, { showCardCount, allowAddCard, ...props });
 };
 var Kanban_default = Kanban;
 

package/dist/{chunk-VJWSKJLJ.mjs → chunk-LPVE2LX3.mjs}

@@ -1,13 +1,18 @@
 import {
   ChartCanvas
-} from "./chunk-CUAXRBKO.mjs";
+} from "./chunk-OP77MPGN.mjs";
+import {
+  useTigerConfig
+} from "./chunk-RUIFGSVN.mjs";
 
 // src/components/OrgChart.tsx
 import { useMemo, useState } from "react";
 import {
-  classNames,
   computeOrgChartLayout,
-  getChartInnerRect,
+  getCartesianChartShellClasses,
+  getChartLabels,
+  mergeTigerLocale,
+  normalizeChartPadding,
   getOrgChartNodeAriaLabel,
   getOrgChartNodeClasses,
   orgChartLinkClasses,
@@ -33,23 +38,21 @@ function OrgChart({
   selectable = false,
   selectedId,
   activeOpacity = 1,
-  inactiveOpacity = 0.35,
+  inactiveOpacity = 0.25,
   colors,
   title,
   desc,
-  ariaLabel = "Organization chart",
+  ariaLabel,
   className,
   onNodeClick,
   onNodeHover,
   onSelectedIdChange
 }) {
+  const config = useTigerConfig();
+  const labels = useMemo(() => getChartLabels(mergeTigerLocale(config.locale)), [config.locale]);
   const [innerSelectedId, setInnerSelectedId] = useState(null);
   const [hoveredId, setHoveredId] = useState(null);
   const resolvedSelectedId = selectedId === void 0 ? innerSelectedId : selectedId;
-  const innerRect = useMemo(
-    () => getChartInnerRect(width, height, padding),
-    [height, padding, width]
-  );
   const layout = useMemo(
     () => computeOrgChartLayout(data, {
       nodeWidth,
@@ -61,11 +64,22 @@ function OrgChart({
     }),
     [colors, data, direction, levelGap, nodeHeight, nodeWidth, siblingGap]
   );
-  const offsetX = Math.max(0, (innerRect.width - layout.width) / 2);
-  const offsetY = Math.max(0, (innerRect.height - layout.height) / 2);
+  const resolvedPadding = normalizeChartPadding(padding);
+  const plotWidth = Math.max(width, layout.width + resolvedPadding.left + resolvedPadding.right);
+  const plotHeight = Math.max(height, layout.height + resolvedPadding.top + resolvedPadding.bottom);
+  const offsetX = Math.max(
+    0,
+    (plotWidth - resolvedPadding.left - resolvedPadding.right - layout.width) / 2
+  );
+  const offsetY = Math.max(
+    0,
+    (plotHeight - resolvedPadding.top - resolvedPadding.bottom - layout.height) / 2
+  );
   const activeId = resolvedSelectedId ?? hoveredId;
+  const canClick = hoverable || selectable || Boolean(onNodeClick);
   const selectNode = (node) => {
-    if (selectable && !node.node.disabled) {
+    if (node.node.disabled) return;
+    if (selectable) {
       const nextId = resolvedSelectedId === node.id ? null : node.id;
       if (selectedId === void 0) setInnerSelectedId(nextId);
       onSelectedIdChange?.(nextId);
@@ -73,6 +87,7 @@ function OrgChart({
     onNodeClick?.(node.node);
   };
   const setHoveredNode = (node) => {
+    if (!hoverable && !onNodeHover) return;
     if (!hoverable) return;
     setHoveredId(node?.id ?? null);
     onNodeHover?.(node?.node ?? null);
@@ -81,17 +96,15 @@ function OrgChart({
     if (activeId === null) return activeOpacity;
     return activeId === node.id ? activeOpacity : inactiveOpacity;
   };
-  return /* @__PURE__ */ jsx(
+  return /* @__PURE__ */ jsx("div", { className: getCartesianChartShellClasses({ showLegend: false, className }), children: /* @__PURE__ */ jsx(
     ChartCanvas,
     {
-      width,
-      height,
+      width: plotWidth,
+      height: plotHeight,
       padding,
       title,
       desc,
-      className: classNames(className),
-      role: "img",
-      "aria-label": ariaLabel,
+      "aria-label": ariaLabel ?? (title ? void 0 : labels.orgChartAriaLabel),
       children: /* @__PURE__ */ jsxs("g", { transform: `translate(${offsetX}, ${offsetY})`, "data-series-type": "org-chart", children: [
         /* @__PURE__ */ jsx("g", { "data-org-chart-links": "true", children: layout.links.map((link) => /* @__PURE__ */ jsx(
           "path",
@@ -103,7 +116,7 @@ function OrgChart({
         )) }),
         /* @__PURE__ */ jsx("g", { "data-org-chart-nodes": "true", children: layout.nodes.map((node) => {
           const selected = resolvedSelectedId === node.id;
-          const interactive = (hoverable || selectable) && !node.node.disabled;
+          const interactive = canClick && !node.node.disabled;
           const textStart = showAvatars && node.node.avatar ? 58 : 16;
           return /* @__PURE__ */ jsxs(
             "g",
@@ -112,7 +125,7 @@ function OrgChart({
               className: getOrgChartNodeClasses(interactive, selected),
               opacity: getNodeOpacity(node),
               role: interactive ? "button" : "group",
-              tabIndex: interactive ? 0 : void 0,
+              tabIndex: interactive ? activeId === node.id || activeId === null && node.index === 0 ? 0 : -1 : void 0,
               "aria-label": getOrgChartNodeAriaLabel(node.node),
               onMouseEnter: () => setHoveredNode(node),
               onMouseLeave: () => setHoveredNode(null),
@@ -158,7 +171,7 @@ function OrgChart({
         }) })
       ] })
     }
-  );
+  ) });
 }
 OrgChart.displayName = "OrgChart";
 

package/dist/chunk-LTIICOWN.mjs

@@ -0,0 +1,115 @@
+// src/components/Highlight.tsx
+import React, { cloneElement, forwardRef, isValidElement } from "react";
+import {
+  findHighlightRanges,
+  getHighlightMarkClasses,
+  getHighlightRootClasses,
+  getHighlightSegments,
+  resolveHighlightText,
+  sliceTextByHighlightRanges
+} from "@expcat/tigercat-core";
+import { jsx } from "react/jsx-runtime";
+function flattenReactText(node) {
+  if (node == null || typeof node === "boolean") return "";
+  if (typeof node === "string" || typeof node === "number") return String(node);
+  if (Array.isArray(node)) {
+    let out = "";
+    for (const item of node) out += flattenReactText(item);
+    return out;
+  }
+  if (isValidElement(node)) {
+    const props = node.props;
+    return flattenReactText(props.children);
+  }
+  return "";
+}
+function highlightReactNode(node, ranges, offset, markClasses, highlightStyle) {
+  if (node == null || typeof node === "boolean") return node;
+  if (typeof node === "string" || typeof node === "number") {
+    const text = String(node);
+    const pieces = sliceTextByHighlightRanges(text, offset.current, ranges);
+    offset.current += text.length;
+    if (pieces.length === 1 && !pieces[0].highlighted) return text;
+    return pieces.map(
+      (piece, index) => piece.highlighted ? /* @__PURE__ */ jsx(
+        "mark",
+        {
+          className: markClasses,
+          style: highlightStyle,
+          "data-highlight-mark": "",
+          children: piece.text
+        },
+        `mark-${piece.start}-${index}`
+      ) : /* @__PURE__ */ jsx(React.Fragment, { children: piece.text }, `text-${piece.start}-${index}`)
+    );
+  }
+  if (Array.isArray(node)) {
+    return node.map((child, index) => /* @__PURE__ */ jsx(React.Fragment, { children: highlightReactNode(child, ranges, offset, markClasses, highlightStyle) }, index));
+  }
+  if (isValidElement(node)) {
+    const children = node.props.children;
+    if (children == null) return node;
+    return cloneElement(
+      node,
+      void 0,
+      highlightReactNode(children, ranges, offset, markClasses, highlightStyle)
+    );
+  }
+  return node;
+}
+var Highlight = forwardRef(
+  ({
+    text,
+    keywords,
+    caseSensitive = false,
+    global = true,
+    highlightClassName,
+    highlightStyle,
+    className,
+    style,
+    children,
+    ...rest
+  }, ref) => {
+    const markClasses = getHighlightMarkClasses(highlightClassName);
+    const source = resolveHighlightText(text, flattenReactText(children));
+    const options = { caseSensitive, global };
+    const content = text != null ? getHighlightSegments(source, keywords, options).map(
+      (segment) => segment.highlighted ? /* @__PURE__ */ jsx(
+        "mark",
+        {
+          className: markClasses,
+          style: highlightStyle,
+          "data-highlight-mark": "",
+          children: segment.text
+        },
+        `mark-${segment.start}-${segment.end}`
+      ) : /* @__PURE__ */ jsx(React.Fragment, { children: segment.text }, `text-${segment.start}-${segment.end}`)
+    ) : highlightReactNode(
+      children,
+      findHighlightRanges(source, keywords, options),
+      { current: 0 },
+      markClasses,
+      highlightStyle
+    );
+    return /* @__PURE__ */ jsx(
+      "span",
+      {
+        ref,
+        "data-highlight": "",
+        "data-highlight-case-sensitive": caseSensitive ? "true" : "false",
+        "data-highlight-global": global ? "true" : "false",
+        className: getHighlightRootClasses(className),
+        style,
+        ...rest,
+        children: content
+      }
+    );
+  }
+);
+Highlight.displayName = "Highlight";
+var Highlight_default = Highlight;
+
+export {
+  Highlight,
+  Highlight_default
+};

package/dist/chunk-MADQ6KHD.mjs

@@ -0,0 +1,116 @@
+import {
+  useFormItemControlContext
+} from "./chunk-F6T3OLTQ.mjs";
+import {
+  useControlledState
+} from "./chunk-UJTAHHQT.mjs";
+
+// src/components/RadioGroup.tsx
+import React, { useCallback, useId, useMemo } from "react";
+import {
+  collectRadioGroupInputs,
+  getChoiceGroupClasses,
+  getElementTextDirection,
+  getRadioGroupKeyboardNextIndex,
+  markFormItemGroupControl,
+  mergeAriaDescribedBy
+} from "@expcat/tigercat-core";
+import { jsx } from "react/jsx-runtime";
+var RadioGroupContext = React.createContext(null);
+var RadioGroupInner = ({
+  value,
+  defaultValue,
+  name,
+  disabled = false,
+  size = "md",
+  direction = "vertical",
+  status: statusProp,
+  onChange,
+  children,
+  className,
+  onKeyDown,
+  ...props
+}) => {
+  const formItemControl = useFormItemControlContext();
+  const [currentValue, setValue] = useControlledState({
+    value,
+    defaultValue,
+    onChange: (next) => {
+      if (next === void 0) return;
+      onChange?.(next);
+      formItemControl?.onChange?.(next);
+    }
+  });
+  const reactId = useId();
+  const groupName = name || `tiger-radio-${reactId}`;
+  const effectiveDisabled = Boolean(disabled || formItemControl?.disabled);
+  const status = statusProp ?? formItemControl?.status ?? "default";
+  const labelledby = typeof props["aria-labelledby"] === "string" && props["aria-labelledby"].trim() ? props["aria-labelledby"].trim() : formItemControl?.labelId;
+  const describedBy = mergeAriaDescribedBy(
+    typeof props["aria-describedby"] === "string" ? props["aria-describedby"] : void 0,
+    formItemControl?.describedBy
+  );
+  const role = "radiogroup";
+  const handleChange = useCallback(
+    (newValue) => {
+      if (effectiveDisabled) return;
+      setValue(newValue);
+    },
+    [effectiveDisabled, setValue]
+  );
+  const handleKeyDown = (event) => {
+    onKeyDown?.(event);
+    if (event.defaultPrevented || effectiveDisabled) return;
+    const target = event.target;
+    const currentInput = target.closest('input[type="radio"]');
+    if (!currentInput) return;
+    const container = event.currentTarget;
+    const enabledInputs = collectRadioGroupInputs(container).filter((input) => !input.disabled);
+    if (enabledInputs.length === 0) return;
+    const currentIndex = enabledInputs.indexOf(currentInput);
+    if (currentIndex === -1) return;
+    const rtl = getElementTextDirection(container) === "rtl";
+    const nextIndex = getRadioGroupKeyboardNextIndex(
+      event.key,
+      currentIndex,
+      enabledInputs.length,
+      rtl
+    );
+    if (nextIndex === null) return;
+    event.preventDefault();
+    const nextInput = enabledInputs[nextIndex];
+    nextInput.focus();
+    nextInput.click();
+  };
+  const contextValue = useMemo(
+    () => ({
+      value: currentValue,
+      name: groupName,
+      disabled: effectiveDisabled,
+      size,
+      onChange: handleChange
+    }),
+    [currentValue, groupName, effectiveDisabled, size, handleChange]
+  );
+  return /* @__PURE__ */ jsx(RadioGroupContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx(
+    "div",
+    {
+      ...props,
+      className: getChoiceGroupClasses({ direction, className }),
+      role,
+      "aria-labelledby": labelledby,
+      "aria-describedby": describedBy,
+      "aria-invalid": status === "error" ? true : props["aria-invalid"],
+      "aria-disabled": effectiveDisabled || void 0,
+      onKeyDown: handleKeyDown,
+      children
+    }
+  ) });
+};
+var RadioGroup = markFormItemGroupControl(RadioGroupInner);
+RadioGroup.displayName = "RadioGroup";
+
+export {
+  RadioGroupContext,
+  RadioGroup
+};