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/select/root/SelectRootContext.js

@@ -0,0 +1,26 @@
+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 SelectRootContext = /* @__PURE__ */ React.createContext(null);
+if (process.env.NODE_ENV !== "production") SelectRootContext.displayName = "SelectRootContext";
+const SelectFloatingContext = /* @__PURE__ */ React.createContext(null);
+if (process.env.NODE_ENV !== "production") SelectFloatingContext.displayName = "SelectFloatingContext";
+function useSelectRootContext() {
+  const context = React.useContext(SelectRootContext);
+  if (context === null) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: SelectRootContext is missing. Select parts must be placed within <Select.Root>." : formatErrorMessage(60));
+  }
+  return context;
+}
+function useSelectFloatingContext() {
+  const context = React.useContext(SelectFloatingContext);
+  if (context === null) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: SelectFloatingContext is missing. Select parts must be placed within <Select.Root>." : formatErrorMessage(61));
+  }
+  return context;
+}
+export {
+  SelectFloatingContext,
+  SelectRootContext,
+  useSelectFloatingContext,
+  useSelectRootContext
+};

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/select/scroll-arrow/SelectScrollArrow.js

@@ -0,0 +1,172 @@
+import * as React from "react";
+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 { useIsoLayoutEffect } 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/useIsoLayoutEffect.js";
+import { useSelectRootContext } from "../root/SelectRootContext.js";
+import { useSelectPositionerContext } from "../positioner/SelectPositionerContext.js";
+import { useTransitionStatus } from "../../utils/useTransitionStatus.js";
+import { useOpenChangeComplete } from "../../utils/useOpenChangeComplete.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { selectors } from "../store.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";
+const SelectScrollArrow = /* @__PURE__ */ React.forwardRef(function SelectScrollArrow2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    direction,
+    keepMounted = false,
+    ...elementProps
+  } = componentProps;
+  const {
+    store,
+    popupRef,
+    listRef,
+    handleScrollArrowVisibility,
+    scrollArrowsMountedCountRef
+  } = useSelectRootContext();
+  const {
+    side,
+    scrollDownArrowRef,
+    scrollUpArrowRef
+  } = useSelectPositionerContext();
+  const visibleSelector = direction === "up" ? selectors.scrollUpArrowVisible : selectors.scrollDownArrowVisible;
+  const stateVisible = useStore(store, visibleSelector);
+  const openMethod = useStore(store, selectors.openMethod);
+  const visible = stateVisible && openMethod !== "touch";
+  const timeout = useTimeout();
+  const scrollArrowRef = direction === "up" ? scrollUpArrowRef : scrollDownArrowRef;
+  const {
+    transitionStatus,
+    setMounted
+  } = useTransitionStatus(visible);
+  useIsoLayoutEffect(() => {
+    scrollArrowsMountedCountRef.current += 1;
+    if (!store.state.hasScrollArrows) {
+      store.set("hasScrollArrows", true);
+    }
+    return () => {
+      scrollArrowsMountedCountRef.current = Math.max(0, scrollArrowsMountedCountRef.current - 1);
+      if (scrollArrowsMountedCountRef.current === 0 && store.state.hasScrollArrows) {
+        store.set("hasScrollArrows", false);
+      }
+    };
+  }, [store, scrollArrowsMountedCountRef]);
+  useOpenChangeComplete({
+    open: visible,
+    ref: scrollArrowRef,
+    onComplete() {
+      if (!visible) {
+        setMounted(false);
+      }
+    }
+  });
+  const state = {
+    direction,
+    visible,
+    side,
+    transitionStatus
+  };
+  const defaultProps = {
+    "aria-hidden": true,
+    children: direction === "up" ? "▲" : "▼",
+    style: {
+      position: "absolute"
+    },
+    onMouseMove(event) {
+      if (event.movementX === 0 && event.movementY === 0 || timeout.isStarted()) {
+        return;
+      }
+      store.set("activeIndex", null);
+      function scrollNextItem() {
+        var _a;
+        const scroller = store.state.listElement ?? popupRef.current;
+        if (!scroller) {
+          return;
+        }
+        store.set("activeIndex", null);
+        handleScrollArrowVisibility();
+        const isScrolledToTop = scroller.scrollTop === 0;
+        const isScrolledToBottom = Math.round(scroller.scrollTop + scroller.clientHeight) >= scroller.scrollHeight;
+        const list = listRef.current;
+        if (list.length === 0) {
+          if (direction === "up") {
+            store.set("scrollUpArrowVisible", !isScrolledToTop);
+          } else {
+            store.set("scrollDownArrowVisible", !isScrolledToBottom);
+          }
+        }
+        if (direction === "up" && isScrolledToTop || direction === "down" && isScrolledToBottom) {
+          timeout.clear();
+          return;
+        }
+        if ((store.state.listElement || popupRef.current) && listRef.current && listRef.current.length > 0) {
+          const items = listRef.current;
+          const scrollArrowHeight = ((_a = scrollArrowRef.current) == null ? void 0 : _a.offsetHeight) || 0;
+          if (direction === "up") {
+            let firstVisibleIndex = 0;
+            const scrollTop = scroller.scrollTop + scrollArrowHeight;
+            for (let i = 0; i < items.length; i += 1) {
+              const item = items[i];
+              if (item) {
+                const itemTop = item.offsetTop;
+                if (itemTop >= scrollTop) {
+                  firstVisibleIndex = i;
+                  break;
+                }
+              }
+            }
+            const targetIndex = Math.max(0, firstVisibleIndex - 1);
+            if (targetIndex < firstVisibleIndex) {
+              const targetItem = items[targetIndex];
+              if (targetItem) {
+                scroller.scrollTop = Math.max(0, targetItem.offsetTop - scrollArrowHeight);
+              }
+            } else {
+              scroller.scrollTop = 0;
+            }
+          } else {
+            let lastVisibleIndex = items.length - 1;
+            const scrollBottom = scroller.scrollTop + scroller.clientHeight - scrollArrowHeight;
+            for (let i = 0; i < items.length; i += 1) {
+              const item = items[i];
+              if (item) {
+                const itemBottom = item.offsetTop + item.offsetHeight;
+                if (itemBottom > scrollBottom) {
+                  lastVisibleIndex = Math.max(0, i - 1);
+                  break;
+                }
+              }
+            }
+            const targetIndex = Math.min(items.length - 1, lastVisibleIndex + 1);
+            if (targetIndex > lastVisibleIndex) {
+              const targetItem = items[targetIndex];
+              if (targetItem) {
+                scroller.scrollTop = targetItem.offsetTop + targetItem.offsetHeight - scroller.clientHeight + scrollArrowHeight;
+              }
+            } else {
+              scroller.scrollTop = scroller.scrollHeight - scroller.clientHeight;
+            }
+          }
+        }
+        timeout.start(40, scrollNextItem);
+      }
+      timeout.start(40, scrollNextItem);
+    },
+    onMouseLeave() {
+      timeout.clear();
+    }
+  };
+  const element = useRenderElement("div", componentProps, {
+    ref: [forwardedRef, scrollArrowRef],
+    state,
+    props: [defaultProps, elementProps]
+  });
+  const shouldRender = visible || keepMounted;
+  if (!shouldRender) {
+    return null;
+  }
+  return element;
+});
+if (process.env.NODE_ENV !== "production") SelectScrollArrow.displayName = "SelectScrollArrow";
+export {
+  SelectScrollArrow
+};

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/select/scroll-down-arrow/SelectScrollDownArrow.js

