@spacing-ui/core 0.1.0 → 0.2.0

package/dist/index.cjs

@@ -21,7 +21,7 @@ var Root = ({ value, onValueChange, children }) => {
   const triggerRef = react.useRef(null);
   const listboxRef = react.useRef(null);
   const reactId = react.useId();
-  const triggerId = `${reactId}trigger`;
+  const triggerId2 = `${reactId}trigger`;
   const listboxId = `${reactId}listbox`;
   const optionIdPrefix = `${reactId}option-`;
   const getOptionId = react.useCallback(
@@ -60,7 +60,7 @@ var Root = ({ value, onValueChange, children }) => {
       onValueChange,
       activeValue,
       setActiveValue,
-      triggerId,
+      triggerId: triggerId2,
       listboxId,
       triggerRef,
       listboxRef,
@@ -73,7 +73,7 @@ var Root = ({ value, onValueChange, children }) => {
       value,
       onValueChange,
       activeValue,
-      triggerId,
+      triggerId2,
       listboxId,
       getOptionId,
       getOrderedOptions
@@ -252,7 +252,992 @@ var Select = Object.assign(Root, {
   Content,
   Option
 });
+var DEFAULT_DELAY_MS = 700;
+var DEFAULT_SKIP_DELAY_MS = 300;
+var ProviderContext = react.createContext(null);
+var Provider = ({
+  children,
+  delayDuration = DEFAULT_DELAY_MS,
+  skipDelayDuration = DEFAULT_SKIP_DELAY_MS
+}) => {
+  const lastCloseAt = react.useRef(0);
+  const isInSkipWindow = react.useCallback(
+    () => Date.now() - lastCloseAt.current < skipDelayDuration,
+    [skipDelayDuration]
+  );
+  const noteClose = react.useCallback(() => {
+    lastCloseAt.current = Date.now();
+  }, []);
+  const value = react.useMemo(
+    () => ({ delayDuration, skipDelayDuration, isInSkipWindow, noteClose }),
+    [delayDuration, skipDelayDuration, isInSkipWindow, noteClose]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(ProviderContext.Provider, { value, children });
+};
+var TooltipContext = react.createContext(null);
+function useTooltipContext(component) {
+  const ctx = react.useContext(TooltipContext);
+  if (!ctx) {
+    throw new Error(`<Tooltip.${component}> must be rendered inside <Tooltip>`);
+  }
+  return ctx;
+}
+var Root2 = ({
+  children,
+  delayDuration,
+  open: controlledOpen,
+  defaultOpen = false,
+  onOpenChange
+}) => {
+  const provider = react.useContext(ProviderContext);
+  const effectiveDelay = delayDuration ?? provider?.delayDuration ?? DEFAULT_DELAY_MS;
+  const isControlled = controlledOpen !== void 0;
+  const [uncontrolledOpen, setUncontrolledOpen] = react.useState(defaultOpen);
+  const open = isControlled ? controlledOpen : uncontrolledOpen;
+  const openTimerRef = react.useRef(null);
+  const triggerRef = react.useRef(null);
+  const reactId = react.useId();
+  const contentId2 = `${reactId}content`;
+  const clearOpenTimer = react.useCallback(() => {
+    if (openTimerRef.current !== null) {
+      clearTimeout(openTimerRef.current);
+      openTimerRef.current = null;
+    }
+  }, []);
+  const setOpen = react.useCallback(
+    (next) => {
+      if (!isControlled) setUncontrolledOpen(next);
+      onOpenChange?.(next);
+      if (!next) provider?.noteClose();
+    },
+    [isControlled, onOpenChange, provider]
+  );
+  const scheduleOpen = react.useCallback(() => {
+    clearOpenTimer();
+    if (provider?.isInSkipWindow()) {
+      setOpen(true);
+      return;
+    }
+    openTimerRef.current = setTimeout(() => {
+      setOpen(true);
+      openTimerRef.current = null;
+    }, effectiveDelay);
+  }, [clearOpenTimer, effectiveDelay, provider, setOpen]);
+  const closeImmediately = react.useCallback(() => {
+    clearOpenTimer();
+    setOpen(false);
+  }, [clearOpenTimer, setOpen]);
+  react.useEffect(() => clearOpenTimer, [clearOpenTimer]);
+  const setTriggerRef = react.useCallback((node) => {
+    triggerRef.current = node;
+  }, []);
+  const triggerProps = react.useMemo(
+    () => ({
+      onMouseEnter: () => scheduleOpen(),
+      onMouseLeave: () => closeImmediately(),
+      onFocus: () => {
+        clearOpenTimer();
+        setOpen(true);
+      },
+      onBlur: () => closeImmediately(),
+      onKeyDown: (e) => {
+        if (e.key === "Escape" && open) {
+          closeImmediately();
+        }
+      },
+      "aria-describedby": open ? contentId2 : void 0
+    }),
+    [scheduleOpen, closeImmediately, clearOpenTimer, setOpen, open, contentId2]
+  );
+  const value = react.useMemo(
+    () => ({ open, contentId: contentId2, triggerProps, setTriggerRef }),
+    [open, contentId2, triggerProps, setTriggerRef]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(TooltipContext.Provider, { value, children });
+};
+function composeRef(...refs) {
+  return (node) => {
+    for (const ref of refs) {
+      if (!ref) continue;
+      if (typeof ref === "function") ref(node);
+      else ref.current = node;
+    }
+  };
+}
+function composeHandler(...handlers) {
+  return (e) => {
+    for (const handler of handlers) {
+      handler?.(e);
+      if (typeof e.defaultPrevented === "boolean" && e.defaultPrevented) {
+        return;
+      }
+    }
+  };
+}
+var Trigger3 = ({ children }) => {
+  const ctx = useTooltipContext("Trigger");
+  if (!react.isValidElement(children)) {
+    throw new Error("<Tooltip.Trigger> expects a single React element child.");
+  }
+  const child = children;
+  const childProps = child.props;
+  const childRef = child.ref;
+  const merged = {
+    ...childProps,
+    onMouseEnter: composeHandler(
+      childProps.onMouseEnter,
+      ctx.triggerProps.onMouseEnter
+    ),
+    onMouseLeave: composeHandler(
+      childProps.onMouseLeave,
+      ctx.triggerProps.onMouseLeave
+    ),
+    onFocus: composeHandler(
+      childProps.onFocus,
+      ctx.triggerProps.onFocus
+    ),
+    onBlur: composeHandler(
+      childProps.onBlur,
+      ctx.triggerProps.onBlur
+    ),
+    onKeyDown: composeHandler(
+      childProps.onKeyDown,
+      ctx.triggerProps.onKeyDown
+    ),
+    "aria-describedby": [childProps["aria-describedby"], ctx.triggerProps["aria-describedby"]].filter(Boolean).join(" ") || void 0,
+    ref: composeRef(childRef, ctx.setTriggerRef)
+  };
+  return react.cloneElement(child, merged);
+};
+var Content2 = ({ children, forceMount, id, ...rest }) => {
+  const ctx = useTooltipContext("Content");
+  if (!ctx.open && !forceMount) return null;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      id: id ?? ctx.contentId,
+      role: "tooltip",
+      "data-state": ctx.open ? "open" : "closed",
+      ...rest,
+      children
+    }
+  );
+};
+var Tooltip = Object.assign(Root2, {
+  Provider,
+  Trigger: Trigger3,
+  Content: Content2
+});
+var Switch = react.forwardRef(function Switch2({
+  checked: controlledChecked,
+  defaultChecked = false,
+  onCheckedChange,
+  disabled,
+  onClick,
+  onKeyDown,
+  ...rest
+}, ref) {
+  const isControlled = controlledChecked !== void 0;
+  const [uncontrolled, setUncontrolled] = react.useState(defaultChecked);
+  const checked = isControlled ? controlledChecked : uncontrolled;
+  const toggle = react.useCallback(() => {
+    if (disabled) return;
+    const next = !checked;
+    if (!isControlled) setUncontrolled(next);
+    onCheckedChange?.(next);
+  }, [checked, disabled, isControlled, onCheckedChange]);
+  const handleClick = (e) => {
+    onClick?.(e);
+    if (e.defaultPrevented) return;
+    toggle();
+  };
+  const handleKeyDown = (e) => {
+    onKeyDown?.(e);
+    if (e.defaultPrevented) return;
+    if (e.key === " " || e.key === "Enter") {
+      e.preventDefault();
+      toggle();
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "button",
+    {
+      ref,
+      type: "button",
+      role: "switch",
+      "aria-checked": checked,
+      "aria-disabled": disabled || void 0,
+      disabled,
+      "data-state": checked ? "checked" : "unchecked",
+      "data-disabled": disabled || void 0,
+      onClick: handleClick,
+      onKeyDown: handleKeyDown,
+      ...rest
+    }
+  );
+});
+var isChecked = (s) => s === true;
+var isIndeterminate = (s) => s === "indeterminate";
+var Checkbox = react.forwardRef(function Checkbox2({
+  checked: controlled,
+  defaultChecked = false,
+  onCheckedChange,
+  disabled,
+  required,
+  onClick,
+  onKeyDown,
+  ...rest
+}, ref) {
+  const isControlled = controlled !== void 0;
+  const [uncontrolled, setUncontrolled] = react.useState(defaultChecked);
+  const value = isControlled ? controlled : uncontrolled;
+  const toggle = react.useCallback(() => {
+    if (disabled) return;
+    const next = isChecked(value) ? false : true;
+    if (!isControlled) setUncontrolled(next);
+    onCheckedChange?.(next);
+  }, [disabled, isControlled, onCheckedChange, value]);
+  const handleClick = (e) => {
+    onClick?.(e);
+    if (e.defaultPrevented) return;
+    toggle();
+  };
+  const handleKeyDown = (e) => {
+    onKeyDown?.(e);
+    if (e.defaultPrevented) return;
+    if (e.key === " ") {
+      e.preventDefault();
+      toggle();
+    }
+  };
+  const ariaChecked = isIndeterminate(value) ? "mixed" : isChecked(value) ? "true" : "false";
+  const dataState = isIndeterminate(value) ? "indeterminate" : isChecked(value) ? "checked" : "unchecked";
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "button",
+    {
+      ref,
+      type: "button",
+      role: "checkbox",
+      "aria-checked": ariaChecked,
+      "aria-required": required || void 0,
+      "aria-disabled": disabled || void 0,
+      disabled,
+      "data-state": dataState,
+      "data-disabled": disabled || void 0,
+      onClick: handleClick,
+      onKeyDown: handleKeyDown,
+      ...rest
+    }
+  );
+});
+var RadioGroupContext = react.createContext(null);
+function useRadioGroupContext(component) {
+  const ctx = react.useContext(RadioGroupContext);
+  if (!ctx) {
+    throw new Error(`<${component}> must be rendered inside <RadioGroup>`);
+  }
+  return ctx;
+}
+var Root3 = react.forwardRef(function RadioGroup({
+  value: controlled,
+  defaultValue,
+  onValueChange,
+  name,
+  disabled = false,
+  orientation = "vertical",
+  children,
+  ...rest
+}, forwardedRef) {
+  const isControlled = controlled !== void 0;
+  const [uncontrolled, setUncontrolled] = react.useState(defaultValue ?? null);
+  const value = isControlled ? controlled ?? null : uncontrolled;
+  const reactId = react.useId();
+  const generatedName = name ?? `${reactId}name`;
+  const groupRef = react.useRef(null);
+  const setRefs = (node) => {
+    groupRef.current = node;
+    if (typeof forwardedRef === "function") forwardedRef(node);
+    else if (forwardedRef) forwardedRef.current = node;
+  };
+  const setValue = react.useCallback(
+    (next) => {
+      if (disabled) return;
+      if (!isControlled) setUncontrolled(next);
+      onValueChange?.(next);
+    },
+    [disabled, isControlled, onValueChange]
+  );
+  react.useEffect(() => {
+    const root = groupRef.current;
+    if (!root) return;
+    const items = Array.from(root.querySelectorAll('[role="radio"]'));
+    const tabbable = value !== null ? items.find((el) => el.getAttribute("data-value") === value && !el.disabled) : items.find((el) => !el.disabled);
+    items.forEach((el) => {
+      el.tabIndex = el === tabbable ? 0 : -1;
+    });
+  });
+  const ctx = react.useMemo(
+    () => ({
+      value,
+      onValueChange: setValue,
+      name: generatedName,
+      disabled,
+      orientation,
+      groupRef
+    }),
+    [value, setValue, generatedName, disabled, orientation]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(RadioGroupContext.Provider, { value: ctx, children: /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      ref: setRefs,
+      role: "radiogroup",
+      "aria-orientation": orientation,
+      "aria-disabled": disabled || void 0,
+      "data-disabled": disabled || void 0,
+      ...rest,
+      children
+    }
+  ) });
+});
+var Item = react.forwardRef(function RadioGroupItem({ value, disabled: itemDisabled, onClick, onKeyDown, ...rest }, ref) {
+  const ctx = useRadioGroupContext("RadioGroup.Item");
+  const disabled = ctx.disabled || !!itemDisabled;
+  const checked = ctx.value === value;
+  const handleClick = (e) => {
+    onClick?.(e);
+    if (e.defaultPrevented || disabled) return;
+    ctx.onValueChange(value);
+  };
+  const move = (direction) => {
+    const root = ctx.groupRef.current;
+    if (!root) return;
+    const items = Array.from(root.querySelectorAll('[role="radio"]')).filter(
+      (el) => !el.disabled
+    );
+    if (items.length === 0) return;
+    const idx = items.findIndex((el) => el === document.activeElement);
+    const nextIdx = (idx + direction + items.length) % items.length;
+    const next = items[nextIdx];
+    if (!next) return;
+    next.focus();
+    const nextValue = next.getAttribute("data-value");
+    if (nextValue) ctx.onValueChange(nextValue);
+  };
+  const handleKeyDown = (e) => {
+    onKeyDown?.(e);
+    if (e.defaultPrevented || disabled) return;
+    const nextKey = ctx.orientation === "horizontal" ? "ArrowRight" : "ArrowDown";
+    const prevKey = ctx.orientation === "horizontal" ? "ArrowLeft" : "ArrowUp";
+    if (e.key === nextKey) {
+      e.preventDefault();
+      move(1);
+    } else if (e.key === prevKey) {
+      e.preventDefault();
+      move(-1);
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "button",
+    {
+      ref,
+      type: "button",
+      role: "radio",
+      name: ctx.name,
+      value,
+      "aria-checked": checked,
+      "aria-disabled": disabled || void 0,
+      disabled,
+      tabIndex: -1,
+      "data-value": value,
+      "data-state": checked ? "checked" : "unchecked",
+      "data-disabled": disabled || void 0,
+      onClick: handleClick,
+      onKeyDown: handleKeyDown,
+      ...rest
+    }
+  );
+});
+var RadioGroup2 = Object.assign(Root3, { Item });
+var TabsContext = react.createContext(null);
+function useTabsContext(component) {
+  const ctx = react.useContext(TabsContext);
+  if (!ctx) {
+    throw new Error(`<Tabs.${component}> must be rendered inside <Tabs>`);
+  }
+  return ctx;
+}
+var triggerId = (prefix, value) => `${prefix}trigger-${value.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+var contentId = (prefix, value) => `${prefix}content-${value.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+var Root4 = react.forwardRef(function Tabs({
+  value: controlled,
+  defaultValue,
+  onValueChange,
+  orientation = "horizontal",
+  activationMode = "automatic",
+  children,
+  ...rest
+}, ref) {
+  const isControlled = controlled !== void 0;
+  const [uncontrolled, setUncontrolled] = react.useState(defaultValue ?? null);
+  const value = isControlled ? controlled ?? null : uncontrolled;
+  const reactId = react.useId();
+  const listRef = react.useRef(null);
+  const setValue = react.useCallback(
+    (next) => {
+      if (!isControlled) setUncontrolled(next);
+      onValueChange?.(next);
+    },
+    [isControlled, onValueChange]
+  );
+  const ctx = react.useMemo(
+    () => ({
+      value,
+      onValueChange: setValue,
+      activationMode,
+      orientation,
+      idPrefix: reactId,
+      listRef
+    }),
+    [value, setValue, activationMode, orientation, reactId]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(TabsContext.Provider, { value: ctx, children: /* @__PURE__ */ jsxRuntime.jsx("div", { ref, "data-orientation": orientation, ...rest, children }) });
+});
+var List = react.forwardRef(function TabsList({ loop = true, children, ...rest }, forwardedRef) {
+  const ctx = useTabsContext("List");
+  const setRefs = (node) => {
+    ctx.listRef.current = node;
+    if (typeof forwardedRef === "function") forwardedRef(node);
+    else if (forwardedRef) forwardedRef.current = node;
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      ref: setRefs,
+      role: "tablist",
+      "aria-orientation": ctx.orientation,
+      "data-orientation": ctx.orientation,
+      "data-loop": loop || void 0,
+      ...rest,
+      children
+    }
+  );
+});
+var Trigger4 = react.forwardRef(function TabsTrigger({ value, disabled, onClick, onKeyDown, onFocus, ...rest }, ref) {
+  const ctx = useTabsContext("Trigger");
+  const selected = ctx.value === value;
+  const handleClick = (e) => {
+    onClick?.(e);
+    if (e.defaultPrevented || disabled) return;
+    ctx.onValueChange(value);
+  };
+  const move = (direction) => {
+    const root = ctx.listRef.current;
+    if (!root) return;
+    const triggers = Array.from(root.querySelectorAll('[role="tab"]')).filter(
+      (el) => !el.disabled
+    );
+    if (triggers.length === 0) return;
+    let nextIdx;
+    if (direction === "first") nextIdx = 0;
+    else if (direction === "last") nextIdx = triggers.length - 1;
+    else {
+      const idx = triggers.findIndex((el) => el === document.activeElement);
+      const loopList = (root.getAttribute("data-loop") ?? "true") !== "false";
+      const candidate = idx + direction;
+      if (candidate < 0) nextIdx = loopList ? triggers.length - 1 : 0;
+      else if (candidate >= triggers.length) nextIdx = loopList ? 0 : triggers.length - 1;
+      else nextIdx = candidate;
+    }
+    const target = triggers[nextIdx];
+    if (!target) return;
+    target.focus();
+    if (ctx.activationMode === "automatic") {
+      const v = target.getAttribute("data-value");
+      if (v) ctx.onValueChange(v);
+    }
+  };
+  const handleKeyDown = (e) => {
+    onKeyDown?.(e);
+    if (e.defaultPrevented || disabled) return;
+    const nextKey = ctx.orientation === "horizontal" ? "ArrowRight" : "ArrowDown";
+    const prevKey = ctx.orientation === "horizontal" ? "ArrowLeft" : "ArrowUp";
+    if (e.key === nextKey) {
+      e.preventDefault();
+      move(1);
+    } else if (e.key === prevKey) {
+      e.preventDefault();
+      move(-1);
+    } else if (e.key === "Home") {
+      e.preventDefault();
+      move("first");
+    } else if (e.key === "End") {
+      e.preventDefault();
+      move("last");
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "button",
+    {
+      ref,
+      type: "button",
+      role: "tab",
+      id: triggerId(ctx.idPrefix, value),
+      "aria-selected": selected,
+      "aria-controls": contentId(ctx.idPrefix, value),
+      "aria-disabled": disabled || void 0,
+      disabled,
+      tabIndex: selected ? 0 : -1,
+      "data-value": value,
+      "data-state": selected ? "active" : "inactive",
+      "data-disabled": disabled || void 0,
+      "data-orientation": ctx.orientation,
+      onClick: handleClick,
+      onKeyDown: handleKeyDown,
+      onFocus,
+      ...rest
+    }
+  );
+});
+var Content3 = react.forwardRef(function TabsContent({ value, forceMount, hidden, ...rest }, ref) {
+  const ctx = useTabsContext("Content");
+  const selected = ctx.value === value;
+  if (!selected && !forceMount) return null;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      ref,
+      role: "tabpanel",
+      id: contentId(ctx.idPrefix, value),
+      "aria-labelledby": triggerId(ctx.idPrefix, value),
+      "data-state": selected ? "active" : "inactive",
+      "data-orientation": ctx.orientation,
+      hidden: hidden ?? !selected,
+      tabIndex: 0,
+      ...rest
+    }
+  );
+});
+var Tabs2 = Object.assign(Root4, { List, Trigger: Trigger4, Content: Content3 });
+var AccordionContext = react.createContext(null);
+function useAccordionContext(component) {
+  const ctx = react.useContext(AccordionContext);
+  if (!ctx) {
+    throw new Error(`<Accordion.${component}> must be rendered inside <Accordion>`);
+  }
+  return ctx;
+}
+var ItemContext = react.createContext(null);
+function useItemContext(component) {
+  const ctx = react.useContext(ItemContext);
+  if (!ctx) {
+    throw new Error(`<Accordion.${component}> must be rendered inside <Accordion.Item>`);
+  }
+  return ctx;
+}
+var Root5 = react.forwardRef(function Accordion(props, forwardedRef) {
+  const {
+    type,
+    disabled = false,
+    children,
+    // strip controlled-state props so they don't leak onto the DOM
+    value: _v,
+    defaultValue: _dv,
+    onValueChange: _ovc,
+    collapsible: _col,
+    ...rest
+  } = props;
+  const isMultiple = type === "multiple";
+  const controlled = "value" in props ? isMultiple ? props.value : props.value : void 0;
+  const isControlled = controlled !== void 0;
+  const defaultValue = "defaultValue" in props ? isMultiple ? props.defaultValue ?? [] : props.defaultValue ?? null : isMultiple ? [] : null;
+  const [uncontrolledArr, setUncontrolledArr] = react.useState(
+    isMultiple ? defaultValue ?? [] : []
+  );
+  const [uncontrolledStr, setUncontrolledStr] = react.useState(
+    isMultiple ? null : defaultValue ?? null
+  );
+  const values = react.useMemo(() => {
+    if (isMultiple) {
+      return isControlled ? controlled ?? [] : uncontrolledArr;
+    }
+    return isControlled ? controlled ? [controlled] : [] : uncontrolledStr ? [uncontrolledStr] : [];
+  }, [isMultiple, isControlled, controlled, uncontrolledArr, uncontrolledStr]);
+  const collapsible = !isMultiple && "collapsible" in props ? !!props.collapsible : isMultiple;
+  const reactId = react.useId();
+  const rootRef = react.useRef(null);
+  const setRefs = (node) => {
+    rootRef.current = node;
+    if (typeof forwardedRef === "function") forwardedRef(node);
+    else if (forwardedRef) forwardedRef.current = node;
+  };
+  const toggle = react.useCallback(
+    (value) => {
+      if (disabled) return;
+      if (isMultiple) {
+        const arr = isControlled ? controlled ?? [] : uncontrolledArr;
+        const next = arr.includes(value) ? arr.filter((v) => v !== value) : [...arr, value];
+        if (!isControlled) setUncontrolledArr(next);
+        props.onValueChange?.(next);
+      } else {
+        const current = isControlled ? controlled : uncontrolledStr;
+        const allowEmpty = "collapsible" in props ? !!props.collapsible : false;
+        let next;
+        if (current === value) {
+          if (!allowEmpty) return;
+          next = "";
+        } else {
+          next = value;
+        }
+        if (!isControlled) setUncontrolledStr(next || null);
+        props.onValueChange?.(next);
+      }
+    },
+    [disabled, isMultiple, isControlled, controlled, uncontrolledArr, uncontrolledStr, props]
+  );
+  const ctx = react.useMemo(
+    () => ({
+      type,
+      values,
+      toggle,
+      collapsible,
+      disabled,
+      idPrefix: reactId,
+      rootRef
+    }),
+    [type, values, toggle, collapsible, disabled, reactId]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(AccordionContext.Provider, { value: ctx, children: /* @__PURE__ */ jsxRuntime.jsx("div", { ref: setRefs, "data-disabled": disabled || void 0, ...rest, children }) });
+});
+var Item2 = react.forwardRef(function AccordionItem({ value, disabled: itemDisabled, children, ...rest }, ref) {
+  const ctx = useAccordionContext("Item");
+  const open = ctx.values.includes(value);
+  const disabled = ctx.disabled || !!itemDisabled;
+  const safeValue = value.replace(/[^a-zA-Z0-9_-]/g, "_");
+  const triggerId2 = `${ctx.idPrefix}trigger-${safeValue}`;
+  const contentId2 = `${ctx.idPrefix}content-${safeValue}`;
+  const itemCtx = react.useMemo(
+    () => ({ value, open, disabled, triggerId: triggerId2, contentId: contentId2 }),
+    [value, open, disabled, triggerId2, contentId2]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(ItemContext.Provider, { value: itemCtx, children: /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      ref,
+      "data-state": open ? "open" : "closed",
+      "data-disabled": disabled || void 0,
+      ...rest,
+      children
+    }
+  ) });
+});
+var Trigger5 = react.forwardRef(function AccordionTrigger({ onClick, onKeyDown, ...rest }, ref) {
+  const ctx = useAccordionContext("Trigger");
+  const item = useItemContext("Trigger");
+  const handleClick = (e) => {
+    onClick?.(e);
+    if (e.defaultPrevented || item.disabled) return;
+    ctx.toggle(item.value);
+  };
+  const move = (direction) => {
+    const root = ctx.rootRef.current;
+    if (!root) return;
+    const triggers = Array.from(
+      root.querySelectorAll('[data-accordion-trigger="true"]')
+    ).filter((el) => !el.disabled);
+    if (triggers.length === 0) return;
+    let nextIdx;
+    if (direction === "first") nextIdx = 0;
+    else if (direction === "last") nextIdx = triggers.length - 1;
+    else {
+      const idx = triggers.findIndex((el) => el === document.activeElement);
+      const candidate = idx + direction;
+      nextIdx = (candidate + triggers.length) % triggers.length;
+    }
+    triggers[nextIdx]?.focus();
+  };
+  const handleKeyDown = (e) => {
+    onKeyDown?.(e);
+    if (e.defaultPrevented) return;
+    if (e.key === "ArrowDown") {
+      e.preventDefault();
+      move(1);
+    } else if (e.key === "ArrowUp") {
+      e.preventDefault();
+      move(-1);
+    } else if (e.key === "Home") {
+      e.preventDefault();
+      move("first");
+    } else if (e.key === "End") {
+      e.preventDefault();
+      move("last");
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "button",
+    {
+      ref,
+      type: "button",
+      id: item.triggerId,
+      "aria-expanded": item.open,
+      "aria-controls": item.contentId,
+      "aria-disabled": item.disabled || void 0,
+      disabled: item.disabled,
+      "data-state": item.open ? "open" : "closed",
+      "data-disabled": item.disabled || void 0,
+      "data-accordion-trigger": "true",
+      onClick: handleClick,
+      onKeyDown: handleKeyDown,
+      ...rest
+    }
+  );
+});
+var Content4 = react.forwardRef(function AccordionContent({ forceMount, hidden, children, ...rest }, ref) {
+  const item = useItemContext("Content");
+  if (!item.open && !forceMount) return null;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      ref,
+      role: "region",
+      id: item.contentId,
+      "aria-labelledby": item.triggerId,
+      "data-state": item.open ? "open" : "closed",
+      hidden: hidden ?? !item.open,
+      ...rest,
+      children
+    }
+  );
+});
+var Accordion2 = Object.assign(Root5, { Item: Item2, Trigger: Trigger5, Content: Content4 });
+var FOCUSABLE_SELECTOR = [
+  "a[href]",
+  "button:not([disabled])",
+  "input:not([disabled])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  '[tabindex]:not([tabindex="-1"])'
+].join(",");
+function getFocusables(root) {
+  if (!root) return [];
+  return Array.from(root.querySelectorAll(FOCUSABLE_SELECTOR)).filter(
+    (el) => !el.hasAttribute("disabled") && el.getAttribute("aria-hidden") !== "true"
+  );
+}
+var DialogContext = react.createContext(null);
+function useDialogContext(component) {
+  const ctx = react.useContext(DialogContext);
+  if (!ctx) {
+    throw new Error(`<Dialog.${component}> must be rendered inside <Dialog>`);
+  }
+  return ctx;
+}
+var Root6 = ({
+  children,
+  open: controlled,
+  defaultOpen = false,
+  onOpenChange,
+  modal = true
+}) => {
+  const isControlled = controlled !== void 0;
+  const [uncontrolled, setUncontrolled] = react.useState(defaultOpen);
+  const open = isControlled ? controlled : uncontrolled;
+  const triggerRef = react.useRef(null);
+  const contentRef = react.useRef(null);
+  const [hasTitle, setHasTitle] = react.useState(false);
+  const [hasDescription, setHasDescription] = react.useState(false);
+  const reactId = react.useId();
+  const contentId2 = `${reactId}content`;
+  const titleId = `${reactId}title`;
+  const descriptionId = `${reactId}description`;
+  const setOpen = react.useCallback(
+    (next) => {
+      if (!isControlled) setUncontrolled(next);
+      onOpenChange?.(next);
+    },
+    [isControlled, onOpenChange]
+  );
+  const ctx = react.useMemo(
+    () => ({
+      open,
+      setOpen,
+      triggerRef,
+      contentRef,
+      contentId: contentId2,
+      titleId,
+      descriptionId,
+      hasTitle,
+      setHasTitle,
+      hasDescription,
+      setHasDescription,
+      modal
+    }),
+    [open, setOpen, contentId2, titleId, descriptionId, hasTitle, hasDescription, modal]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(DialogContext.Provider, { value: ctx, children });
+};
+var Trigger6 = react.forwardRef(function DialogTrigger({ onClick, ...rest }, forwardedRef) {
+  const ctx = useDialogContext("Trigger");
+  const setRefs = (node) => {
+    ctx.triggerRef.current = node;
+    if (typeof forwardedRef === "function") forwardedRef(node);
+    else if (forwardedRef) forwardedRef.current = node;
+  };
+  const handleClick = (e) => {
+    onClick?.(e);
+    if (e.defaultPrevented) return;
+    ctx.setOpen(true);
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "button",
+    {
+      ref: setRefs,
+      type: "button",
+      "aria-haspopup": "dialog",
+      "aria-expanded": ctx.open,
+      "aria-controls": ctx.open ? ctx.contentId : void 0,
+      "data-state": ctx.open ? "open" : "closed",
+      onClick: handleClick,
+      ...rest
+    }
+  );
+});
+var Overlay = react.forwardRef(function DialogOverlay({ forceMount, onClick, ...rest }, ref) {
+  const ctx = useDialogContext("Overlay");
+  if (!ctx.open && !forceMount) return null;
+  const handleClick = (e) => {
+    onClick?.(e);
+    if (e.defaultPrevented || !ctx.modal) return;
+    if (e.target === e.currentTarget) {
+      ctx.setOpen(false);
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { ref, "data-state": ctx.open ? "open" : "closed", onClick: handleClick, ...rest });
+});
+var Content5 = react.forwardRef(function DialogContent({ forceMount, onEscapeKeyDown, onKeyDown, children, ...rest }, forwardedRef) {
+  const ctx = useDialogContext("Content");
+  const setRefs = (node) => {
+    ctx.contentRef.current = node;
+    if (typeof forwardedRef === "function") forwardedRef(node);
+    else if (forwardedRef) forwardedRef.current = node;
+  };
+  react.useEffect(() => {
+    if (!ctx.open) return;
+    const previouslyFocused = document.activeElement;
+    const id = requestAnimationFrame(() => {
+      const root = ctx.contentRef.current;
+      if (!root) return;
+      const focusables = getFocusables(root);
+      const target = focusables[0] ?? root;
+      target.focus();
+    });
+    return () => {
+      cancelAnimationFrame(id);
+      const trigger = ctx.triggerRef.current;
+      (trigger ?? previouslyFocused)?.focus?.();
+    };
+  }, [ctx.open, ctx.contentRef, ctx.triggerRef]);
+  react.useEffect(() => {
+    if (!ctx.open || !ctx.modal) return;
+    const prev = document.body.style.overflow;
+    document.body.style.overflow = "hidden";
+    return () => {
+      document.body.style.overflow = prev;
+    };
+  }, [ctx.open, ctx.modal]);
+  const { open: ctxOpen, setOpen: ctxSetOpen } = ctx;
+  react.useEffect(() => {
+    if (!ctxOpen) return;
+    const onKey = (e) => {
+      if (e.key !== "Escape") return;
+      onEscapeKeyDown?.(e);
+      if (e.defaultPrevented) return;
+      ctxSetOpen(false);
+    };
+    document.addEventListener("keydown", onKey);
+    return () => document.removeEventListener("keydown", onKey);
+  }, [ctxOpen, ctxSetOpen, onEscapeKeyDown]);
+  if (!ctx.open && !forceMount) return null;
+  const handleKeyDown = (e) => {
+    onKeyDown?.(e);
+    if (e.defaultPrevented) return;
+    if (e.key !== "Tab" || !ctx.modal) return;
+    const focusables = getFocusables(ctx.contentRef.current);
+    if (focusables.length === 0) {
+      e.preventDefault();
+      return;
+    }
+    const first = focusables[0];
+    const last = focusables[focusables.length - 1];
+    const active = document.activeElement;
+    if (e.shiftKey && (active === first || !ctx.contentRef.current?.contains(active))) {
+      e.preventDefault();
+      last.focus();
+    } else if (!e.shiftKey && active === last) {
+      e.preventDefault();
+      first.focus();
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      ref: setRefs,
+      role: "dialog",
+      "aria-modal": ctx.modal || void 0,
+      id: ctx.contentId,
+      "aria-labelledby": ctx.hasTitle ? ctx.titleId : void 0,
+      "aria-describedby": ctx.hasDescription ? ctx.descriptionId : void 0,
+      tabIndex: -1,
+      "data-state": ctx.open ? "open" : "closed",
+      onKeyDown: handleKeyDown,
+      ...rest,
+      children
+    }
+  );
+});
+var Title = react.forwardRef(function DialogTitle(props, ref) {
+  const ctx = useDialogContext("Title");
+  react.useEffect(() => {
+    ctx.setHasTitle(true);
+    return () => ctx.setHasTitle(false);
+  }, [ctx]);
+  return /* @__PURE__ */ jsxRuntime.jsx("h2", { ref, id: ctx.titleId, ...props });
+});
+var Description = react.forwardRef(
+  function DialogDescription(props, ref) {
+    const ctx = useDialogContext("Description");
+    react.useEffect(() => {
+      ctx.setHasDescription(true);
+      return () => ctx.setHasDescription(false);
+    }, [ctx]);
+    return /* @__PURE__ */ jsxRuntime.jsx("p", { ref, id: ctx.descriptionId, ...props });
+  }
+);
+var Close = react.forwardRef(function DialogClose({ onClick, ...rest }, ref) {
+  const ctx = useDialogContext("Close");
+  const handleClick = (e) => {
+    onClick?.(e);
+    if (e.defaultPrevented) return;
+    ctx.setOpen(false);
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx("button", { ref, type: "button", onClick: handleClick, ...rest });
+});
+var Dialog = Object.assign(Root6, {
+  Trigger: Trigger6,
+  Overlay,
+  Content: Content5,
+  Title,
+  Description,
+  Close
+});
 
+exports.Accordion = Accordion2;
+exports.Checkbox = Checkbox;
+exports.Dialog = Dialog;
+exports.RadioGroup = RadioGroup2;
 exports.Select = Select;
+exports.Switch = Switch;
+exports.Tabs = Tabs2;
+exports.Tooltip = Tooltip;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map