@ark-ui/solid 4.0.0 → 4.2.0

package/dist/chunk/PELFJH2D.jsx

@@ -0,0 +1,124 @@
+import {
+  createSplitProps
+} from "./6WEDGJKQ.jsx";
+import {
+  ark
+} from "./UFYZ7HLU.jsx";
+import {
+  useEnvironmentContext
+} from "./5O4RWSWO.jsx";
+import {
+  useLocaleContext
+} from "./3QQZKR3F.jsx";
+import {
+  createContext
+} from "./NMGUCD2L.jsx";
+import {
+  __export
+} from "./7IUG3E2V.jsx";
+
+// src/components/splitter/use-splitter-context.ts
+var [SplitterProvider, useSplitterContext] = createContext({
+  hookName: "useSplitterContext",
+  providerName: "<SplitterProvider />"
+});
+
+// src/components/splitter/splitter-context.tsx
+var SplitterContext = (props) => props.children(useSplitterContext());
+
+// src/components/splitter/splitter-panel.tsx
+import { mergeProps } from "@zag-js/solid";
+var SplitterPanel = (props) => {
+  const [panelProps, restProps] = createSplitProps()(props, ["id", "snapSize"]);
+  const api = useSplitterContext();
+  const mergedProps = mergeProps(() => api().getPanelProps(panelProps), restProps);
+  return <ark.div {...mergedProps} />;
+};
+
+// src/components/splitter/splitter-resize-trigger.tsx
+import { mergeProps as mergeProps2 } from "@zag-js/solid";
+var SplitterResizeTrigger = (props) => {
+  const [resizeTriggerProps, restProps] = createSplitProps()(props, [
+    "disabled",
+    "id",
+    "step"
+  ]);
+  const api = useSplitterContext();
+  const mergedProps = mergeProps2(() => api().getResizeTriggerProps(resizeTriggerProps), restProps);
+  return <ark.button {...mergedProps} />;
+};
+
+// src/components/splitter/splitter-root.tsx
+import { mergeProps as mergeProps3 } from "@zag-js/solid";
+
+// src/components/splitter/use-splitter.ts
+import { normalizeProps, useMachine } from "@zag-js/solid";
+import * as splitter from "@zag-js/splitter";
+import { createMemo, createUniqueId } from "solid-js";
+var useSplitter = (props) => {
+  const locale = useLocaleContext();
+  const environment = useEnvironmentContext();
+  const id = createUniqueId();
+  const context = createMemo(() => ({
+    id,
+    dir: locale().dir,
+    getRootNode: environment().getRootNode,
+    size: props.defaultSize,
+    ...props
+  }));
+  const [state, send] = useMachine(splitter.machine(context()), { context });
+  return createMemo(() => splitter.connect(state, send, normalizeProps));
+};
+
+// src/components/splitter/splitter-root.tsx
+var SplitterRoot = (props) => {
+  const [useSplitterProps, localProps] = createSplitProps()(props, [
+    "defaultSize",
+    "id",
+    "ids",
+    "onSizeChange",
+    "onSizeChangeEnd",
+    "orientation",
+    "size"
+  ]);
+  const api = useSplitter(useSplitterProps);
+  const mergedProps = mergeProps3(() => api().getRootProps(), localProps);
+  return <SplitterProvider value={api}>
+      <ark.div {...mergedProps} />
+    </SplitterProvider>;
+};
+
+// src/components/splitter/splitter-root-provider.tsx
+import { mergeProps as mergeProps4 } from "@zag-js/solid";
+var SplitterRootProvider = (props) => {
+  const [{ value: splitter2 }, localProps] = createSplitProps()(props, ["value"]);
+  const mergedProps = mergeProps4(() => splitter2().getRootProps(), localProps);
+  return <SplitterProvider value={splitter2}>
+      <ark.div {...mergedProps} />
+    </SplitterProvider>;
+};
+
+// src/components/splitter/splitter.anatomy.ts
+import { anatomy } from "@zag-js/splitter";
+
+// src/components/splitter/splitter.ts
+var splitter_exports = {};
+__export(splitter_exports, {
+  Context: () => SplitterContext,
+  Panel: () => SplitterPanel,
+  ResizeTrigger: () => SplitterResizeTrigger,
+  Root: () => SplitterRoot,
+  RootProvider: () => SplitterRootProvider
+});
+
+export {
+  useSplitterContext,
+  SplitterContext,
+  SplitterPanel,
+  SplitterResizeTrigger,
+  useSplitter,
+  SplitterRoot,
+  SplitterRootProvider,
+  anatomy,
+  splitter_exports
+};