@@ -0,0 +1,14 @@
+import * as React from "react";
+import { SelectScrollArrow } from "../scroll-arrow/SelectScrollArrow.js";
+import { jsx } from "react/jsx-runtime";
+const SelectScrollDownArrow = /* @__PURE__ */ React.forwardRef(function SelectScrollDownArrow2(props, forwardedRef) {
+  return /* @__PURE__ */ jsx(SelectScrollArrow, {
+    ...props,
+    ref: forwardedRef,
+    direction: "down"
+  });
+});
+if (process.env.NODE_ENV !== "production") SelectScrollDownArrow.displayName = "SelectScrollDownArrow";
+export {
+  SelectScrollDownArrow
+};

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/select/scroll-up-arrow/SelectScrollUpArrow.js

@@ -0,0 +1,14 @@
+import * as React from "react";
+import { SelectScrollArrow } from "../scroll-arrow/SelectScrollArrow.js";
+import { jsx } from "react/jsx-runtime";
+const SelectScrollUpArrow = /* @__PURE__ */ React.forwardRef(function SelectScrollUpArrow2(props, forwardedRef) {
+  return /* @__PURE__ */ jsx(SelectScrollArrow, {
+    ...props,
+    ref: forwardedRef,
+    direction: "up"
+  });
+});
+if (process.env.NODE_ENV !== "production") SelectScrollUpArrow.displayName = "SelectScrollUpArrow";
+export {
+  SelectScrollUpArrow
+};

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/select/store.js

