@ark-ui/solid 4.1.0 → 4.2.1

package/dist/chunk/YKYATBPX.js

@@ -0,0 +1,179 @@
+import { createSplitProps } from './ZMHI4GDJ.js';
+import { ark } from './EPLBB4QN.js';
+import { useLocaleContext } from './HPDOBQ3V.js';
+import { useEnvironmentContext } from './QODB3C3M.js';
+import { createContext } from './I5UG2QUO.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 { createMemo, createUniqueId } from 'solid-js';
+import * as steps from '@zag-js/steps';
+export { anatomy } from '@zag-js/steps';
+
+// src/components/steps/use-steps-context.ts
+var [StepsProvider, useStepsContext] = createContext({
+  hookName: "useStepsContext",
+  providerName: "<StepsProvider />"
+});
+
+// src/components/steps/steps-completed-content.tsx
+var StepsCompletedContent = (props) => {
+  const steps2 = useStepsContext();
+  const mergedProps = mergeProps(() => steps2().getContentProps({
+    index: steps2().count
+  }), props);
+  return createComponent(ark.div, mergedProps);
+};
+var StepsContent = (props) => {
+  const [itemProps, localProps] = createSplitProps()(props, ["index"]);
+  const steps2 = useStepsContext();
+  const mergedProps = mergeProps(() => steps2().getContentProps(itemProps), localProps);
+  return createComponent(ark.div, mergedProps);
+};
+
+// src/components/steps/steps-context.tsx
+var StepsContext = (props) => {
+  const context = useStepsContext();
+  return props.children(context);
+};
+
+// src/components/steps/use-steps-item-props-context.ts
+var [StepsItemPropsProvider, useStepsItemPropsContext] = createContext({
+  hookName: "useStepsItemPropsContext",
+  providerName: "<StepsItemPropsProvider />"
+});
+
+// src/components/steps/steps-indicator.tsx
+var StepsIndicator = (props) => {
+  const steps2 = useStepsContext();
+  const itemProps = useStepsItemPropsContext();
+  const mergedProps = mergeProps(() => steps2().getIndicatorProps(itemProps), props);
+  return createComponent(ark.div, mergedProps);
+};
+
+// src/components/steps/use-steps-item-context.ts
+var [StepsItemProvider, useStepsItemContext] = createContext({
+  hookName: "useStepsItemContext",
+  providerName: "<StepsItem />"
+});
+
+// src/components/steps/steps-item.tsx
+var StepsItem = (props) => {
+  const [itemProps, localProps] = createSplitProps()(props, ["index"]);
+  const steps2 = useStepsContext();
+  const mergedProps = mergeProps(() => steps2().getItemProps(itemProps), localProps);
+  const itemState = createMemo(() => steps2().getItemState(itemProps));
+  return createComponent(StepsItemPropsProvider, {
+    value: itemProps,
+    get children() {
+      return createComponent(StepsItemProvider, {
+        value: itemState,
+        get children() {
+          return createComponent(ark.li, mergedProps);
+        }
+      });
+    }
+  });
+};
+
+// src/components/steps/steps-item-context.tsx
+var StepsItemContext = (props) => {
+  return props.children(useStepsItemContext());
+};
+StepsItemContext.displayName = "StepsItemContext";
+var StepsList = (props) => {
+  const steps2 = useStepsContext();
+  const mergedProps = mergeProps(() => steps2().getListProps(), props);
+  return createComponent(ark.ol, mergedProps);
+};
+var StepsNextTrigger = (props) => {
+  const steps2 = useStepsContext();
+  const mergedProps = mergeProps(() => steps2().getNextTriggerProps(), props);
+  return createComponent(ark.button, mergedProps);
+};
+var StepsPrevTrigger = (props) => {
+  const steps2 = useStepsContext();
+  const mergedProps = mergeProps(() => steps2().getPrevTriggerProps(), props);
+  return createComponent(ark.button, mergedProps);
+};
+var StepsProgress = (props) => {
+  const steps2 = useStepsContext();
+  const mergedProps = mergeProps(() => steps2().getProgressProps(), props);
+  return createComponent(ark.div, mergedProps);
+};
+function useSteps(props = {}) {
+  const environment = useEnvironmentContext();
+  const locale = useLocaleContext();
+  const id = createUniqueId();
+  const context = createMemo(() => ({
+    id,
+    dir: locale().dir,
+    getRootNode: environment().getRootNode,
+    step: props.defaultStep,
+    ...props
+  }));
+  const [state, send] = useMachine(steps.machine(context()), { context });
+  return createMemo(() => steps.connect(state, send, normalizeProps));
+}
+
+// src/components/steps/steps-root.tsx
+var StepsRoot = (props) => {
+  const [useStepsProps, localProps] = createSplitProps()(props, ["defaultStep", "id", "ids", "count", "linear", "onStepChange", "onStepComplete", "orientation", "step"]);
+  const steps2 = useSteps(useStepsProps);
+  const mergedProps = mergeProps(() => steps2().getRootProps(), localProps);
+  return createComponent(StepsProvider, {
+    value: steps2,
+    get children() {
+      return createComponent(ark.div, mergedProps);
+    }
+  });
+};
+var StepsRootProvider = (props) => {
+  const [{
+    value: steps2
+  }, rootProps] = createSplitProps()(props, ["value"]);
+  const mergedProps = mergeProps(() => steps2().getRootProps(), rootProps);
+  return createComponent(StepsProvider, {
+    value: steps2,
+    get children() {
+      return createComponent(ark.div, mergeProps$1(mergedProps, {
+        get children() {
+          return props.children;
+        }
+      }));
+    }
+  });
+};
+var StepsSeparator = (props) => {
+  const steps2 = useStepsContext();
+  const itemProps = useStepsItemPropsContext();
+  const mergedProps = mergeProps(() => steps2().getSeparatorProps(itemProps), props);
+  return createComponent(ark.div, mergedProps);
+};
+var StepsTrigger = (props) => {
+  const steps2 = useStepsContext();
+  const itemProps = useStepsItemPropsContext();
+  const mergedProps = mergeProps(() => steps2().getTriggerProps(itemProps), props);
+  return createComponent(ark.button, mergedProps);
+};
+
+// src/components/steps/steps.ts
+var steps_exports = {};
+__export(steps_exports, {
+  CompletedContent: () => StepsCompletedContent,
+  Content: () => StepsContent,
+  Context: () => StepsContext,
+  Indicator: () => StepsIndicator,
+  Item: () => StepsItem,
+  ItemContext: () => StepsItemContext,
+  List: () => StepsList,
+  NextTrigger: () => StepsNextTrigger,
+  PrevTrigger: () => StepsPrevTrigger,
+  Progress: () => StepsProgress,
+  Root: () => StepsRoot,
+  RootProvider: () => StepsRootProvider,
+  Separator: () => StepsSeparator,
+  Trigger: () => StepsTrigger
+});
+
+export { StepsCompletedContent, StepsContent, StepsContext, StepsIndicator, StepsItem, StepsItemContext, StepsList, StepsNextTrigger, StepsPrevTrigger, StepsProgress, StepsRoot, StepsRootProvider, StepsSeparator, StepsTrigger, steps_exports, useSteps, useStepsContext, useStepsItemContext };