package/dist/chunk/PIUV7KP7.js

@@ -0,0 +1,28 @@
+import { ListCollection } from '@zag-js/collection';
+
+// src/components/collection.ts
+
+// ../../node_modules/@zag-js/store/dist/index.mjs
+function getGlobal() {
+  if (typeof globalThis !== "undefined") return globalThis;
+  if (typeof self !== "undefined") return self;
+  if (typeof window !== "undefined") return window;
+  if (typeof global !== "undefined") return global;
+}
+function makeGlobal(key, value) {
+  const g = getGlobal();
+  if (!g) return value();
+  g[key] || (g[key] = value());
+  return g[key];
+}
+makeGlobal("__zag__proxyStateMap", () => /* @__PURE__ */ new WeakMap());
+var refSet = makeGlobal("__zag__refSet", () => /* @__PURE__ */ new WeakSet());
+function ref(obj) {
+  refSet.add(obj);
+  return obj;
+}
+
+// src/components/collection.ts
+var createListCollection = (options) => ref(new ListCollection(options));
+
+export { createListCollection };

package/dist/chunk/Q3GD7QM3.js

@@ -0,0 +1,128 @@
+import { usePresence, PresenceProvider } from './LCESUDZB.js';
+import { useRenderStrategyContext, splitRenderStrategyProps, RenderStrategyProvider } from './L7OSYHVR.js';
+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 { Show, createUniqueId, createMemo } from 'solid-js';
+import * as tabs from '@zag-js/tabs';
+export { anatomy } from '@zag-js/tabs';
+
+// src/components/tabs/use-tabs-context.ts
+var [TabsProvider, useTabsContext] = createContext({
+  hookName: "useTabsContext",
+  providerName: "<TabsProvider />"
+});
+
+// src/components/tabs/tab-content.tsx
+var TabContent = (props) => {
+  const [contentProps, localProps] = createSplitProps()(props, ["value"]);
+  const api = useTabsContext();
+  const renderStrategyProps = useRenderStrategyContext();
+  const presenceApi = usePresence(mergeProps(renderStrategyProps, () => ({
+    present: api().value === contentProps.value,
+    immediate: true
+  })));
+  const mergedProps = mergeProps(() => api().getContentProps(contentProps), () => presenceApi().presenceProps, localProps);
+  return createComponent(PresenceProvider, {
+    value: presenceApi,
+    get children() {
+      return createComponent(Show, {
+        get when() {
+          return !presenceApi().unmounted;
+        },
+        get children() {
+          return createComponent(ark.div, mergedProps);
+        }
+      });
+    }
+  });
+};
+var TabIndicator = (props) => {
+  const api = useTabsContext();
+  const mergedProps = mergeProps(() => api().getIndicatorProps(), props);
+  return createComponent(ark.div, mergedProps);
+};
+var TabList = (props) => {
+  const api = useTabsContext();
+  const mergedProps = mergeProps(() => api().getListProps(), props);
+  return createComponent(ark.div, mergedProps);
+};
+var TabTrigger = (props) => {
+  const [triggerProps, localProps] = createSplitProps()(props, ["disabled", "value"]);
+  const api = useTabsContext();
+  const mergedProps = mergeProps(() => api().getTriggerProps(triggerProps), localProps);
+  return createComponent(ark.button, mergedProps);
+};
+
+// src/components/tabs/tabs-context.tsx
+var TabsContext = (props) => props.children(useTabsContext());
+var useTabs = (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(tabs.machine(context()), { context });
+  return createMemo(() => tabs.connect(state, send, normalizeProps));
+};
+
+// src/components/tabs/tabs-root.tsx
+var TabsRoot = (props) => {
+  const [renderStrategyProps, tabsProps] = splitRenderStrategyProps(props);
+  const [useTabsProps, restProps] = createSplitProps()(tabsProps, ["activationMode", "composite", "defaultValue", "deselectable", "id", "ids", "loopFocus", "onFocusChange", "onValueChange", "orientation", "translations", "value"]);
+  const api = useTabs(useTabsProps);
+  const mergedProps = mergeProps(() => api().getRootProps(), restProps);
+  return createComponent(TabsProvider, {
+    value: api,
+    get children() {
+      return createComponent(RenderStrategyProvider, {
+        value: renderStrategyProps,
+        get children() {
+          return createComponent(ark.div, mergedProps);
+        }
+      });
+    }
+  });
+};
+var TabsRootProvider = (props) => {
+  const [renderStrategyProps, tabsProps] = splitRenderStrategyProps(props);
+  const [{
+    value: tabs2
+  }, localprops] = createSplitProps()(tabsProps, ["value"]);
+  const mergedProps = mergeProps(() => tabs2().getRootProps(), localprops);
+  return createComponent(TabsProvider, {
+    value: tabs2,
+    get children() {
+      return createComponent(RenderStrategyProvider, {
+        value: renderStrategyProps,
+        get children() {
+          return createComponent(ark.div, mergedProps);
+        }
+      });
+    }
+  });
+};
+
+// src/components/tabs/tabs.ts
+var tabs_exports = {};
+__export(tabs_exports, {
+  Content: () => TabContent,
+  Context: () => TabsContext,
+  Indicator: () => TabIndicator,
+  List: () => TabList,
+  Root: () => TabsRoot,
+  RootProvider: () => TabsRootProvider,
+  Trigger: () => TabTrigger
+});
+
+export { TabContent, TabIndicator, TabList, TabTrigger, TabsContext, TabsRoot, TabsRootProvider, tabs_exports, useTabs, useTabsContext };

