@ark-ui/solid/dist/chunk/VL4J24YY.js

A collection of unstyled, accessible UI components for Solid, utilizing state machines for seamless interaction.

import { useCollapsibleContext, collapsible_exports } from './ROUJC6XC.js';
import { splitRenderStrategyProps, RenderStrategyProvider, useRenderStrategyContext } from './QFAL6GWC.js';
import { createSplitProps } from './ZMHI4GDJ.js';
import { ark } from './EPLBB4QN.js';
import { useEnvironmentContext } from './YO2MCGXO.js';
import { useLocaleContext } from './OKZ64GSY.js';
import { createContext } from './TROPIN4C.js';
import { runIfFn } from './DT73WLR4.js';
import { __export } from './ESLJRKWD.js';
import { createComponent, mergeProps as mergeProps$1 } from 'solid-js/web';
import { mergeProps, useMachine, normalizeProps } from '@zag-js/solid';
import { splitProps, createMemo, createUniqueId } from 'solid-js';
import * as accordion from '@zag-js/accordion';
export { anatomy } from '@zag-js/accordion';

// src/components/accordion/use-accordion-context.ts
var [AccordionProvider, useAccordionContext] = createContext({
  hookName: "useAccordionContext",
  providerName: "<AccordionProvider />"
});

// src/components/accordion/accordion-context.tsx
var AccordionContext = (props) => props.children(useAccordionContext());

// src/components/accordion/use-accordion-item-context.ts
var [AccordionItemProvider, useAccordionItemContext] = createContext({
  hookName: "useAccordionItemContext",
  providerName: "<AccordionItemProvider />"
});

// src/components/accordion/use-accordion-item-props-context.ts
var [AccordionItemPropsProvider, useAccordionItemPropsContext] = createContext({
  hookName: "useAccordionItemPropsContext",
  providerName: "<AccordionItemPropsProvider />"
});

// src/components/accordion/accordion-item.tsx
var AccordionItem = (props) => {
  const [itemProps, localProps] = createSplitProps()(props, ["value", "disabled"]);
  const accordion2 = useAccordionContext();
  const renderStrategyProps = useRenderStrategyContext();
  const mergedProps = mergeProps(() => accordion2().getItemProps(itemProps), localProps);
  const itemState = createMemo(() => accordion2().getItemState(itemProps));
  const itemContentProps = accordion2().getItemContentProps(itemProps);
  return createComponent(AccordionItemPropsProvider, {
    value: itemProps,
    get children() {
      return createComponent(AccordionItemProvider, {
        value: itemState,
        get children() {
          return createComponent(collapsible_exports.Root, mergeProps$1({
            get open() {
              return itemState().expanded;
            },
            get ids() {
              return {
                content: itemContentProps.id
              };
            }
          }, renderStrategyProps, mergedProps));
        }
      });
    }
  });
};
var splitVisibilityProps = createSplitProps();
var AccordionItemContent = (props) => {
  const accordion2 = useAccordionContext();
  const itemProps = useAccordionItemPropsContext();
  const itemContentProps = createMemo(() => {
    const contentProps = accordion2().getItemContentProps(itemProps);
    const [, ownProps] = splitVisibilityProps(contentProps, ["hidden", "data-state"]);
    return ownProps;
  });
  const mergedProps = mergeProps(() => itemContentProps(), props);
  return createComponent(collapsible_exports.Content, mergedProps);
};

// src/components/accordion/accordion-item-context.tsx
var AccordionItemContext = (props) => props.children(useAccordionItemContext());
var AccordionItemIndicator = (props) => {
  const accordion2 = useAccordionContext();
  const itemProps = useAccordionItemPropsContext();
  const mergedProps = mergeProps(() => accordion2().getItemIndicatorProps(itemProps), props);
  return createComponent(ark.div, mergedProps);
};
var AccordionItemTrigger = (props) => {
  const accordion2 = useAccordionContext();
  const itemProps = useAccordionItemPropsContext();
  const collapsible = useCollapsibleContext();
  const mergedProps = mergeProps(() => accordion2().getItemTriggerProps(itemProps), props);
  const [ariaControls, buttonProps] = splitProps(mergedProps, ["aria-controls"]);
  return createComponent(ark.button, mergeProps$1(buttonProps, () => !collapsible().unmounted && ariaControls));
};
var useAccordion = (props) => {
  const id = createUniqueId();
  const locale = useLocaleContext();
  const environment = useEnvironmentContext();
  const machineProps = createMemo(() => ({
    id,
    dir: locale().dir,
    getRootNode: environment().getRootNode,
    ...runIfFn(props)
  }));
  const service = useMachine(accordion.machine, machineProps);
  return createMemo(() => accordion.connect(service, normalizeProps));
};

// src/components/accordion/accordion-root.tsx
var AccordionRoot = (props) => {
  const [renderStrategyProps, accordionProps] = splitRenderStrategyProps(props);
  const [useAccordionProps, localProps] = createSplitProps()(accordionProps, ["collapsible", "defaultValue", "disabled", "id", "ids", "multiple", "onFocusChange", "onValueChange", "orientation", "value"]);
  const api = useAccordion(useAccordionProps);
  const mergedProps = mergeProps(() => api().getRootProps(), localProps);
  return createComponent(AccordionProvider, {
    value: api,
    get children() {
      return createComponent(RenderStrategyProvider, {
        value: renderStrategyProps,
        get children() {
          return createComponent(ark.div, mergedProps);
        }
      });
    }
  });
};
var AccordionRootProvider = (props) => {
  const [renderStrategyProps, accordionProps] = splitRenderStrategyProps(props);
  const [{
    value: accordion2
  }, localProps] = createSplitProps()(accordionProps, ["value"]);
  const mergedProps = mergeProps(() => accordion2().getRootProps(), localProps);
  return createComponent(AccordionProvider, {
    value: accordion2,
    get children() {
      return createComponent(RenderStrategyProvider, {
        value: renderStrategyProps,
        get children() {
          return createComponent(ark.div, mergedProps);
        }
      });
    }
  });
};

// src/components/accordion/accordion.ts
var accordion_exports = {};
__export(accordion_exports, {
  Context: () => AccordionContext,
  Item: () => AccordionItem,
  ItemContent: () => AccordionItemContent,
  ItemContext: () => AccordionItemContext,
  ItemIndicator: () => AccordionItemIndicator,
  ItemTrigger: () => AccordionItemTrigger,
  Root: () => AccordionRoot,
  RootProvider: () => AccordionRootProvider
});

export { AccordionContext, AccordionItem, AccordionItemContent, AccordionItemContext, AccordionItemIndicator, AccordionItemTrigger, AccordionRoot, AccordionRootProvider, accordion_exports, useAccordion, useAccordionContext, useAccordionItemContext };