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

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

import { splitPresenceProps, usePresence, PresenceProvider, usePresenceContext } from './SIT3D7TL.js';
import { useFieldContext } from './VJ2ZFW6U.js';
import { composeRefs } from './ROP6QZQ7.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, template, insert, effect } from 'solid-js/web';
import { mergeProps, useMachine, normalizeProps } from '@zag-js/solid';
import { Show, createUniqueId, createMemo, Index } from 'solid-js';
import * as select from '@zag-js/select';
export { anatomy } from '@zag-js/select';

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

// src/components/select/select-clear-trigger.tsx
var SelectClearTrigger = (props) => {
  const select2 = useSelectContext();
  const mergedProps = mergeProps(() => select2().getClearTriggerProps(), props);
  return createComponent(ark.button, mergedProps);
};
var SelectContent = (props) => {
  const select2 = useSelectContext();
  const presenceApi = usePresenceContext();
  const mergedProps = mergeProps(() => select2().getContentProps(), () => presenceApi().presenceProps, props);
  return createComponent(Show, {
    get when() {
      return !presenceApi().unmounted;
    },
    get children() {
      return createComponent(ark.div, mergeProps$1(mergedProps, {
        ref(r$) {
          var _ref$ = composeRefs(presenceApi().ref, props.ref);
          typeof _ref$ === "function" && _ref$(r$);
        }
      }));
    }
  });
};

// src/components/select/select-context.tsx
var SelectContext = (props) => props.children(useSelectContext());
var SelectControl = (props) => {
  const select2 = useSelectContext();
  const mergedProps = mergeProps(() => select2().getControlProps(), props);
  return createComponent(ark.div, mergedProps);
};
var _tmpl$ = /* @__PURE__ */ template(`<option value>`);
var _tmpl$2 = /* @__PURE__ */ template(`<option>`);
var SelectHiddenSelect = (props) => {
  const select2 = useSelectContext();
  const mergedProps = mergeProps(() => select2().getHiddenSelectProps(), props);
  const isValueEmpty = createMemo(() => select2().value.length === 0);
  const field = useFieldContext();
  return createComponent(ark.select, mergeProps$1({
    get ["aria-describedby"]() {
      return field?.().ariaDescribedby;
    }
  }, mergedProps, {
    get children() {
      return [createComponent(Show, {
        get when() {
          return isValueEmpty();
        },
        get children() {
          return _tmpl$();
        }
      }), createComponent(Index, {
        get each() {
          return select2().collection.items;
        },
        children: (item) => (() => {
          var _el$2 = _tmpl$2();
          insert(_el$2, () => select2().collection.stringifyItem(item()));
          effect(() => _el$2.disabled = select2().collection.getItemDisabled(item()));
          effect(() => _el$2.value = select2().collection.getItemValue(item()) ?? "");
          return _el$2;
        })()
      })];
    }
  }));
};
var SelectIndicator = (props) => {
  const select2 = useSelectContext();
  const mergedProps = mergeProps(() => select2().getIndicatorProps(), props);
  return createComponent(ark.div, mergedProps);
};

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

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

// src/components/select/select-item.tsx
var SelectItem = (props) => {
  const [itemProps, localProps] = createSplitProps()(props, ["item", "persistFocus"]);
  const select2 = useSelectContext();
  const mergedProps = mergeProps(() => select2().getItemProps(itemProps), localProps);
  const itemState = createMemo(() => select2().getItemState(itemProps));
  return createComponent(SelectItemPropsProvider, {
    value: itemProps,
    get children() {
      return createComponent(SelectItemProvider, {
        value: itemState,
        get children() {
          return createComponent(ark.div, mergedProps);
        }
      });
    }
  });
};

// src/components/select/select-item-context.tsx
var SelectItemContext = (props) => props.children(useSelectItemContext());

// src/components/select/use-select-item-group-props-context.ts
var [SelectItemGroupPropsProvider, useSelectItemGroupPropsContext] = createContext({
  hookName: "useSelectItemGroupPropsContext",
  providerName: "<SelectItemGroupPropsProvider />"
});