package/dist/chunk/QJASL3TD.js

@@ -0,0 +1,102 @@
+import { splitRenderStrategyProps } from './L7OSYHVR.js';
+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 { Show, createUniqueId, createMemo, createSignal, createEffect } from 'solid-js';
+import * as collapsible from '@zag-js/collapsible';
+export { anatomy } from '@zag-js/collapsible';
+
+// src/components/collapsible/use-collapsible-context.ts
+var [CollapsibleProvider, useCollapsibleContext] = createContext({
+  hookName: "useCollapsibleContext",
+  providerName: "<CollapsibleProvider />"
+});
+
+// src/components/collapsible/collapsible-content.tsx
+var CollapsibleContent = (props) => {
+  const api = useCollapsibleContext();
+  const mergedProps = mergeProps(() => api().getContentProps(), props);
+  return createComponent(Show, {
+    get when() {
+      return !api().unmounted;
+    },
+    get children() {
+      return createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+// src/components/collapsible/collapsible-context.tsx
+var CollapsibleContext = (props) => props.children(useCollapsibleContext());
+var useCollapsible = (props) => {
+  const locale = useLocaleContext();
+  const environment = useEnvironmentContext();
+  const [renderStrategyProps, collapsibleProps] = splitRenderStrategyProps(props);
+  const id = createUniqueId();
+  const context = createMemo(() => ({
+    id,
+    dir: locale().dir,
+    getRootNode: environment().getRootNode,
+    open: props.defaultOpen,
+    "open.controlled": props.open !== void 0,
+    ...collapsibleProps
+  }));
+  const [state, send] = useMachine(collapsible.machine(context()), { context });
+  const [wasVisible, setWasVisible] = createSignal(false);
+  createEffect(() => {
+    const isPresent = api().visible;
+    if (isPresent) setWasVisible(true);
+  });
+  const api = createMemo(() => collapsible.connect(state, send, normalizeProps));
+  return createMemo(() => ({
+    ...api(),
+    unmounted: !api().visible && !wasVisible() && renderStrategyProps.lazyMount || renderStrategyProps.unmountOnExit && !api().visible && wasVisible()
+  }));
+};
+
+// src/components/collapsible/collapsible-root.tsx
+var CollapsibleRoot = (props) => {
+  const [useCollapsibleProps, localProps] = createSplitProps()(props, ["defaultOpen", "disabled", "id", "ids", "lazyMount", "onExitComplete", "onOpenChange", "open", "unmountOnExit"]);
+  const api = useCollapsible(useCollapsibleProps);
+  const mergedProps = mergeProps(() => api().getRootProps(), localProps);
+  return createComponent(CollapsibleProvider, {
+    value: api,
+    get children() {
+      return createComponent(ark.div, mergedProps);
+    }
+  });
+};
+var CollapsibleRootProvider = (props) => {
+  const [{
+    value: collapsible2
+  }, localProps] = createSplitProps()(props, ["value"]);
+  const mergedProps = mergeProps(() => collapsible2().getRootProps(), localProps);
+  return createComponent(CollapsibleProvider, {
+    value: collapsible2,
+    get children() {
+      return createComponent(ark.div, mergedProps);
+    }
+  });
+};
+var CollapsibleTrigger = (props) => {
+  const api = useCollapsibleContext();
+  const mergedProps = mergeProps(() => api().getTriggerProps(), props);
+  return createComponent(ark.button, mergedProps);
+};
+
+// src/components/collapsible/collapsible.ts
+var collapsible_exports = {};
+__export(collapsible_exports, {
+  Content: () => CollapsibleContent,
+  Context: () => CollapsibleContext,
+  Root: () => CollapsibleRoot,
+  RootProvider: () => CollapsibleRootProvider,
+  Trigger: () => CollapsibleTrigger
+});
+
+export { CollapsibleContent, CollapsibleContext, CollapsibleRoot, CollapsibleRootProvider, CollapsibleTrigger, collapsible_exports, useCollapsible, useCollapsibleContext };

package/dist/chunk/QK4E7K6M.js

@@ -0,0 +1,302 @@
+import { usePresenceContext, splitPresenceProps, usePresence, PresenceProvider } from './LCESUDZB.js';
+import { useFieldContext } from './B2OPFF7J.js';
+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, effect, template } from 'solid-js/web';
+import { mergeProps, useMachine, normalizeProps } from '@zag-js/solid';
+import { Show, createMemo, Index, createUniqueId, splitProps, createEffect } 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, mergedProps);
+    }
+  });
+};
+
+// 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();
+          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 locale = useLocaleContext();
+  const environment = useEnvironmentContext();
+  const id = createUniqueId();
+  const field = useFieldContext();
+  const initialContext = 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,
+    open: props.defaultOpen,
+    value: props.defaultValue,
+    "open.controlled": props.open !== void 0,
+    ...props
+  }));
+  const context = createMemo(() => {
+    const [, restProps] = splitProps(initialContext(), ["collection"]);
+    return restProps;
+  });
+  const [state, send, service] = useMachine(select.machine(initialContext()), {
+    context
+  });
+  createEffect(() => {
+    service.setContext({ collection: props.collection });
+  });
+  return createMemo(() => select.connect(state, send, normalizeProps));
+};
+
+// src/components/select/select-root.tsx
+var SelectRoot = (props) => {
+  const [presenceProps, selectProps] = splitPresenceProps(props);
+  const [useSelectProps, localProps] = createSplitProps()(selectProps, ["closeOnSelect", "composite", "collection", "defaultOpen", "defaultValue", "deselectable", "disabled", "form", "highlightedValue", "id", "ids", "invalid", "loopFocus", "multiple", "name", "onFocusOutside", "onHighlightChange", "onInteractOutside", "onOpenChange", "onPointerDownOutside", "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 };