@@ -0,0 +1,64 @@
+import { compareItemEquality } from "../utils/itemEquality.js";
+import { hasNullItemLabel, stringifyAsValue } 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),
+  modal: createSelector((state) => state.modal),
+  multiple: createSelector((state) => state.multiple),
+  items: createSelector((state) => state.items),
+  itemToStringLabel: createSelector((state) => state.itemToStringLabel),
+  itemToStringValue: createSelector((state) => state.itemToStringValue),
+  isItemEqualToValue: createSelector((state) => state.isItemEqualToValue),
+  value: createSelector((state) => state.value),
+  hasSelectedValue: createSelector((state) => {
+    const {
+      value,
+      multiple,
+      itemToStringValue
+    } = state;
+    if (value == null) {
+      return false;
+    }
+    if (multiple && Array.isArray(value)) {
+      return value.length > 0;
+    }
+    return stringifyAsValue(value, itemToStringValue) !== "";
+  }),
+  hasNullItemLabel: createSelector((state, enabled) => {
+    return enabled ? hasNullItemLabel(state.items) : false;
+  }),
+  open: createSelector((state) => state.open),
+  mounted: createSelector((state) => state.mounted),
+  forceMount: createSelector((state) => state.forceMount),
+  transitionStatus: createSelector((state) => state.transitionStatus),
+  openMethod: createSelector((state) => state.openMethod),
+  activeIndex: createSelector((state) => state.activeIndex),
+  selectedIndex: createSelector((state) => state.selectedIndex),
+  isActive: createSelector((state, index) => state.activeIndex === index),
+  isSelected: createSelector((state, index, itemValue) => {
+    const comparer = state.isItemEqualToValue;
+    const storeValue = state.value;
+    if (state.multiple) {
+      return Array.isArray(storeValue) && storeValue.some((selectedItem) => compareItemEquality(itemValue, selectedItem, comparer));
+    }
+    if (state.selectedIndex === index && state.selectedIndex !== null) {
+      return true;
+    }
+    return compareItemEquality(itemValue, storeValue, comparer);
+  }),
+  isSelectedByFocus: createSelector((state, index) => {
+    return state.selectedIndex === index;
+  }),
+  popupProps: createSelector((state) => state.popupProps),
+  triggerProps: createSelector((state) => state.triggerProps),
+  triggerElement: createSelector((state) => state.triggerElement),
+  positionerElement: createSelector((state) => state.positionerElement),
+  listElement: createSelector((state) => state.listElement),
+  scrollUpArrowVisible: createSelector((state) => state.scrollUpArrowVisible),
+  scrollDownArrowVisible: createSelector((state) => state.scrollDownArrowVisible),
+  hasScrollArrows: createSelector((state) => state.hasScrollArrows)
+};
+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/select/trigger/SelectTrigger.js