package/dist/chunk/YQYOROY7.jsx

@@ -0,0 +1,250 @@
+import {
+  useControllableState
+} from "./52WUF3CY.jsx";
+import {
+  useFieldContext
+} from "./YJ7NNN57.jsx";
+import {
+  createSplitProps
+} from "./6WEDGJKQ.jsx";
+import {
+  ark
+} from "./UFYZ7HLU.jsx";
+import {
+  useLocaleContext
+} from "./3QQZKR3F.jsx";
+import {
+  useEnvironmentContext
+} from "./5O4RWSWO.jsx";
+import {
+  createContext
+} from "./NMGUCD2L.jsx";
+import {
+  __export
+} from "./7IUG3E2V.jsx";
+
+// src/components/checkbox/use-checkbox-context.ts
+var [CheckboxProvider, useCheckboxContext] = createContext({
+  hookName: "useCheckboxContext",
+  providerName: "<CheckboxProvider />"
+});
+
+// src/components/checkbox/checkbox-context.tsx
+var CheckboxContext = (props) => props.children(useCheckboxContext());
+
+// src/components/checkbox/checkbox-control.tsx
+import { mergeProps } from "@zag-js/solid";
+var CheckboxControl = (props) => {
+  const checkbox2 = useCheckboxContext();
+  const mergedProps = mergeProps(() => checkbox2().getControlProps(), props);
+  return <ark.div {...mergedProps} />;
+};
+
+// src/components/checkbox/checkbox.anatomy.ts
+import { anatomy } from "@zag-js/checkbox";
+var checkboxAnatomy = anatomy.extendWith("group");
+
+// src/components/checkbox/use-checkbox-group.ts
+import { createMemo } from "solid-js";
+function useCheckboxGroup(props = {}) {
+  const interative = createMemo(() => !(props.disabled || props.readOnly));
+  const [value, setValue] = useControllableState({
+    value: props.value,
+    defaultValue: props.defaultValue || [],
+    onChange: props.onValueChange
+  });
+  return createMemo(() => {
+    const isChecked = (val) => {
+      return value().some((v) => String(v) === String(val));
+    };
+    const toggleValue = (val) => {
+      isChecked(val) ? removeValue(val) : addValue(val);
+    };
+    const addValue = (val) => {
+      if (!interative()) return;
+      if (isChecked(val)) return;
+      setValue(value().concat(val));
+    };
+    const removeValue = (val) => {
+      if (!interative()) return;
+      setValue(value().filter((v) => String(v) !== String(val)));
+    };
+    const getItemProps = (itemProps) => {
+      return {
+        checked: itemProps.value != null ? isChecked(itemProps.value) : void 0,
+        onCheckedChange() {
+          if (itemProps.value != null) {
+            toggleValue(itemProps.value);
+          }
+        },
+        name: props.name,
+        disabled: props.disabled,
+        readOnly: props.readOnly,
+        invalid: props.invalid
+      };
+    };
+    return {
+      isChecked,
+      value,
+      name: props.name,
+      disabled: props.disabled,
+      readOnly: props.readOnly,
+      invalid: props.invalid,
+      setValue,
+      addValue,
+      toggleValue,
+      getItemProps
+    };
+  });
+}
+
+// src/components/checkbox/use-checkbox-group-context.tsx
+var [CheckboxGroupContextProvider, useCheckboxGroupContext] = createContext({
+  hookName: "useCheckboxGroupContext",
+  providerName: "<CheckboxGroupProvider />",
+  strict: false
+});
+
+// src/components/checkbox/checkbox-group.tsx
+var CheckboxGroup = (props) => {
+  const [checkboxGroupProps, localProps] = createSplitProps()(props, [
+    "defaultValue",
+    "value",
+    "onValueChange",
+    "disabled",
+    "invalid",
+    "readOnly",
+    "name"
+  ]);
+  const checkboxGroup = useCheckboxGroup(checkboxGroupProps);
+  return <CheckboxGroupContextProvider value={checkboxGroup}>
+      <ark.div role="group" {...localProps} {...checkboxAnatomy.build().group.attrs} />
+    </CheckboxGroupContextProvider>;
+};
+
+// src/components/checkbox/checkbox-hidden-input.tsx
+import { mergeProps as mergeProps2 } from "@zag-js/solid";
+var CheckboxHiddenInput = (props) => {
+  const checkbox2 = useCheckboxContext();
+  const mergedProps = mergeProps2(() => checkbox2().getHiddenInputProps(), props);
+  const field = useFieldContext();
+  return <ark.input aria-describedby={field?.().ariaDescribedby} {...mergedProps} />;
+};
+
+// src/components/checkbox/checkbox-indicator.tsx
+import { mergeProps as mergeProps3 } from "@zag-js/solid";
+var CheckboxIndicator = (props) => {
+  const [indicatorProps, localProps] = createSplitProps()(props, ["indeterminate"]);
+  const checkbox2 = useCheckboxContext();
+  const mergedProps = mergeProps3(() => checkbox2().getIndicatorProps(), localProps);
+  return <ark.div
+    {...mergedProps}
+    hidden={!(indicatorProps.indeterminate ? checkbox2().indeterminate : checkbox2().checked)}
+  />;
+};
+
+// src/components/checkbox/checkbox-label.tsx
+import { mergeProps as mergeProps4 } from "@zag-js/solid";
+var CheckboxLabel = (props) => {
+  const checkbox2 = useCheckboxContext();
+  const mergedProps = mergeProps4(() => checkbox2().getLabelProps(), props);
+  return <ark.span {...mergedProps} />;
+};
+
+// src/components/checkbox/checkbox-root.tsx
+import { mergeProps as mergeProps6 } from "@zag-js/solid";
+
+// src/components/checkbox/use-checkbox.ts
+import * as checkbox from "@zag-js/checkbox";
+import { mergeProps as mergeProps5, normalizeProps, useMachine } from "@zag-js/solid";
+import { createMemo as createMemo2, createUniqueId } from "solid-js";
+var useCheckbox = (ownProps) => {
+  const checkboxGroup = useCheckboxGroupContext();
+  const props = createMemo2(() => {
+    return mergeProps5(ownProps, checkboxGroup?.().getItemProps({ value: ownProps.value }) ?? {});
+  }, [ownProps, checkboxGroup]);
+  const locale = useLocaleContext();
+  const environment = useEnvironmentContext();
+  const id = createUniqueId();
+  const field = useFieldContext();
+  const context = createMemo2(() => ({
+    id,
+    ids: {
+      label: field?.().ids.label,
+      hiddenInput: field?.().ids.control
+    },
+    disabled: field?.().disabled,
+    readOnly: field?.().readOnly,
+    invalid: field?.().invalid,
+    required: field?.().required,
+    dir: locale().dir,
+    getRootNode: environment().getRootNode,
+    checked: props().defaultChecked,
+    ...props()
+  }));
+  const [state, send] = useMachine(checkbox.machine(context()), { context });
+  return createMemo2(() => checkbox.connect(state, send, normalizeProps));
+};
+
+// src/components/checkbox/checkbox-root.tsx
+var CheckboxRoot = (props) => {
+  const [useCheckboxProps, labelprops] = createSplitProps()(props, [
+    "checked",
+    "defaultChecked",
+    "disabled",
+    "form",
+    "id",
+    "ids",
+    "invalid",
+    "name",
+    "onCheckedChange",
+    "readOnly",
+    "required",
+    "value"
+  ]);
+  const checkbox2 = useCheckbox(useCheckboxProps);
+  const mergedProps = mergeProps6(() => checkbox2().getRootProps(), labelprops);
+  return <CheckboxProvider value={checkbox2}>
+      <ark.label {...mergedProps} />
+    </CheckboxProvider>;
+};
+
+// src/components/checkbox/checkbox-root-provider.tsx
+import { mergeProps as mergeProps7 } from "@zag-js/solid";
+var CheckboxRootProvider = (props) => {
+  const [{ value: checkbox2 }, labelprops] = createSplitProps()(props, ["value"]);
+  const mergedProps = mergeProps7(() => checkbox2().getRootProps(), labelprops);
+  return <CheckboxProvider value={checkbox2}>
+      <ark.label {...mergedProps} />
+    </CheckboxProvider>;
+};
+
+// src/components/checkbox/checkbox.ts
+var checkbox_exports = {};
+__export(checkbox_exports, {
+  Context: () => CheckboxContext,
+  Control: () => CheckboxControl,
+  Group: () => CheckboxGroup,
+  HiddenInput: () => CheckboxHiddenInput,
+  Indicator: () => CheckboxIndicator,
+  Label: () => CheckboxLabel,
+  Root: () => CheckboxRoot,
+  RootProvider: () => CheckboxRootProvider
+});
+
+export {
+  useCheckboxContext,
+  CheckboxContext,
+  CheckboxControl,
+  checkboxAnatomy,
+  useCheckboxGroup,
+  useCheckboxGroupContext,
+  CheckboxGroup,
+  CheckboxHiddenInput,
+  CheckboxIndicator,
+  CheckboxLabel,
+  useCheckbox,
+  CheckboxRoot,
+  CheckboxRootProvider,
+  checkbox_exports
+};

