dune-react 0.0.1 → 0.0.2

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/combobox/root/ComboboxRoot.js

@@ -0,0 +1,24 @@
+import "react";
+import { AriaCombobox } from "./AriaCombobox.js";
+import { jsx } from "react/jsx-runtime";
+function ComboboxRoot(props) {
+  const {
+    multiple = false,
+    defaultValue,
+    value,
+    onValueChange,
+    autoComplete,
+    ...other
+  } = props;
+  return /* @__PURE__ */ jsx(AriaCombobox, {
+    ...other,
+    selectionMode: multiple ? "multiple" : "single",
+    selectedValue: value,
+    defaultSelectedValue: defaultValue,
+    onSelectedValueChange: onValueChange,
+    formAutoComplete: autoComplete
+  });
+}
+export {
+  ComboboxRoot
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/combobox/root/ComboboxRootContext.js

@@ -0,0 +1,44 @@
+import formatErrorMessage from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/formatErrorMessage.js";
+import * as React from "react";
+const ComboboxRootContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") ComboboxRootContext.displayName = "ComboboxRootContext";
+const ComboboxFloatingContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") ComboboxFloatingContext.displayName = "ComboboxFloatingContext";
+const ComboboxDerivedItemsContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") ComboboxDerivedItemsContext.displayName = "ComboboxDerivedItemsContext";
+const ComboboxInputValueContext = /* @__PURE__ */ React.createContext("");
+if (process.env.NODE_ENV !== "production") ComboboxInputValueContext.displayName = "ComboboxInputValueContext";
+function useComboboxRootContext() {
+  const context = React.useContext(ComboboxRootContext);
+  if (!context) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: ComboboxRootContext is missing. Combobox parts must be placed within <Combobox.Root>." : formatErrorMessage(22));
+  }
+  return context;
+}
+function useComboboxFloatingContext() {
+  const context = React.useContext(ComboboxFloatingContext);
+  if (!context) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: ComboboxFloatingContext is missing. Combobox parts must be placed within <Combobox.Root>." : formatErrorMessage(23));
+  }
+  return context;
+}
+function useComboboxDerivedItemsContext() {
+  const context = React.useContext(ComboboxDerivedItemsContext);
+  if (!context) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: ComboboxItemsContext is missing. Combobox parts must be placed within <Combobox.Root>." : formatErrorMessage(24));
+  }
+  return context;
+}
+function useComboboxInputValueContext() {
+  return React.useContext(ComboboxInputValueContext);
+}
+export {
+  ComboboxDerivedItemsContext,
+  ComboboxFloatingContext,
+  ComboboxInputValueContext,
+  ComboboxRootContext,
+  useComboboxDerivedItemsContext,
+  useComboboxFloatingContext,
+  useComboboxInputValueContext,
+  useComboboxRootContext
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/combobox/root/utils/constants.js

@@ -0,0 +1,9 @@
+const NO_ACTIVE_VALUE = Symbol("none");
+const INITIAL_LAST_HIGHLIGHT = {
+  value: NO_ACTIVE_VALUE,
+  index: -1
+};
+export {
+  INITIAL_LAST_HIGHLIGHT,
+  NO_ACTIVE_VALUE
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/combobox/root/utils/index.js

@@ -0,0 +1,30 @@
+import { stringifyAsLabel } from "../../../utils/resolveValueLabel.js";
+function createCollatorItemFilter(collatorFilter, itemToStringLabel) {
+  return (item, query) => {
+    if (item == null) {
+      return false;
+    }
+    const itemString = stringifyAsLabel(item, itemToStringLabel);
+    return collatorFilter.contains(itemString, query);
+  };
+}
+function createSingleSelectionCollatorFilter(collatorFilter, itemToStringLabel, selectedValue) {
+  return (item, query) => {
+    if (item == null) {
+      return false;
+    }
+    if (!query) {
+      return true;
+    }
+    const itemString = stringifyAsLabel(item, itemToStringLabel);
+    const selectedString = selectedValue != null ? stringifyAsLabel(selectedValue, itemToStringLabel) : "";
+    if (selectedString && collatorFilter.contains(selectedString, query) && selectedString.length === query.length) {
+      return true;
+    }
+    return collatorFilter.contains(itemString, query);
+  };
+}
+export {
+  createCollatorItemFilter,
+  createSingleSelectionCollatorFilter
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/combobox/root/utils/useFilter.js

@@ -0,0 +1,61 @@
+import "react";
+import { stringifyAsLabel } from "../../../utils/resolveValueLabel.js";
+const filterCache = /* @__PURE__ */ new Map();
+function stringifyLocale(locale) {
+  if (Array.isArray(locale)) {
+    return locale.map((value) => stringifyLocale(value)).join(",");
+  }
+  if (locale == null) {
+    return "";
+  }
+  return String(locale);
+}
+function getFilter(options = {}) {
+  const mergedOptions = {
+    usage: "search",
+    sensitivity: "base",
+    ignorePunctuation: true,
+    ...options
+  };
+  const cacheKey = `${stringifyLocale(options.locale)}|${JSON.stringify(mergedOptions)}`;
+  const cachedFilter = filterCache.get(cacheKey);
+  if (cachedFilter) {
+    return cachedFilter;
+  }
+  const collator = new Intl.Collator(options.locale, mergedOptions);
+  const filter = {
+    contains(item, query, itemToString) {
+      if (!query) {
+        return true;
+      }
+      const itemString = stringifyAsLabel(item, itemToString);
+      for (let i = 0; i <= itemString.length - query.length; i += 1) {
+        if (collator.compare(itemString.slice(i, i + query.length), query) === 0) {
+          return true;
+        }
+      }
+      return false;
+    },
+    startsWith(item, query, itemToString) {
+      if (!query) {
+        return true;
+      }
+      const itemString = stringifyAsLabel(item, itemToString);
+      return collator.compare(itemString.slice(0, query.length), query) === 0;
+    },
+    endsWith(item, query, itemToString) {
+      if (!query) {
+        return true;
+      }
+      const itemString = stringifyAsLabel(item, itemToString);
+      const queryLength = query.length;
+      return itemString.length >= queryLength && collator.compare(itemString.slice(itemString.length - queryLength), query) === 0;
+    }
+  };
+  filterCache.set(cacheKey, filter);
+  return filter;
+}
+const useCoreFilter = getFilter;
+export {
+  useCoreFilter
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/combobox/row/ComboboxRowContext.js

@@ -0,0 +1,10 @@
+import * as React from "react";
+const ComboboxRowContext = /* @__PURE__ */ React.createContext(false);
+if (process.env.NODE_ENV !== "production") ComboboxRowContext.displayName = "ComboboxRowContext";
+function useComboboxRowContext() {
+  return React.useContext(ComboboxRowContext);
+}
+export {
+  ComboboxRowContext,
+  useComboboxRowContext
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/combobox/store.js

@@ -0,0 +1,86 @@
+import { compareItemEquality } from "../utils/itemEquality.js";
+import { hasNullItemLabel } from "../utils/resolveValueLabel.js";
+import { createSelector } from "../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/store/createSelector.js";
+const selectors = {
+  id: createSelector((state) => state.id),
+  labelId: createSelector((state) => state.labelId),
+  query: createSelector((state) => state.query),
+  items: createSelector((state) => state.items),
+  selectedValue: createSelector((state) => state.selectedValue),
+  hasSelectionChips: createSelector((state) => {
+    const selectedValue = state.selectedValue;
+    return Array.isArray(selectedValue) && selectedValue.length > 0;
+  }),
+  hasSelectedValue: createSelector((state) => {
+    const {
+      selectedValue,
+      selectionMode
+    } = state;
+    if (selectedValue == null) {
+      return false;
+    }
+    if (selectionMode === "multiple" && Array.isArray(selectedValue)) {
+      return selectedValue.length > 0;
+    }
+    return true;
+  }),
+  hasNullItemLabel: createSelector((state, enabled) => {
+    return enabled ? hasNullItemLabel(state.items) : false;
+  }),
+  open: createSelector((state) => state.open),
+  mounted: createSelector((state) => state.mounted),
+  forceMounted: createSelector((state) => state.forceMounted),
+  inline: createSelector((state) => state.inline),
+  activeIndex: createSelector((state) => state.activeIndex),
+  selectedIndex: createSelector((state) => state.selectedIndex),
+  isActive: createSelector((state, index) => state.activeIndex === index),
+  isSelected: createSelector((state, itemValue) => {
+    const comparer = state.isItemEqualToValue;
+    const selectedValue = state.selectedValue;
+    if (Array.isArray(selectedValue)) {
+      return selectedValue.some((selectedItem) => compareItemEquality(itemValue, selectedItem, comparer));
+    }
+    return compareItemEquality(itemValue, selectedValue, comparer);
+  }),
+  transitionStatus: createSelector((state) => state.transitionStatus),
+  popupProps: createSelector((state) => state.popupProps),
+  inputProps: createSelector((state) => state.inputProps),
+  triggerProps: createSelector((state) => state.triggerProps),
+  getItemProps: createSelector((state) => state.getItemProps),
+  positionerElement: createSelector((state) => state.positionerElement),
+  listElement: createSelector((state) => state.listElement),
+  triggerElement: createSelector((state) => state.triggerElement),
+  inputElement: createSelector((state) => state.inputElement),
+  inputGroupElement: createSelector((state) => state.inputGroupElement),
+  popupSide: createSelector((state) => state.popupSide),
+  openMethod: createSelector((state) => state.openMethod),
+  inputInsidePopup: createSelector((state) => state.inputInsidePopup),
+  selectionMode: createSelector((state) => state.selectionMode),
+  listRef: createSelector((state) => state.listRef),
+  labelsRef: createSelector((state) => state.labelsRef),
+  popupRef: createSelector((state) => state.popupRef),
+  emptyRef: createSelector((state) => state.emptyRef),
+  inputRef: createSelector((state) => state.inputRef),
+  keyboardActiveRef: createSelector((state) => state.keyboardActiveRef),
+  chipsContainerRef: createSelector((state) => state.chipsContainerRef),
+  clearRef: createSelector((state) => state.clearRef),
+  valuesRef: createSelector((state) => state.valuesRef),
+  allValuesRef: createSelector((state) => state.allValuesRef),
+  name: createSelector((state) => state.name),
+  disabled: createSelector((state) => state.disabled),
+  readOnly: createSelector((state) => state.readOnly),
+  required: createSelector((state) => state.required),
+  grid: createSelector((state) => state.grid),
+  isGrouped: createSelector((state) => state.isGrouped),
+  virtualized: createSelector((state) => state.virtualized),
+  onOpenChangeComplete: createSelector((state) => state.onOpenChangeComplete),
+  openOnInputClick: createSelector((state) => state.openOnInputClick),
+  itemToStringLabel: createSelector((state) => state.itemToStringLabel),
+  isItemEqualToValue: createSelector((state) => state.isItemEqualToValue),
+  modal: createSelector((state) => state.modal),
+  autoHighlight: createSelector((state) => state.autoHighlight),
+  submitOnItemClick: createSelector((state) => state.submitOnItemClick)
+};
+export {
+  selectors
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/combobox/trigger/ComboboxTrigger.js

@@ -0,0 +1,221 @@
+import * as React from "react";
+import { useStableCallback } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useStableCallback.js";
+import { useTimeout } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useTimeout.js";
+import { ownerDocument } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/owner.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { useComboboxRootContext, useComboboxDerivedItemsContext, useComboboxFloatingContext, useComboboxInputValueContext } from "../root/ComboboxRootContext.js";
+import { triggerStateAttributesMapping } from "../utils/stateAttributesMapping.js";
+import { selectors } from "../store.js";
+import { useFieldRootContext } from "../../field/root/FieldRootContext.js";
+import { useLabelableContext } from "../../labelable-provider/LabelableContext.js";
+import { getPseudoElementBounds } from "../../utils/getPseudoElementBounds.js";
+import { createChangeEventDetails } from "../../utils/createBaseUIEventDetails.js";
+import { useLabelableId } from "../../labelable-provider/useLabelableId.js";
+import { resolveAriaLabelledBy } from "../../utils/resolveAriaLabelledBy.js";
+import { useTypeahead } from "../../floating-ui-react/hooks/useTypeahead.js";
+import { useClick } from "../../floating-ui-react/hooks/useClick.js";
+import { useButton } from "../../use-button/useButton.js";
+import { useStore } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/store/useStore.js";
+import { stopEvent } from "../../floating-ui-react/utils/event.js";
+import { listNavigation } from "../../utils/reason-parts.js";
+import { contains, getTarget } from "../../floating-ui-react/utils/element.js";
+const BOUNDARY_OFFSET = 2;
+const ComboboxTrigger = /* @__PURE__ */ React.forwardRef(function ComboboxTrigger2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    nativeButton = true,
+    disabled: disabledProp = false,
+    id: idProp,
+    ...elementProps
+  } = componentProps;
+  const {
+    state: fieldState,
+    disabled: fieldDisabled,
+    setTouched,
+    setFocused,
+    validationMode,
+    validation
+  } = useFieldRootContext();
+  const {
+    labelId: fieldLabelId
+  } = useLabelableContext();
+  const store = useComboboxRootContext();
+  const {
+    filteredItems
+  } = useComboboxDerivedItemsContext();
+  const selectionMode = useStore(store, selectors.selectionMode);
+  const comboboxDisabled = useStore(store, selectors.disabled);
+  const readOnly = useStore(store, selectors.readOnly);
+  const required = useStore(store, selectors.required);
+  const mounted = useStore(store, selectors.mounted);
+  const popupSideValue = useStore(store, selectors.popupSide);
+  const positionerElement = useStore(store, selectors.positionerElement);
+  const listElement = useStore(store, selectors.listElement);
+  const triggerProps = useStore(store, selectors.triggerProps);
+  const triggerElement = useStore(store, selectors.triggerElement);
+  const inputInsidePopup = useStore(store, selectors.inputInsidePopup);
+  const rootId = useStore(store, selectors.id);
+  const comboboxLabelId = useStore(store, selectors.labelId);
+  const open = useStore(store, selectors.open);
+  const selectedValue = useStore(store, selectors.selectedValue);
+  const activeIndex = useStore(store, selectors.activeIndex);
+  const selectedIndex = useStore(store, selectors.selectedIndex);
+  const hasSelectedValue = useStore(store, selectors.hasSelectedValue);
+  const floatingRootContext = useComboboxFloatingContext();
+  const inputValue = useComboboxInputValueContext();
+  const focusTimeout = useTimeout();
+  const disabled = fieldDisabled || comboboxDisabled || disabledProp;
+  const listEmpty = filteredItems.length === 0;
+  const popupSide = mounted && positionerElement ? popupSideValue : null;
+  useLabelableId({
+    id: inputInsidePopup ? idProp : void 0
+  });
+  const id = inputInsidePopup ? idProp ?? rootId : idProp;
+  const ariaLabelledBy = resolveAriaLabelledBy(fieldLabelId, comboboxLabelId);
+  const currentPointerTypeRef = React.useRef("");
+  function trackPointerType(event) {
+    currentPointerTypeRef.current = event.pointerType;
+  }
+  const domReference = floatingRootContext.useState("domReferenceElement");
+  React.useEffect(() => {
+    if (!inputInsidePopup) {
+      return;
+    }
+    if (triggerElement && triggerElement !== domReference) {
+      floatingRootContext.set("domReferenceElement", triggerElement);
+    }
+  }, [triggerElement, domReference, floatingRootContext, inputInsidePopup]);
+  const {
+    reference: triggerTypeaheadProps
+  } = useTypeahead(floatingRootContext, {
+    enabled: !open && !readOnly && !comboboxDisabled && selectionMode === "single",
+    listRef: store.state.labelsRef,
+    activeIndex,
+    selectedIndex,
+    onMatch(index) {
+      const nextSelectedValue = store.state.valuesRef.current[index];
+      if (nextSelectedValue !== void 0) {
+        store.state.setSelectedValue(nextSelectedValue, createChangeEventDetails("none"));
+      }
+    }
+  });
+  const {
+    reference: triggerClickProps
+  } = useClick(floatingRootContext, {
+    enabled: !readOnly && !comboboxDisabled,
+    event: "mousedown"
+  });
+  const {
+    buttonRef,
+    getButtonProps
+  } = useButton({
+    native: nativeButton,
+    disabled
+  });
+  const state = {
+    ...fieldState,
+    open,
+    disabled,
+    popupSide,
+    listEmpty,
+    placeholder: !hasSelectedValue
+  };
+  const setTriggerElement = useStableCallback((element2) => {
+    store.set("triggerElement", element2);
+  });
+  const element = useRenderElement("button", componentProps, {
+    ref: [forwardedRef, buttonRef, setTriggerElement],
+    state,
+    props: [triggerProps, triggerClickProps, triggerTypeaheadProps, {
+      id,
+      tabIndex: inputInsidePopup ? 0 : -1,
+      role: inputInsidePopup ? "combobox" : void 0,
+      "aria-expanded": open ? "true" : "false",
+      "aria-haspopup": inputInsidePopup ? "dialog" : "listbox",
+      "aria-controls": open ? listElement == null ? void 0 : listElement.id : void 0,
+      "aria-required": inputInsidePopup ? required || void 0 : void 0,
+      "aria-labelledby": ariaLabelledBy,
+      onPointerDown: trackPointerType,
+      onPointerEnter: trackPointerType,
+      onFocus() {
+        setFocused(true);
+        if (disabled || readOnly) {
+          return;
+        }
+        focusTimeout.start(0, store.state.forceMount);
+      },
+      onBlur(event) {
+        if (contains(positionerElement, event.relatedTarget)) {
+          return;
+        }
+        setTouched(true);
+        setFocused(false);
+        if (validationMode === "onBlur") {
+          const valueToValidate = selectionMode === "none" ? inputValue : selectedValue;
+          validation.commit(valueToValidate);
+        }
+      },
+      onMouseDown(event) {
+        var _a;
+        if (disabled || readOnly) {
+          return;
+        }
+        if (!inputInsidePopup) {
+          floatingRootContext.set("domReferenceElement", event.currentTarget);
+        }
+        store.state.forceMount();
+        if (currentPointerTypeRef.current !== "touch") {
+          (_a = store.state.inputRef.current) == null ? void 0 : _a.focus();
+          if (!inputInsidePopup) {
+            event.preventDefault();
+          }
+        }
+        if (open) {
+          return;
+        }
+        const doc = ownerDocument(event.currentTarget);
+        function handleMouseUp(mouseEvent) {
+          if (!triggerElement) {
+            return;
+          }
+          const mouseUpTarget = getTarget(mouseEvent);
+          const positioner = store.state.positionerElement;
+          const list = store.state.listElement;
+          if (contains(triggerElement, mouseUpTarget) || contains(positioner, mouseUpTarget) || contains(list, mouseUpTarget) || mouseUpTarget === triggerElement) {
+            return;
+          }
+          const bounds = getPseudoElementBounds(triggerElement);
+          const withinHorizontal = mouseEvent.clientX >= bounds.left - BOUNDARY_OFFSET && mouseEvent.clientX <= bounds.right + BOUNDARY_OFFSET;
+          const withinVertical = mouseEvent.clientY >= bounds.top - BOUNDARY_OFFSET && mouseEvent.clientY <= bounds.bottom + BOUNDARY_OFFSET;
+          if (withinHorizontal && withinVertical) {
+            return;
+          }
+          store.state.setOpen(false, createChangeEventDetails("cancel-open", mouseEvent));
+        }
+        if (inputInsidePopup) {
+          doc.addEventListener("mouseup", handleMouseUp, {
+            once: true
+          });
+        }
+      },
+      onKeyDown(event) {
+        var _a;
+        if (disabled || readOnly) {
+          return;
+        }
+        if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+          stopEvent(event);
+          store.state.setOpen(true, createChangeEventDetails(listNavigation, event.nativeEvent));
+          (_a = store.state.inputRef.current) == null ? void 0 : _a.focus();
+        }
+      }
+    }, validation ? validation.getValidationProps(elementProps) : elementProps, getButtonProps],
+    stateAttributesMapping: triggerStateAttributesMapping
+  });
+  return element;
+});
+if (process.env.NODE_ENV !== "production") ComboboxTrigger.displayName = "ComboboxTrigger";
+export {
+  ComboboxTrigger
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/combobox/utils/ComboboxInternalDismissButton.js

@@ -0,0 +1,36 @@
+import * as React from "react";
+import { useMergedRefs } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useMergedRefs.js";
+import { useStableCallback } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useStableCallback.js";
+import { visuallyHiddenInput } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/visuallyHidden.js";
+import { createChangeEventDetails } from "../../utils/createBaseUIEventDetails.js";
+import { useComboboxRootContext } from "../root/ComboboxRootContext.js";
+import { jsx } from "react/jsx-runtime";
+import { useButton } from "../../use-button/useButton.js";
+import { closePress } from "../../utils/reason-parts.js";
+const ComboboxInternalDismissButton = /* @__PURE__ */ React.forwardRef(function ComboboxInternalDismissButton2(_, forwardedRef) {
+  const store = useComboboxRootContext();
+  const {
+    buttonRef,
+    getButtonProps
+  } = useButton({
+    native: false
+  });
+  const mergedRef = useMergedRefs(forwardedRef, buttonRef);
+  const handleDismiss = useStableCallback((event) => {
+    store.state.setOpen(false, createChangeEventDetails(closePress, event.nativeEvent, event.currentTarget));
+  });
+  const dismissProps = getButtonProps({
+    onClick: handleDismiss
+  });
+  return /* @__PURE__ */ jsx("span", {
+    ref: mergedRef,
+    ...dismissProps,
+    "aria-label": "Dismiss",
+    tabIndex: void 0,
+    style: visuallyHiddenInput
+  });
+});
+if (process.env.NODE_ENV !== "production") ComboboxInternalDismissButton.displayName = "ComboboxInternalDismissButton";
+export {
+  ComboboxInternalDismissButton
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/combobox/utils/stateAttributesMapping.js

@@ -0,0 +1,15 @@
+import { pressableTriggerOpenStateMapping } from "../../utils/popupStateMapping.js";
+import { fieldValidityMapping } from "../../field/utils/constants.js";
+const triggerStateAttributesMapping = {
+  ...pressableTriggerOpenStateMapping,
+  ...fieldValidityMapping,
+  popupSide: (side) => side ? {
+    "data-popup-side": side
+  } : null,
+  listEmpty: (empty) => empty ? {
+    "data-list-empty": ""
+  } : null
+};
+export {
+  triggerStateAttributesMapping
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/combobox/value/ComboboxValue.js

@@ -0,0 +1,38 @@
+import * as React from "react";
+import { useComboboxRootContext } from "../root/ComboboxRootContext.js";
+import { resolveMultipleLabels, resolveSelectedLabel } from "../../utils/resolveValueLabel.js";
+import { selectors } from "../store.js";
+import { jsx } from "react/jsx-runtime";
+import { useStore } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/store/useStore.js";
+function ComboboxValue(props) {
+  const {
+    children: childrenProp,
+    placeholder
+  } = props;
+  const store = useComboboxRootContext();
+  const itemToStringLabel = useStore(store, selectors.itemToStringLabel);
+  const selectedValue = useStore(store, selectors.selectedValue);
+  const items = useStore(store, selectors.items);
+  const multiple = useStore(store, selectors.selectionMode) === "multiple";
+  const hasSelectedValue = useStore(store, selectors.hasSelectedValue);
+  const shouldCheckNullItemLabel = !hasSelectedValue && placeholder != null && childrenProp == null;
+  const hasNullLabel = useStore(store, selectors.hasNullItemLabel, shouldCheckNullItemLabel);
+  let children = null;
+  if (typeof childrenProp === "function") {
+    children = childrenProp(selectedValue);
+  } else if (childrenProp != null) {
+    children = childrenProp;
+  } else if (!hasSelectedValue && placeholder != null && !hasNullLabel) {
+    children = placeholder;
+  } else if (multiple && Array.isArray(selectedValue)) {
+    children = resolveMultipleLabels(selectedValue, items, itemToStringLabel);
+  } else {
+    children = resolveSelectedLabel(selectedValue, items, itemToStringLabel);
+  }
+  return /* @__PURE__ */ jsx(React.Fragment, {
+    children
+  });
+}
+export {
+  ComboboxValue
+};