// src/components/select/select-item-group.tsx
var SelectItemGroup = (props) => {
  const [_itemGroupProps, localProps] = createSplitProps()(props, ["id"]);
  const select2 = useSelectContext();
  const itemGroupProps = mergeProps({
    id: createUniqueId()
  }, _itemGroupProps);
  const mergedProps = mergeProps(() => select2().getItemGroupProps(itemGroupProps), localProps);
  return createComponent(SelectItemGroupPropsProvider, {
    value: itemGroupProps,
    get children() {
      return createComponent(ark.div, mergedProps);
    }
  });
};
var SelectItemGroupLabel = (props) => {
  const select2 = useSelectContext();
  const itemGroupProps = useSelectItemGroupPropsContext();
  const mergedProps = mergeProps(() => select2().getItemGroupLabelProps({
    htmlFor: itemGroupProps.id
  }), props);
  return createComponent(ark.div, mergedProps);
};
var SelectItemIndicator = (props) => {
  const select2 = useSelectContext();
  const itemProps = useSelectItemPropsContext();
  const mergedProps = mergeProps(() => select2().getItemIndicatorProps(itemProps), props);
  return createComponent(ark.div, mergedProps);
};
var SelectItemText = (props) => {
  const select2 = useSelectContext();
  const itemProps = useSelectItemPropsContext();
  const mergedProps = mergeProps(() => select2().getItemTextProps(itemProps), props);
  return createComponent(ark.span, mergedProps);
};
var SelectLabel = (props) => {
  const select2 = useSelectContext();
  const mergedProps = mergeProps(() => select2().getLabelProps(), props);
  return createComponent(ark.label, mergedProps);
};
var SelectList = (props) => {
  const select2 = useSelectContext();
  const mergedProps = mergeProps(() => select2().getListProps(), props);
  return createComponent(ark.div, mergedProps);
};
var SelectPositioner = (props) => {
  const select2 = useSelectContext();
  const presenceApi = usePresenceContext();
  const mergedProps = mergeProps(() => select2().getPositionerProps(), props);
  return createComponent(Show, {
    get when() {
      return !presenceApi().unmounted;
    },
    get children() {
      return createComponent(ark.div, mergedProps);
    }
  });
};
var useSelect = (props) => {
  const id = createUniqueId();
  const locale = useLocaleContext();
  const environment = useEnvironmentContext();
  const field = useFieldContext();
  const machineProps = createMemo(() => ({
    id,
    ids: {
      label: field?.().ids.label,
      hiddenSelect: field?.().ids.control
    },
    disabled: field?.().disabled,
    readOnly: field?.().readOnly,
    invalid: field?.().invalid,
    required: field?.().required,
    dir: locale().dir,
    getRootNode: environment().getRootNode,
    ...runIfFn(props)
  }));
  const service = useMachine(select.machine, machineProps);
  return createMemo(() => select.connect(service, normalizeProps));
};

// src/components/select/select-root.tsx
var SelectRoot = (props) => {
  const [presenceProps, selectProps] = splitPresenceProps(props);
  const [useSelectProps, localProps] = createSplitProps()(selectProps, ["closeOnSelect", "collection", "composite", "defaultHighlightedValue", "defaultOpen", "defaultValue", "deselectable", "disabled", "form", "highlightedValue", "id", "ids", "invalid", "loopFocus", "multiple", "name", "onFocusOutside", "onHighlightChange", "onInteractOutside", "onOpenChange", "onPointerDownOutside", "onSelect", "onValueChange", "open", "positioning", "readOnly", "required", "scrollToIndexFn", "value"]);
  const select2 = useSelect(useSelectProps);
  const presenceApi = usePresence(mergeProps(() => ({
    present: select2().open
  }), presenceProps));
  const mergedProps = mergeProps(() => select2().getRootProps(), localProps);
  return createComponent(SelectProvider, {
    value: select2,
    get children() {
      return createComponent(PresenceProvider, {
        value: presenceApi,
        get children() {
          return createComponent(ark.div, mergedProps);
        }
      });
    }
  });
};
var SelectRootProvider = (props) => {
  const [presenceProps, selectProps] = splitPresenceProps(props);
  const [{
    value: select2
  }, localProps] = createSplitProps()(selectProps, ["value"]);
  const presence = usePresence(mergeProps(() => ({
    present: select2().open
  }), presenceProps));
  const mergedProps = mergeProps(() => select2().getRootProps(), localProps);
  return createComponent(SelectProvider, {
    value: select2,
    get children() {
      return createComponent(PresenceProvider, {
        value: presence,
        get children() {
          return createComponent(ark.div, mergedProps);
        }
      });
    }
  });
};
var SelectTrigger = (props) => {
  const select2 = useSelectContext();
  const mergedProps = mergeProps(() => select2().getTriggerProps(), props);
  return createComponent(ark.button, mergedProps);
};
var SelectValueText = (props) => {
  const select2 = useSelectContext();
  const mergedProps = mergeProps(() => select2().getValueTextProps(), props);
  return createComponent(ark.span, mergeProps$1(mergedProps, {
    get children() {
      return select2().valueAsString || props.placeholder;
    }
  }));
};

// src/components/select/select.ts
var select_exports = {};
__export(select_exports, {
  ClearTrigger: () => SelectClearTrigger,
  Content: () => SelectContent,
  Context: () => SelectContext,
  Control: () => SelectControl,
  HiddenSelect: () => SelectHiddenSelect,
  Indicator: () => SelectIndicator,
  Item: () => SelectItem,
  ItemContext: () => SelectItemContext,
  ItemGroup: () => SelectItemGroup,
  ItemGroupLabel: () => SelectItemGroupLabel,
  ItemIndicator: () => SelectItemIndicator,
  ItemText: () => SelectItemText,
  Label: () => SelectLabel,
  List: () => SelectList,
  Positioner: () => SelectPositioner,
  Root: () => SelectRoot,
  RootProvider: () => SelectRootProvider,
  Trigger: () => SelectTrigger,
  ValueText: () => SelectValueText
});

export { SelectClearTrigger, SelectContent, SelectContext, SelectControl, SelectHiddenSelect, SelectIndicator, SelectItem, SelectItemContext, SelectItemGroup, SelectItemGroupLabel, SelectItemIndicator, SelectItemText, SelectLabel, SelectList, SelectPositioner, SelectRoot, SelectRootProvider, SelectTrigger, SelectValueText, select_exports, useSelect, useSelectContext, useSelectItemContext };