package/dist/chunk/ZMHI4GDJ.js

@@ -0,0 +1,6 @@
+import { splitProps } from 'solid-js';
+
+// src/utils/create-split-props.ts
+var createSplitProps = () => (props, keys) => splitProps(props, keys);
+
+export { createSplitProps };

package/dist/chunk/ZTGL23QZ.js

@@ -0,0 +1,144 @@
+import { createSplitProps } from './ZMHI4GDJ.js';
+import { ark } from './EPLBB4QN.js';
+import { useLocaleContext } from './HPDOBQ3V.js';
+import { useEnvironmentContext } from './QODB3C3M.js';
+import { createContext } from './I5UG2QUO.js';
+import { __export } from './ESLJRKWD.js';
+import { createComponent } from 'solid-js/web';
+import { mergeProps, useMachine, normalizeProps } from '@zag-js/solid';
+import * as segmentGroup from '@zag-js/radio-group';
+import { anatomy } from '@zag-js/radio-group';
+import { createMemo, createUniqueId } from 'solid-js';
+
+// src/components/segment-group/use-segment-group-context.ts
+var [SegmentGroupProvider, useSegmentGroupContext] = createContext(
+  {
+    hookName: "useSegmentGroupContext",
+    providerName: "<SegmentGroupProvider />"
+  }
+);
+
+// src/components/segment-group/segment-group-context.tsx
+var SegmentGroupContext = (props) => props.children(useSegmentGroupContext());
+var segmentGroupAnatomy = anatomy.rename("segment-group");
+var parts = segmentGroupAnatomy.build();
+
+// src/components/segment-group/segment-group-indicator.tsx
+var SegmentGroupIndicator = (props) => {
+  const segmentGroup2 = useSegmentGroupContext();
+  const mergedProps = mergeProps(() => segmentGroup2().getIndicatorProps(), parts.indicator.attrs, props);
+  return createComponent(ark.div, mergedProps);
+};
+
+// src/components/segment-group/use-segment-group-item-context.ts
+var [SegmentGroupItemProvider, useSegmentGroupItemContext] = createContext({
+  hookName: "useSegmentGroupItemContext",
+  providerName: "<SegmentGroupItemProvider />"
+});
+
+// src/components/segment-group/use-segment-group-item-props-context.ts
+var [SegmentGroupItemPropsProvider, useSegmentGroupItemPropsContext] = createContext({
+  hookName: "useSegmentGroupItemPropsContext",
+  providerName: "<SegmentGroupItemPropsProvider />"
+});
+
+// src/components/segment-group/segment-group-item.tsx
+var SegmentGroupItem = (props) => {
+  const [itemProps, localProps] = createSplitProps()(props, ["value", "disabled", "invalid"]);
+  const segmentGroup2 = useSegmentGroupContext();
+  const mergedProps = mergeProps(() => segmentGroup2().getItemProps(itemProps), parts.item.attrs, localProps);
+  const itemState = createMemo(() => segmentGroup2().getItemState(itemProps));
+  return createComponent(SegmentGroupItemPropsProvider, {
+    value: itemProps,
+    get children() {
+      return createComponent(SegmentGroupItemProvider, {
+        value: itemState,
+        get children() {
+          return createComponent(ark.label, mergedProps);
+        }
+      });
+    }
+  });
+};
+
+// src/components/segment-group/segment-group-item-context.tsx
+var SegmentGroupItemContext = (props) => props.children(useSegmentGroupItemContext());
+var SegmentGroupItemControl = (props) => {
+  const segmentGroup2 = useSegmentGroupContext();
+  const itemProps = useSegmentGroupItemPropsContext();
+  const mergedProps = mergeProps(() => segmentGroup2().getItemControlProps(itemProps), parts.itemControl.attrs, props);
+  return createComponent(ark.div, mergedProps);
+};
+var SegmentGroupItemHiddenInput = (props) => {
+  const segmentGroup2 = useSegmentGroupContext();
+  const itemProps = useSegmentGroupItemPropsContext();
+  const mergedProps = mergeProps(() => segmentGroup2().getItemHiddenInputProps(itemProps), props);
+  return createComponent(ark.input, mergedProps);
+};
+var SegmentGroupItemText = (props) => {
+  const segmentGroup2 = useSegmentGroupContext();
+  const itemProps = useSegmentGroupItemPropsContext();
+  const mergedProps = mergeProps(() => segmentGroup2().getItemTextProps(itemProps), parts.itemText.attrs, props);
+  return createComponent(ark.span, mergedProps);
+};
+var SegmentGroupLabel = (props) => {
+  const segmentGroup2 = useSegmentGroupContext();
+  const mergedProps = mergeProps(() => segmentGroup2().getLabelProps(), parts.label.attrs, props);
+  return createComponent(ark.label, mergedProps);
+};
+var useSegmentGroup = (props) => {
+  const locale = useLocaleContext();
+  const environment = useEnvironmentContext();
+  const id = createUniqueId();
+  const context = createMemo(() => ({
+    id,
+    dir: locale().dir,
+    getRootNode: environment().getRootNode,
+    value: props.defaultValue,
+    ...props
+  }));
+  const [state, send] = useMachine(segmentGroup.machine(context()), { context });
+  return createMemo(() => segmentGroup.connect(state, send, normalizeProps));
+};
+
+// src/components/segment-group/segment-group-root.tsx
+var SegmentGroupRoot = (props) => {
+  const [useSegmentGroupProps, localProps] = createSplitProps()(props, ["defaultValue", "disabled", "form", "id", "ids", "name", "onValueChange", "orientation", "readOnly", "value"]);
+  const segmentGroup2 = useSegmentGroup(useSegmentGroupProps);
+  const mergedProps = mergeProps(() => segmentGroup2().getRootProps(), parts.root.attrs, localProps);
+  return createComponent(SegmentGroupProvider, {
+    value: segmentGroup2,
+    get children() {
+      return createComponent(ark.div, mergedProps);
+    }
+  });
+};
+var SegmentGroupRootProvider = (props) => {
+  const [{
+    value: segmentGroup2
+  }, localProps] = createSplitProps()(props, ["value"]);
+  const mergedProps = mergeProps(() => segmentGroup2().getRootProps(), parts.root.attrs, localProps);
+  return createComponent(SegmentGroupProvider, {
+    value: segmentGroup2,
+    get children() {
+      return createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+// src/components/segment-group/segment-group.ts
+var segment_group_exports = {};
+__export(segment_group_exports, {
+  Context: () => SegmentGroupContext,
+  Indicator: () => SegmentGroupIndicator,
+  Item: () => SegmentGroupItem,
+  ItemContext: () => SegmentGroupItemContext,
+  ItemControl: () => SegmentGroupItemControl,
+  ItemHiddenInput: () => SegmentGroupItemHiddenInput,
+  ItemText: () => SegmentGroupItemText,
+  Label: () => SegmentGroupLabel,
+  Root: () => SegmentGroupRoot,
+  RootProvider: () => SegmentGroupRootProvider
+});
+
+export { SegmentGroupContext, SegmentGroupIndicator, SegmentGroupItem, SegmentGroupItemContext, SegmentGroupItemControl, SegmentGroupItemHiddenInput, SegmentGroupItemText, SegmentGroupLabel, SegmentGroupRoot, SegmentGroupRootProvider, segmentGroupAnatomy, segment_group_exports, useSegmentGroup, useSegmentGroupContext, useSegmentGroupItemContext };

package/dist/components/accordion/index.d.ts

@@ -0,0 +1,85 @@
+import * as accordion$1 from '@zag-js/accordion';
+import { ItemProps, ItemState, FocusChangeDetails, ValueChangeDetails } from '@zag-js/accordion';
+export { FocusChangeDetails as AccordionFocusChangeDetails, ValueChangeDetails as AccordionValueChangeDetails, anatomy as accordionAnatomy } from '@zag-js/accordion';
+import * as solid_js from 'solid-js';
+import { Accessor, JSX } from 'solid-js';
+import { PropTypes } from '@zag-js/solid';
+import { O as Optional } from '../../types-B277wCdv.js';
+import { PolymorphicProps, HTMLProps } from '../factory.js';
+import { R as RenderStrategyProps } from '../../render-strategy-B5MqQP3X.js';
+
+interface UseAccordionProps extends Optional<Omit<accordion$1.Context, 'dir' | 'getRootNode'>, 'id'> {
+    /**
+     * The initial value of the accordion when it is first rendered.
+     * Use when you do not need to control the state of the color picker.
+     */
+    defaultValue?: accordion$1.Context['value'];
+}
+interface UseAccordionReturn extends Accessor<accordion$1.Api<PropTypes>> {
+}
+declare const useAccordion: (props: UseAccordionProps) => UseAccordionReturn;
+
+interface UseAccordionContext extends UseAccordionReturn {
+}
+declare const useAccordionContext: () => UseAccordionContext;
+
+interface AccordionContextProps {
+    children: (context: UseAccordionContext) => JSX.Element;
+}
+declare const AccordionContext: (props: AccordionContextProps) => JSX.Element;
+
+interface AccordionItemBaseProps extends ItemProps, PolymorphicProps<'div'> {
+}
+interface AccordionItemProps extends HTMLProps<'div'>, AccordionItemBaseProps {
+}
+declare const AccordionItem: (props: AccordionItemProps) => solid_js.JSX.Element;
+
+interface AccordionItemContentBaseProps extends PolymorphicProps<'div'> {
+}
+interface AccordionItemContentProps extends HTMLProps<'div'>, AccordionItemContentBaseProps {
+}
+declare const AccordionItemContent: (props: AccordionItemContentProps) => solid_js.JSX.Element;
+
+interface UseAccordionItemContext extends Accessor<ItemState> {
+}
+declare const useAccordionItemContext: () => UseAccordionItemContext;
+
+interface AccordionItemContextProps {
+    children: (context: UseAccordionItemContext) => JSX.Element;
+}
+declare const AccordionItemContext: (props: AccordionItemContextProps) => JSX.Element;
+
+interface AccordionItemIndicatorBaseProps extends PolymorphicProps<'div'> {
+}
+interface AccordionItemIndicatorProps extends HTMLProps<'div'>, AccordionItemIndicatorBaseProps {
+}
+declare const AccordionItemIndicator: (props: AccordionItemIndicatorProps) => solid_js.JSX.Element;
+
+interface AccordionItemTriggerBaseProps extends PolymorphicProps<'button'> {
+}
+interface AccordionItemTriggerProps extends HTMLProps<'button'>, AccordionItemTriggerBaseProps {
+}
+declare const AccordionItemTrigger: (props: AccordionItemTriggerProps) => solid_js.JSX.Element;
+
+interface AccordionRootBaseProps extends UseAccordionProps, RenderStrategyProps, PolymorphicProps<'div'> {
+}
+interface AccordionRootProps extends HTMLProps<'div'>, AccordionRootBaseProps {
+}
+declare const AccordionRoot: (props: AccordionRootProps) => solid_js.JSX.Element;
+
+interface RootProviderProps {
+    value: UseAccordionReturn;
+}
+interface AccordionRootProviderBaseProps extends RootProviderProps, RenderStrategyProps, PolymorphicProps<'div'> {
+}
+interface AccordionRootProviderProps extends HTMLProps<'div'>, AccordionRootProviderBaseProps {
+}
+declare const AccordionRootProvider: (props: AccordionRootProviderProps) => solid_js.JSX.Element;
+
+declare const accordion_FocusChangeDetails: typeof FocusChangeDetails;
+declare const accordion_ValueChangeDetails: typeof ValueChangeDetails;
+declare namespace accordion {
+  export { AccordionContext as Context, type AccordionContextProps as ContextProps, accordion_FocusChangeDetails as FocusChangeDetails, AccordionItem as Item, type AccordionItemBaseProps as ItemBaseProps, AccordionItemContent as ItemContent, type AccordionItemContentBaseProps as ItemContentBaseProps, type AccordionItemContentProps as ItemContentProps, AccordionItemContext as ItemContext, type AccordionItemContextProps as ItemContextProps, AccordionItemIndicator as ItemIndicator, type AccordionItemIndicatorBaseProps as ItemIndicatorBaseProps, type AccordionItemIndicatorProps as ItemIndicatorProps, type AccordionItemProps as ItemProps, AccordionItemTrigger as ItemTrigger, type AccordionItemTriggerBaseProps as ItemTriggerBaseProps, type AccordionItemTriggerProps as ItemTriggerProps, AccordionRoot as Root, type AccordionRootBaseProps as RootBaseProps, type AccordionRootProps as RootProps, AccordionRootProvider as RootProvider, type AccordionRootProviderBaseProps as RootProviderBaseProps, type AccordionRootProviderProps as RootProviderProps, accordion_ValueChangeDetails as ValueChangeDetails };
+}
+
+export { accordion as Accordion, AccordionContext, type AccordionContextProps, AccordionItem, type AccordionItemBaseProps, AccordionItemContent, type AccordionItemContentBaseProps, type AccordionItemContentProps, AccordionItemContext, type AccordionItemContextProps, AccordionItemIndicator, type AccordionItemIndicatorBaseProps, type AccordionItemIndicatorProps, type AccordionItemProps, AccordionItemTrigger, type AccordionItemTriggerBaseProps, type AccordionItemTriggerProps, AccordionRoot, type AccordionRootBaseProps, type AccordionRootProps, AccordionRootProvider, type AccordionRootProviderBaseProps, type AccordionRootProviderProps, type UseAccordionContext, type UseAccordionItemContext, type UseAccordionProps, type UseAccordionReturn, useAccordion, useAccordionContext, useAccordionItemContext };

package/dist/components/accordion/index.js

@@ -0,0 +1 @@
+export { accordion_exports as Accordion, AccordionContext, AccordionItem, AccordionItemContent, AccordionItemContext, AccordionItemIndicator, AccordionItemTrigger, AccordionRoot, AccordionRootProvider, anatomy as accordionAnatomy, useAccordion, useAccordionContext, useAccordionItemContext } from '../../chunk/KWJ6UCDT.js';