@@ -0,0 +1,208 @@
+import * as React from "react";
+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 { 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 { 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 { 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 { useValueAsRef } 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/useValueAsRef.js";
+import { useSelectRootContext } from "../root/SelectRootContext.js";
+import { useFieldRootContext } from "../../field/root/FieldRootContext.js";
+import { useLabelableContext } from "../../labelable-provider/LabelableContext.js";
+import { pressableTriggerOpenStateMapping } from "../../utils/popupStateMapping.js";
+import { fieldValidityMapping } from "../../field/utils/constants.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { selectors } from "../store.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 { 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 { getFloatingFocusElement, contains } from "../../floating-ui-react/utils/element.js";
+import { mergeProps } from "../../merge-props/mergeProps.js";
+import { none, cancelOpen } from "../../utils/reason-parts.js";
+const BOUNDARY_OFFSET = 2;
+const SELECTED_DELAY = 400;
+const UNSELECTED_DELAY = 200;
+const stateAttributesMapping = {
+  ...pressableTriggerOpenStateMapping,
+  ...fieldValidityMapping,
+  value: () => null
+};
+const SelectTrigger = /* @__PURE__ */ React.forwardRef(function SelectTrigger2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    id: idProp,
+    disabled: disabledProp = false,
+    nativeButton = true,
+    ...elementProps
+  } = componentProps;
+  const {
+    setTouched,
+    setFocused,
+    validationMode,
+    state: fieldState,
+    disabled: fieldDisabled
+  } = useFieldRootContext();
+  const {
+    labelId: fieldLabelId
+  } = useLabelableContext();
+  const {
+    store,
+    setOpen,
+    selectionRef,
+    validation,
+    readOnly,
+    required,
+    alignItemWithTriggerActiveRef,
+    disabled: selectDisabled,
+    keyboardActiveRef
+  } = useSelectRootContext();
+  const disabled = fieldDisabled || selectDisabled || disabledProp;
+  const open = useStore(store, selectors.open);
+  const value = useStore(store, selectors.value);
+  const triggerProps = useStore(store, selectors.triggerProps);
+  const positionerElement = useStore(store, selectors.positionerElement);
+  const listElement = useStore(store, selectors.listElement);
+  const rootId = useStore(store, selectors.id);
+  const selectLabelId = useStore(store, selectors.labelId);
+  const hasSelectedValue = useStore(store, selectors.hasSelectedValue);
+  const shouldCheckNullItemLabel = !hasSelectedValue && open;
+  const hasNullItemLabel = useStore(store, selectors.hasNullItemLabel, shouldCheckNullItemLabel);
+  const id = idProp ?? rootId;
+  const ariaLabelledBy = resolveAriaLabelledBy(fieldLabelId, selectLabelId);
+  useLabelableId({
+    id
+  });
+  const positionerRef = useValueAsRef(positionerElement);
+  const triggerRef = React.useRef(null);
+  const {
+    getButtonProps,
+    buttonRef
+  } = useButton({
+    disabled,
+    native: nativeButton
+  });
+  const setTriggerElement = useStableCallback((element) => {
+    store.set("triggerElement", element);
+  });
+  const mergedRef = useMergedRefs(forwardedRef, triggerRef, buttonRef, setTriggerElement);
+  const timeoutFocus = useTimeout();
+  const timeoutMouseDown = useTimeout();
+  const selectedDelayTimeout = useTimeout();
+  const unselectedDelayTimeout = useTimeout();
+  React.useEffect(() => {
+    if (open) {
+      const hasSelectedItemInList = hasSelectedValue || hasNullItemLabel;
+      const shouldDelayUnselectedMouseUpLonger = !hasSelectedItemInList;
+      if (shouldDelayUnselectedMouseUpLonger) {
+        selectedDelayTimeout.start(SELECTED_DELAY, () => {
+          selectionRef.current.allowUnselectedMouseUp = true;
+          selectionRef.current.allowSelectedMouseUp = true;
+        });
+      } else {
+        unselectedDelayTimeout.start(UNSELECTED_DELAY, () => {
+          selectionRef.current.allowUnselectedMouseUp = true;
+          selectedDelayTimeout.start(UNSELECTED_DELAY, () => {
+            selectionRef.current.allowSelectedMouseUp = true;
+          });
+        });
+      }
+      return () => {
+        selectedDelayTimeout.clear();
+        unselectedDelayTimeout.clear();
+      };
+    }
+    selectionRef.current = {
+      allowSelectedMouseUp: false,
+      allowUnselectedMouseUp: false
+    };
+    timeoutMouseDown.clear();
+    return void 0;
+  }, [open, hasSelectedValue, hasNullItemLabel, selectionRef, timeoutMouseDown, selectedDelayTimeout, unselectedDelayTimeout]);
+  const ariaControlsId = React.useMemo(() => {
+    var _a;
+    return (listElement == null ? void 0 : listElement.id) ?? ((_a = getFloatingFocusElement(positionerElement)) == null ? void 0 : _a.id);
+  }, [listElement, positionerElement]);
+  const props = mergeProps(triggerProps, {
+    id,
+    role: "combobox",
+    "aria-expanded": open ? "true" : "false",
+    "aria-haspopup": "listbox",
+    "aria-controls": open ? ariaControlsId : void 0,
+    "aria-labelledby": ariaLabelledBy,
+    "aria-readonly": readOnly || void 0,
+    "aria-required": required || void 0,
+    tabIndex: disabled ? -1 : 0,
+    ref: mergedRef,
+    onFocus(event) {
+      setFocused(true);
+      if (open && alignItemWithTriggerActiveRef.current) {
+        setOpen(false, createChangeEventDetails(none, event.nativeEvent));
+      }
+      timeoutFocus.start(0, () => {
+        store.set("forceMount", true);
+      });
+    },
+    onBlur(event) {
+      if (contains(positionerElement, event.relatedTarget)) {
+        return;
+      }
+      setTouched(true);
+      setFocused(false);
+      if (validationMode === "onBlur") {
+        validation.commit(value);
+      }
+    },
+    onPointerMove() {
+      keyboardActiveRef.current = false;
+    },
+    onKeyDown() {
+      keyboardActiveRef.current = true;
+    },
+    onMouseDown(event) {
+      if (open) {
+        return;
+      }
+      const doc = ownerDocument(event.currentTarget);
+      function handleMouseUp(mouseEvent) {
+        if (!triggerRef.current) {
+          return;
+        }
+        const mouseUpTarget = mouseEvent.target;
+        if (contains(triggerRef.current, mouseUpTarget) || contains(positionerRef.current, mouseUpTarget) || mouseUpTarget === triggerRef.current) {
+          return;
+        }
+        const bounds = getPseudoElementBounds(triggerRef.current);
+        if (mouseEvent.clientX >= bounds.left - BOUNDARY_OFFSET && mouseEvent.clientX <= bounds.right + BOUNDARY_OFFSET && mouseEvent.clientY >= bounds.top - BOUNDARY_OFFSET && mouseEvent.clientY <= bounds.bottom + BOUNDARY_OFFSET) {
+          return;
+        }
+        setOpen(false, createChangeEventDetails(cancelOpen, mouseEvent));
+      }
+      timeoutMouseDown.start(0, () => {
+        doc.addEventListener("mouseup", handleMouseUp, {
+          once: true
+        });
+      });
+    }
+  }, validation.getValidationProps, elementProps, getButtonProps);
+  props.role = "combobox";
+  const state = {
+    ...fieldState,
+    open,
+    disabled,
+    value,
+    readOnly,
+    placeholder: !hasSelectedValue
+  };
+  return useRenderElement("button", componentProps, {
+    ref: [forwardedRef, triggerRef],
+    state,
+    stateAttributesMapping,
+    props
+  });
+});
+if (process.env.NODE_ENV !== "production") SelectTrigger.displayName = "SelectTrigger";
+export {
+  SelectTrigger
+};

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/select/value/SelectValue.js

@@ -0,0 +1,57 @@
+import * as React from "react";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { useSelectRootContext } from "../root/SelectRootContext.js";
+import { resolveMultipleLabels, resolveSelectedLabel } from "../../utils/resolveValueLabel.js";
+import { selectors } from "../store.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";
+const stateAttributesMapping = {
+  value: () => null
+};
+const SelectValue = /* @__PURE__ */ React.forwardRef(function SelectValue2(componentProps, forwardedRef) {
+  const {
+    className,
+    render,
+    children: childrenProp,
+    placeholder,
+    ...elementProps
+  } = componentProps;
+  const {
+    store,
+    valueRef
+  } = useSelectRootContext();
+  const value = useStore(store, selectors.value);
+  const items = useStore(store, selectors.items);
+  const itemToStringLabel = useStore(store, selectors.itemToStringLabel);
+  const hasSelectedValue = useStore(store, selectors.hasSelectedValue);
+  const shouldCheckNullItemLabel = !hasSelectedValue && placeholder != null && childrenProp == null;
+  const hasNullLabel = useStore(store, selectors.hasNullItemLabel, shouldCheckNullItemLabel);
+  const state = {
+    value,
+    placeholder: !hasSelectedValue
+  };
+  let children = null;
+  if (typeof childrenProp === "function") {
+    children = childrenProp(value);
+  } else if (childrenProp != null) {
+    children = childrenProp;
+  } else if (!hasSelectedValue && placeholder != null && !hasNullLabel) {
+    children = placeholder;
+  } else if (Array.isArray(value)) {
+    children = resolveMultipleLabels(value, items, itemToStringLabel);
+  } else {
+    children = resolveSelectedLabel(value, items, itemToStringLabel);
+  }
+  const element = useRenderElement("span", componentProps, {
+    state,
+    ref: [forwardedRef, valueRef],
+    props: [{
+      children
+    }, elementProps],
+    stateAttributesMapping
+  });
+  return element;
+});
+if (process.env.NODE_ENV !== "production") SelectValue.displayName = "SelectValue";
+export {
+  SelectValue
+};

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/separator/Separator.js

@@ -0,0 +1,26 @@
+import * as React from "react";
+import { useRenderElement } from "../utils/useRenderElement.js";
+const Separator = /* @__PURE__ */ React.forwardRef(function SeparatorComponent(componentProps, forwardedRef) {
+  const {
+    className,
+    render,
+    orientation = "horizontal",
+    ...elementProps
+  } = componentProps;
+  const state = {
+    orientation
+  };
+  const element = useRenderElement("div", componentProps, {
+    state,
+    ref: forwardedRef,
+    props: [{
+      role: "separator",
+      "aria-orientation": orientation
+    }, elementProps]
+  });
+  return element;
+});
+if (process.env.NODE_ENV !== "production") Separator.displayName = "Separator";
+export {
+  Separator
+};