@neynar/ui 0.4.0 → 1.0.0

package/dist/node_modules/@base-ui/react/esm/select/scroll-arrow/SelectScrollArrow.js

@@ -0,0 +1,173 @@
+"use client";
+import * as React from "react";
+import { useTimeout } from "../../../../utils/esm/useTimeout.js";
+import { useIsoLayoutEffect } from "../../../../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 "../../../../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 = React.useMemo(() => ({
+    direction,
+    visible,
+    side,
+    transitionStatus
+  }), [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() {
+        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 = scrollArrowRef.current?.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
+};
+//# sourceMappingURL=SelectScrollArrow.js.map

package/dist/node_modules/@base-ui/react/esm/select/scroll-arrow/SelectScrollArrow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectScrollArrow.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/select/scroll-arrow/SelectScrollArrow.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport { useTimeout } from '@base-ui/utils/useTimeout';\nimport { useStore } from '@base-ui/utils/store';\nimport { useIsoLayoutEffect } from '@base-ui/utils/useIsoLayoutEffect';\nimport { useSelectRootContext } from \"../root/SelectRootContext.js\";\nimport { useSelectPositionerContext } from \"../positioner/SelectPositionerContext.js\";\nimport { useTransitionStatus } from \"../../utils/useTransitionStatus.js\";\nimport { useOpenChangeComplete } from \"../../utils/useOpenChangeComplete.js\";\nimport { useRenderElement } from \"../../utils/useRenderElement.js\";\nimport { selectors } from \"../store.js\";\n\n/**\n * @internal\n */\nexport const SelectScrollArrow = /*#__PURE__*/React.forwardRef(function SelectScrollArrow(componentProps, forwardedRef) {\n  const {\n    render,\n    className,\n    direction,\n    keepMounted = false,\n    ...elementProps\n  } = componentProps;\n  const {\n    store,\n    popupRef,\n    listRef,\n    handleScrollArrowVisibility,\n    scrollArrowsMountedCountRef\n  } = useSelectRootContext();\n  const {\n    side,\n    scrollDownArrowRef,\n    scrollUpArrowRef\n  } = useSelectPositionerContext();\n  const visibleSelector = direction === 'up' ? selectors.scrollUpArrowVisible : selectors.scrollDownArrowVisible;\n  const stateVisible = useStore(store, visibleSelector);\n  const openMethod = useStore(store, selectors.openMethod);\n\n  // Scroll arrows are disabled for touch modality as they are a hover-only element.\n  const visible = stateVisible && openMethod !== 'touch';\n  const timeout = useTimeout();\n  const scrollArrowRef = direction === 'up' ? scrollUpArrowRef : scrollDownArrowRef;\n  const {\n    transitionStatus,\n    setMounted\n  } = useTransitionStatus(visible);\n  useIsoLayoutEffect(() => {\n    scrollArrowsMountedCountRef.current += 1;\n    if (!store.state.hasScrollArrows) {\n      store.set('hasScrollArrows', true);\n    }\n    return () => {\n      scrollArrowsMountedCountRef.current = Math.max(0, scrollArrowsMountedCountRef.current - 1);\n      if (scrollArrowsMountedCountRef.current === 0 && store.state.hasScrollArrows) {\n        store.set('hasScrollArrows', false);\n      }\n    };\n  }, [store, scrollArrowsMountedCountRef]);\n  useOpenChangeComplete({\n    open: visible,\n    ref: scrollArrowRef,\n    onComplete() {\n      if (!visible) {\n        setMounted(false);\n      }\n    }\n  });\n  const state = React.useMemo(() => ({\n    direction,\n    visible,\n    side,\n    transitionStatus\n  }), [direction, visible, side, transitionStatus]);\n  const defaultProps = {\n    'aria-hidden': true,\n    children: direction === 'up' ? '▲' : '▼',\n    style: {\n      position: 'absolute'\n    },\n    onMouseMove(event) {\n      if (event.movementX === 0 && event.movementY === 0 || timeout.isStarted()) {\n        return;\n      }\n      store.set('activeIndex', null);\n      function scrollNextItem() {\n        const scroller = store.state.listElement ?? popupRef.current;\n        if (!scroller) {\n          return;\n        }\n        store.set('activeIndex', null);\n        handleScrollArrowVisibility();\n        const isScrolledToTop = scroller.scrollTop === 0;\n        const isScrolledToBottom = Math.round(scroller.scrollTop + scroller.clientHeight) >= scroller.scrollHeight;\n        const list = listRef.current;\n\n        // Fallback when there are no items registered yet.\n        if (list.length === 0) {\n          if (direction === 'up') {\n            store.set('scrollUpArrowVisible', !isScrolledToTop);\n          } else {\n            store.set('scrollDownArrowVisible', !isScrolledToBottom);\n          }\n        }\n        if (direction === 'up' && isScrolledToTop || direction === 'down' && isScrolledToBottom) {\n          timeout.clear();\n          return;\n        }\n        if ((store.state.listElement || popupRef.current) && listRef.current && listRef.current.length > 0) {\n          const items = listRef.current;\n          const scrollArrowHeight = scrollArrowRef.current?.offsetHeight || 0;\n          if (direction === 'up') {\n            let firstVisibleIndex = 0;\n            const scrollTop = scroller.scrollTop + scrollArrowHeight;\n            for (let i = 0; i < items.length; i += 1) {\n              const item = items[i];\n              if (item) {\n                const itemTop = item.offsetTop;\n                if (itemTop >= scrollTop) {\n                  firstVisibleIndex = i;\n                  break;\n                }\n              }\n            }\n            const targetIndex = Math.max(0, firstVisibleIndex - 1);\n            if (targetIndex < firstVisibleIndex) {\n              const targetItem = items[targetIndex];\n              if (targetItem) {\n                scroller.scrollTop = Math.max(0, targetItem.offsetTop - scrollArrowHeight);\n              }\n            } else {\n              // Already at the first item; ensure we reach the absolute top to account for group labels.\n              scroller.scrollTop = 0;\n            }\n          } else {\n            let lastVisibleIndex = items.length - 1;\n            const scrollBottom = scroller.scrollTop + scroller.clientHeight - scrollArrowHeight;\n            for (let i = 0; i < items.length; i += 1) {\n              const item = items[i];\n              if (item) {\n                const itemBottom = item.offsetTop + item.offsetHeight;\n                if (itemBottom > scrollBottom) {\n                  lastVisibleIndex = Math.max(0, i - 1);\n                  break;\n                }\n              }\n            }\n            const targetIndex = Math.min(items.length - 1, lastVisibleIndex + 1);\n            if (targetIndex > lastVisibleIndex) {\n              const targetItem = items[targetIndex];\n              if (targetItem) {\n                scroller.scrollTop = targetItem.offsetTop + targetItem.offsetHeight - scroller.clientHeight + scrollArrowHeight;\n              }\n            } else {\n              // Already at the last item; ensure we reach the true bottom.\n              scroller.scrollTop = scroller.scrollHeight - scroller.clientHeight;\n            }\n          }\n        }\n        timeout.start(40, scrollNextItem);\n      }\n      timeout.start(40, scrollNextItem);\n    },\n    onMouseLeave() {\n      timeout.clear();\n    }\n  };\n  const element = useRenderElement('div', componentProps, {\n    ref: [forwardedRef, scrollArrowRef],\n    state,\n    props: [defaultProps, elementProps]\n  });\n  const shouldRender = visible || keepMounted;\n  if (!shouldRender) {\n    return null;\n  }\n  return element;\n});\nif (process.env.NODE_ENV !== \"production\") SelectScrollArrow.displayName = \"SelectScrollArrow\";"],"names":[],"mappings":";;;;;;;;;;;AAgBY;AACV;AAAM;AACJ;AACA;AACA;AACc;AACX;AAEL;AAAM;AACJ;AACA;AACA;AACA;AACA;AAEF;AAAM;AACJ;AACA;AACA;AAEF;AACA;AACA;AAGA;AACA;AACA;AACA;AAAM;AACJ;AACA;AAEF;AACE;AACA;AACE;AAAiC;AAEnC;AACE;AACA;AACE;AAAkC;AACpC;AACF;AAEF;AAAsB;AACd;AACD;AAEH;AACE;AAAgB;AAClB;AACF;AAEF;AAAmC;AACjC;AACA;AACA;AACA;AAEF;AAAqB;AACJ;AACsB;AAC9B;AACK;AAChB;AAEM;AACE;AAAA;AAEF;AACA;AACE;AACA;AACE;AAAA;AAEF;AACA;AACA;AACA;AACA;AAGA;AACE;AACE;AAAkD;AAElD;AAAuD;AACzD;AAEF;AACE;AACA;AAAA;AAEF;AACE;AACA;AACA;AACE;AACA;AACA;AACE;AACA;AACE;AACA;AACE;AACA;AAAA;AACF;AACF;AAEF;AACA;AACE;AACA;AACE;AAAyE;AAC3E;AAGA;AAAqB;AACvB;AAEA;AACA;AACA;AACE;AACA;AACE;AACA;AACE;AACA;AAAA;AACF;AACF;AAEF;AACA;AACE;AACA;AACE;AAA8F;AAChG;AAGA;AAAsD;AACxD;AACF;AAEF;AAAgC;AAElC;AAAgC;AAClC;AAEE;AAAa;AACf;AAEF;AAAwD;AACpB;AAClC;AACkC;AAEpC;AACA;AACE;AAAO;AAET;AACF;AACA;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/select/scroll-down-arrow/SelectScrollDownArrow.js

@@ -0,0 +1,16 @@
+"use client";
+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
+};
+//# sourceMappingURL=SelectScrollDownArrow.js.map

package/dist/node_modules/@base-ui/react/esm/select/scroll-down-arrow/SelectScrollDownArrow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectScrollDownArrow.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/select/scroll-down-arrow/SelectScrollDownArrow.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport { SelectScrollArrow } from \"../scroll-arrow/SelectScrollArrow.js\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\n/**\n * An element that scrolls the select popup down when hovered. Does not render when using touch input.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Select](https://base-ui.com/react/components/select)\n */\nexport const SelectScrollDownArrow = /*#__PURE__*/React.forwardRef(function SelectScrollDownArrow(props, forwardedRef) {\n  return /*#__PURE__*/_jsx(SelectScrollArrow, {\n    ...props,\n    ref: forwardedRef,\n    direction: \"down\"\n  });\n});\nif (process.env.NODE_ENV !== \"production\") SelectScrollDownArrow.displayName = \"SelectScrollDownArrow\";"],"names":[],"mappings":";;;;AAWY;AACV;AAA4C;AACvC;AACE;AACM;AAEf;AACA;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/select/scroll-up-arrow/SelectScrollUpArrow.js

@@ -0,0 +1,16 @@
+"use client";
+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
+};
+//# sourceMappingURL=SelectScrollUpArrow.js.map

package/dist/node_modules/@base-ui/react/esm/select/scroll-up-arrow/SelectScrollUpArrow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectScrollUpArrow.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/select/scroll-up-arrow/SelectScrollUpArrow.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport { SelectScrollArrow } from \"../scroll-arrow/SelectScrollArrow.js\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\n/**\n * An element that scrolls the select popup up when hovered. Does not render when using touch input.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Select](https://base-ui.com/react/components/select)\n */\nexport const SelectScrollUpArrow = /*#__PURE__*/React.forwardRef(function SelectScrollUpArrow(props, forwardedRef) {\n  return /*#__PURE__*/_jsx(SelectScrollArrow, {\n    ...props,\n    ref: forwardedRef,\n    direction: \"up\"\n  });\n});\nif (process.env.NODE_ENV !== \"production\") SelectScrollUpArrow.displayName = \"SelectScrollUpArrow\";"],"names":[],"mappings":";;;;AAWY;AACV;AAA4C;AACvC;AACE;AACM;AAEf;AACA;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/select/store.js

@@ -0,0 +1,58 @@
+import { compareItemEquality } from "../utils/itemEquality.js";
+import { stringifyAsValue } from "../utils/resolveValueLabel.js";
+import { createSelector } from "../../../utils/esm/store/createSelector.js";
+const selectors = {
+  id: createSelector((state) => state.id),
+  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),
+  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, candidate) => {
+    const comparer = state.isItemEqualToValue;
+    const storeValue = state.value;
+    if (state.multiple) {
+      return Array.isArray(storeValue) && storeValue.some((item) => compareItemEquality(item, candidate, comparer));
+    }
+    if (state.selectedIndex === index && state.selectedIndex !== null) {
+      return true;
+    }
+    return compareItemEquality(storeValue, candidate, 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),
+  serializedValue: createSelector((state) => {
+    const {
+      multiple,
+      value,
+      itemToStringValue
+    } = state;
+    if (multiple && Array.isArray(value) && value.length === 0) {
+      return "";
+    }
+    return stringifyAsValue(value, itemToStringValue);
+  })
+};
+export {
+  selectors
+};
+//# sourceMappingURL=store.js.map

package/dist/node_modules/@base-ui/react/esm/select/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","sources":["../../../../../../node_modules/@base-ui/react/esm/select/store.js"],"sourcesContent":["import { createSelector } from '@base-ui/utils/store';\nimport { compareItemEquality } from \"../utils/itemEquality.js\";\nimport { stringifyAsValue } from \"../utils/resolveValueLabel.js\";\nexport const selectors = {\n  id: createSelector(state => state.id),\n  modal: createSelector(state => state.modal),\n  multiple: createSelector(state => state.multiple),\n  items: createSelector(state => state.items),\n  itemToStringLabel: createSelector(state => state.itemToStringLabel),\n  itemToStringValue: createSelector(state => state.itemToStringValue),\n  isItemEqualToValue: createSelector(state => state.isItemEqualToValue),\n  value: createSelector(state => state.value),\n  open: createSelector(state => state.open),\n  mounted: createSelector(state => state.mounted),\n  forceMount: createSelector(state => state.forceMount),\n  transitionStatus: createSelector(state => state.transitionStatus),\n  openMethod: createSelector(state => state.openMethod),\n  activeIndex: createSelector(state => state.activeIndex),\n  selectedIndex: createSelector(state => state.selectedIndex),\n  isActive: createSelector((state, index) => state.activeIndex === index),\n  isSelected: createSelector((state, index, candidate) => {\n    const comparer = state.isItemEqualToValue;\n    const storeValue = state.value;\n    if (state.multiple) {\n      return Array.isArray(storeValue) && storeValue.some(item => compareItemEquality(item, candidate, comparer));\n    }\n\n    // `selectedIndex` is only updated after the items mount for the first time,\n    // the value check avoids a re-render for the initially selected item.\n    if (state.selectedIndex === index && state.selectedIndex !== null) {\n      return true;\n    }\n    return compareItemEquality(storeValue, candidate, comparer);\n  }),\n  isSelectedByFocus: createSelector((state, index) => {\n    return state.selectedIndex === index;\n  }),\n  popupProps: createSelector(state => state.popupProps),\n  triggerProps: createSelector(state => state.triggerProps),\n  triggerElement: createSelector(state => state.triggerElement),\n  positionerElement: createSelector(state => state.positionerElement),\n  listElement: createSelector(state => state.listElement),\n  scrollUpArrowVisible: createSelector(state => state.scrollUpArrowVisible),\n  scrollDownArrowVisible: createSelector(state => state.scrollDownArrowVisible),\n  hasScrollArrows: createSelector(state => state.hasScrollArrows),\n  serializedValue: createSelector(state => {\n    const {\n      multiple,\n      value,\n      itemToStringValue\n    } = state;\n    if (multiple && Array.isArray(value) && value.length === 0) {\n      return '';\n    }\n    return stringifyAsValue(value, itemToStringValue);\n  })\n};"],"names":[],"mappings":";;;AAGY,MAAC,YAAY;AAAA,EACvB,IAAI,eAAe,WAAS,MAAM,EAAE;AAAA,EACpC,OAAO,eAAe,WAAS,MAAM,KAAK;AAAA,EAC1C,UAAU,eAAe,WAAS,MAAM,QAAQ;AAAA,EAChD,OAAO,eAAe,WAAS,MAAM,KAAK;AAAA,EAC1C,mBAAmB,eAAe,WAAS,MAAM,iBAAiB;AAAA,EAClE,mBAAmB,eAAe,WAAS,MAAM,iBAAiB;AAAA,EAClE,oBAAoB,eAAe,WAAS,MAAM,kBAAkB;AAAA,EACpE,OAAO,eAAe,WAAS,MAAM,KAAK;AAAA,EAC1C,MAAM,eAAe,WAAS,MAAM,IAAI;AAAA,EACxC,SAAS,eAAe,WAAS,MAAM,OAAO;AAAA,EAC9C,YAAY,eAAe,WAAS,MAAM,UAAU;AAAA,EACpD,kBAAkB,eAAe,WAAS,MAAM,gBAAgB;AAAA,EAChE,YAAY,eAAe,WAAS,MAAM,UAAU;AAAA,EACpD,aAAa,eAAe,WAAS,MAAM,WAAW;AAAA,EACtD,eAAe,eAAe,WAAS,MAAM,aAAa;AAAA,EAC1D,UAAU,eAAe,CAAC,OAAO,UAAU,MAAM,gBAAgB,KAAK;AAAA,EACtE,YAAY,eAAe,CAAC,OAAO,OAAO,cAAc;AACtD,UAAM,WAAW,MAAM;AACvB,UAAM,aAAa,MAAM;AACzB,QAAI,MAAM,UAAU;AAClB,aAAO,MAAM,QAAQ,UAAU,KAAK,WAAW,KAAK,UAAQ,oBAAoB,MAAM,WAAW,QAAQ,CAAC;AAAA,IAC5G;AAIA,QAAI,MAAM,kBAAkB,SAAS,MAAM,kBAAkB,MAAM;AACjE,aAAO;AAAA,IACT;AACA,WAAO,oBAAoB,YAAY,WAAW,QAAQ;AAAA,EAC5D,CAAC;AAAA,EACD,mBAAmB,eAAe,CAAC,OAAO,UAAU;AAClD,WAAO,MAAM,kBAAkB;AAAA,EACjC,CAAC;AAAA,EACD,YAAY,eAAe,WAAS,MAAM,UAAU;AAAA,EACpD,cAAc,eAAe,WAAS,MAAM,YAAY;AAAA,EACxD,gBAAgB,eAAe,WAAS,MAAM,cAAc;AAAA,EAC5D,mBAAmB,eAAe,WAAS,MAAM,iBAAiB;AAAA,EAClE,aAAa,eAAe,WAAS,MAAM,WAAW;AAAA,EACtD,sBAAsB,eAAe,WAAS,MAAM,oBAAoB;AAAA,EACxE,wBAAwB,eAAe,WAAS,MAAM,sBAAsB;AAAA,EAC5E,iBAAiB,eAAe,WAAS,MAAM,eAAe;AAAA,EAC9D,iBAAiB,eAAe,WAAS;AACvC,UAAM;AAAA,MACJ;AAAA,MACA;AAAA,MACA;AAAA,IACN,IAAQ;AACJ,QAAI,YAAY,MAAM,QAAQ,KAAK,KAAK,MAAM,WAAW,GAAG;AAC1D,aAAO;AAAA,IACT;AACA,WAAO,iBAAiB,OAAO,iBAAiB;AAAA,EAClD,CAAC;AACH;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/select/trigger/SelectTrigger.js

@@ -0,0 +1,180 @@
+"use client";
+import * as React from "react";
+import { ownerDocument } from "../../../../utils/esm/owner.js";
+import { useTimeout } from "../../../../utils/esm/useTimeout.js";
+import { useStableCallback } from "../../../../utils/esm/useStableCallback.js";
+import { useMergedRefs } from "../../../../utils/esm/useMergedRefs.js";
+import { useValueAsRef } from "../../../../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 { useButton } from "../../use-button/useButton.js";
+import { useStore } from "../../../../utils/esm/store/useStore.js";
+import { getFloatingFocusElement, contains } from "../../floating-ui-react/utils/element.js";
+import { mergeProps } from "../../merge-props/mergeProps.js";
+import { focusOut, cancelOpen } from "../../utils/reason-parts.js";
+const BOUNDARY_OFFSET = 2;
+const stateAttributesMapping = {
+  ...pressableTriggerOpenStateMapping,
+  ...fieldValidityMapping,
+  value: () => null
+};
+const SelectTrigger = /* @__PURE__ */ React.forwardRef(function SelectTrigger2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    disabled: disabledProp = false,
+    nativeButton = true,
+    ...elementProps
+  } = componentProps;
+  const {
+    setTouched,
+    setFocused,
+    validationMode,
+    state: fieldState,
+    disabled: fieldDisabled
+  } = useFieldRootContext();
+  const {
+    labelId
+  } = useLabelableContext();
+  const {
+    store,
+    setOpen,
+    selectionRef,
+    validation,
+    readOnly,
+    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 serializedValue = useStore(store, selectors.serializedValue);
+  const positionerRef = useValueAsRef(positionerElement);
+  const triggerRef = React.useRef(null);
+  const timeoutFocus = useTimeout();
+  const timeoutMouseDown = useTimeout();
+  const {
+    getButtonProps,
+    buttonRef
+  } = useButton({
+    disabled,
+    native: nativeButton
+  });
+  const setTriggerElement = useStableCallback((element) => {
+    store.set("triggerElement", element);
+  });
+  const mergedRef = useMergedRefs(forwardedRef, triggerRef, buttonRef, setTriggerElement);
+  const timeout1 = useTimeout();
+  const timeout2 = useTimeout();
+  React.useEffect(() => {
+    if (open) {
+      timeout2.start(200, () => {
+        selectionRef.current.allowUnselectedMouseUp = true;
+        timeout1.start(200, () => {
+          selectionRef.current.allowSelectedMouseUp = true;
+        });
+      });
+      return () => {
+        timeout1.clear();
+        timeout2.clear();
+      };
+    }
+    selectionRef.current = {
+      allowSelectedMouseUp: false,
+      allowUnselectedMouseUp: false
+    };
+    timeoutMouseDown.clear();
+    return void 0;
+  }, [open, selectionRef, timeoutMouseDown, timeout1, timeout2]);
+  const ariaControlsId = React.useMemo(() => {
+    return listElement?.id ?? getFloatingFocusElement(positionerElement)?.id;
+  }, [listElement, positionerElement]);
+  const props = mergeProps(triggerProps, {
+    role: "combobox",
+    "aria-expanded": open ? "true" : "false",
+    "aria-haspopup": "listbox",
+    "aria-controls": open ? ariaControlsId : void 0,
+    "aria-labelledby": labelId,
+    "aria-readonly": readOnly || void 0,
+    tabIndex: disabled ? -1 : 0,
+    ref: mergedRef,
+    onFocus(event) {
+      setFocused(true);
+      if (open && alignItemWithTriggerActiveRef.current) {
+        setOpen(false, createChangeEventDetails(focusOut, event.nativeEvent));
+      }
+      timeoutFocus.start(0, () => {
+        store.set("forceMount", true);
+      });
+    },
+    onBlur() {
+      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 = React.useMemo(() => ({
+    ...fieldState,
+    open,
+    disabled,
+    value,
+    readOnly,
+    placeholder: !serializedValue
+  }), [fieldState, open, disabled, value, readOnly, serializedValue]);
+  return useRenderElement("button", componentProps, {
+    ref: [forwardedRef, triggerRef],
+    state,
+    stateAttributesMapping,
+    props
+  });
+});
+if (process.env.NODE_ENV !== "production") SelectTrigger.displayName = "SelectTrigger";
+export {
+  SelectTrigger
+};
+//# sourceMappingURL=SelectTrigger.js.map

package/dist/node_modules/@base-ui/react/esm/select/trigger/SelectTrigger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectTrigger.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/select/trigger/SelectTrigger.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport { ownerDocument } from '@base-ui/utils/owner';\nimport { useTimeout } from '@base-ui/utils/useTimeout';\nimport { useStableCallback } from '@base-ui/utils/useStableCallback';\nimport { useMergedRefs } from '@base-ui/utils/useMergedRefs';\nimport { useValueAsRef } from '@base-ui/utils/useValueAsRef';\nimport { useStore } from '@base-ui/utils/store';\nimport { useSelectRootContext } from \"../root/SelectRootContext.js\";\nimport { useFieldRootContext } from \"../../field/root/FieldRootContext.js\";\nimport { useLabelableContext } from \"../../labelable-provider/LabelableContext.js\";\nimport { pressableTriggerOpenStateMapping } from \"../../utils/popupStateMapping.js\";\nimport { fieldValidityMapping } from \"../../field/utils/constants.js\";\nimport { useRenderElement } from \"../../utils/useRenderElement.js\";\nimport { selectors } from \"../store.js\";\nimport { getPseudoElementBounds } from \"../../utils/getPseudoElementBounds.js\";\nimport { contains, getFloatingFocusElement } from \"../../floating-ui-react/utils.js\";\nimport { mergeProps } from \"../../merge-props/index.js\";\nimport { useButton } from \"../../use-button/index.js\";\nimport { createChangeEventDetails } from \"../../utils/createBaseUIEventDetails.js\";\nimport { REASONS } from \"../../utils/reasons.js\";\nconst BOUNDARY_OFFSET = 2;\nconst stateAttributesMapping = {\n  ...pressableTriggerOpenStateMapping,\n  ...fieldValidityMapping,\n  value: () => null\n};\n\n/**\n * A button that opens the select popup.\n * Renders a `<button>` element.\n *\n * Documentation: [Base UI Select](https://base-ui.com/react/components/select)\n */\nexport const SelectTrigger = /*#__PURE__*/React.forwardRef(function SelectTrigger(componentProps, forwardedRef) {\n  const {\n    render,\n    className,\n    disabled: disabledProp = false,\n    nativeButton = true,\n    ...elementProps\n  } = componentProps;\n  const {\n    setTouched,\n    setFocused,\n    validationMode,\n    state: fieldState,\n    disabled: fieldDisabled\n  } = useFieldRootContext();\n  const {\n    labelId\n  } = useLabelableContext();\n  const {\n    store,\n    setOpen,\n    selectionRef,\n    validation,\n    readOnly,\n    alignItemWithTriggerActiveRef,\n    disabled: selectDisabled,\n    keyboardActiveRef\n  } = useSelectRootContext();\n  const disabled = fieldDisabled || selectDisabled || disabledProp;\n  const open = useStore(store, selectors.open);\n  const value = useStore(store, selectors.value);\n  const triggerProps = useStore(store, selectors.triggerProps);\n  const positionerElement = useStore(store, selectors.positionerElement);\n  const listElement = useStore(store, selectors.listElement);\n  const serializedValue = useStore(store, selectors.serializedValue);\n  const positionerRef = useValueAsRef(positionerElement);\n  const triggerRef = React.useRef(null);\n  const timeoutFocus = useTimeout();\n  const timeoutMouseDown = useTimeout();\n  const {\n    getButtonProps,\n    buttonRef\n  } = useButton({\n    disabled,\n    native: nativeButton\n  });\n  const setTriggerElement = useStableCallback(element => {\n    store.set('triggerElement', element);\n  });\n  const mergedRef = useMergedRefs(forwardedRef, triggerRef, buttonRef, setTriggerElement);\n  const timeout1 = useTimeout();\n  const timeout2 = useTimeout();\n  React.useEffect(() => {\n    if (open) {\n      // mousedown -> move to unselected item -> mouseup should not select within 200ms.\n      timeout2.start(200, () => {\n        selectionRef.current.allowUnselectedMouseUp = true;\n\n        // mousedown -> mouseup on selected item should not select within 400ms.\n        timeout1.start(200, () => {\n          selectionRef.current.allowSelectedMouseUp = true;\n        });\n      });\n      return () => {\n        timeout1.clear();\n        timeout2.clear();\n      };\n    }\n    selectionRef.current = {\n      allowSelectedMouseUp: false,\n      allowUnselectedMouseUp: false\n    };\n    timeoutMouseDown.clear();\n    return undefined;\n  }, [open, selectionRef, timeoutMouseDown, timeout1, timeout2]);\n  const ariaControlsId = React.useMemo(() => {\n    return listElement?.id ?? getFloatingFocusElement(positionerElement)?.id;\n  }, [listElement, positionerElement]);\n  const props = mergeProps(triggerProps, {\n    role: 'combobox',\n    'aria-expanded': open ? 'true' : 'false',\n    'aria-haspopup': 'listbox',\n    'aria-controls': open ? ariaControlsId : undefined,\n    'aria-labelledby': labelId,\n    'aria-readonly': readOnly || undefined,\n    tabIndex: disabled ? -1 : 0,\n    ref: mergedRef,\n    onFocus(event) {\n      setFocused(true);\n      // The popup element shouldn't obscure the focused trigger.\n      if (open && alignItemWithTriggerActiveRef.current) {\n        setOpen(false, createChangeEventDetails(REASONS.focusOut, event.nativeEvent));\n      }\n\n      // Saves a re-render on initial click: `forceMount === true` mounts\n      // the items before `open === true`. We could sync those cycles better\n      // without a timeout, but this is enough for now.\n      //\n      // XXX: might be causing `act()` warnings.\n      timeoutFocus.start(0, () => {\n        store.set('forceMount', true);\n      });\n    },\n    onBlur() {\n      setTouched(true);\n      setFocused(false);\n      if (validationMode === 'onBlur') {\n        validation.commit(value);\n      }\n    },\n    onPointerMove() {\n      keyboardActiveRef.current = false;\n    },\n    onKeyDown() {\n      keyboardActiveRef.current = true;\n    },\n    onMouseDown(event) {\n      if (open) {\n        return;\n      }\n      const doc = ownerDocument(event.currentTarget);\n      function handleMouseUp(mouseEvent) {\n        if (!triggerRef.current) {\n          return;\n        }\n        const mouseUpTarget = mouseEvent.target;\n\n        // Early return if clicked on trigger element or its children\n        if (contains(triggerRef.current, mouseUpTarget) || contains(positionerRef.current, mouseUpTarget) || mouseUpTarget === triggerRef.current) {\n          return;\n        }\n        const bounds = getPseudoElementBounds(triggerRef.current);\n        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) {\n          return;\n        }\n        setOpen(false, createChangeEventDetails(REASONS.cancelOpen, mouseEvent));\n      }\n\n      // Firefox can fire this upon mousedown\n      timeoutMouseDown.start(0, () => {\n        doc.addEventListener('mouseup', handleMouseUp, {\n          once: true\n        });\n      });\n    }\n  }, validation.getValidationProps, elementProps, getButtonProps);\n\n  // ensure nested useButton does not overwrite the combobox role:\n  // <Toolbar.Button render={<Select.Trigger />} />\n  props.role = 'combobox';\n  const state = React.useMemo(() => ({\n    ...fieldState,\n    open,\n    disabled,\n    value,\n    readOnly,\n    placeholder: !serializedValue\n  }), [fieldState, open, disabled, value, readOnly, serializedValue]);\n  return useRenderElement('button', componentProps, {\n    ref: [forwardedRef, triggerRef],\n    state,\n    stateAttributesMapping,\n    props\n  });\n});\nif (process.env.NODE_ENV !== \"production\") SelectTrigger.displayName = \"SelectTrigger\";"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsBA;AACA;AAA+B;AAC1B;AACA;AAEL;AAQY;AACV;AAAM;AACJ;AACA;AACyB;AACV;AACZ;AAEL;AAAM;AACJ;AACA;AACA;AACO;AACG;AAEZ;AAAM;AACJ;AAEF;AAAM;AACJ;AACA;AACA;AACA;AACA;AACA;AACU;AACV;AAEF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAM;AACJ;AACA;AACY;AACZ;AACQ;AAEV;AACE;AAAmC;AAErC;AACA;AACA;AACA;AACE;AAEE;AACE;AAGA;AACE;AAA4C;AAC7C;AAEH;AACE;AACA;AAAc;AAChB;AAEF;AAAuB;AACC;AACE;AAE1B;AACA;AAAO;AAET;AACE;AAAsE;AAExE;AAAuC;AAC/B;AAC2B;AAChB;AACwB;AACtB;AACU;AACH;AACrB;AAEH;AAEA;AACE;AAA4E;AAQ9E;AACE;AAA4B;AAC7B;AACH;AAEE;AACA;AACA;AACE;AAAuB;AACzB;AACF;AAEE;AAA4B;AAC9B;AAEE;AAA4B;AAC9B;AAEE;AACE;AAAA;AAEF;AACA;AACE;AACE;AAAA;AAEF;AAGA;AACE;AAAA;AAEF;AACA;AACE;AAAA;AAEF;AAAuE;AAIzE;AACE;AAA+C;AACvC;AACP;AACF;AACH;AAKF;AACA;AAAmC;AAC9B;AACH;AACA;AACA;AACA;AACc;AAEhB;AAAkD;AAClB;AAC9B;AACA;AACA;AAEJ;AACA;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/select/value/SelectValue.js

@@ -0,0 +1,45 @@
+"use client";
+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 "../../../../utils/esm/store/useStore.js";
+const stateAttributesMapping = {
+  value: () => null
+};
+const SelectValue = /* @__PURE__ */ React.forwardRef(function SelectValue2(componentProps, forwardedRef) {
+  const {
+    className,
+    render,
+    children: childrenProp,
+    ...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 serializedValue = useStore(store, selectors.serializedValue);
+  const state = React.useMemo(() => ({
+    value,
+    placeholder: !serializedValue
+  }), [value, serializedValue]);
+  const children = typeof childrenProp === "function" ? childrenProp(value) : childrenProp ?? (Array.isArray(value) ? resolveMultipleLabels(value, itemToStringLabel) : 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
+};
+//# sourceMappingURL=SelectValue.js.map

package/dist/node_modules/@base-ui/react/esm/select/value/SelectValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectValue.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/select/value/SelectValue.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport { useStore } from '@base-ui/utils/store';\nimport { useRenderElement } from \"../../utils/useRenderElement.js\";\nimport { useSelectRootContext } from \"../root/SelectRootContext.js\";\nimport { resolveSelectedLabel, resolveMultipleLabels } from \"../../utils/resolveValueLabel.js\";\nimport { selectors } from \"../store.js\";\nconst stateAttributesMapping = {\n  value: () => null\n};\n\n/**\n * A text label of the currently selected item.\n * Renders a `<span>` element.\n *\n * Documentation: [Base UI Select](https://base-ui.com/react/components/select)\n */\nexport const SelectValue = /*#__PURE__*/React.forwardRef(function SelectValue(componentProps, forwardedRef) {\n  const {\n    className,\n    render,\n    children: childrenProp,\n    ...elementProps\n  } = componentProps;\n  const {\n    store,\n    valueRef\n  } = useSelectRootContext();\n  const value = useStore(store, selectors.value);\n  const items = useStore(store, selectors.items);\n  const itemToStringLabel = useStore(store, selectors.itemToStringLabel);\n  const serializedValue = useStore(store, selectors.serializedValue);\n  const state = React.useMemo(() => ({\n    value,\n    placeholder: !serializedValue\n  }), [value, serializedValue]);\n  const children = typeof childrenProp === 'function' ? childrenProp(value) : childrenProp ?? (Array.isArray(value) ? resolveMultipleLabels(value, itemToStringLabel) : resolveSelectedLabel(value, items, itemToStringLabel));\n  const element = useRenderElement('span', componentProps, {\n    state,\n    ref: [forwardedRef, valueRef],\n    props: [{\n      children\n    }, elementProps],\n    stateAttributesMapping\n  });\n  return element;\n});\nif (process.env.NODE_ENV !== \"production\") SelectValue.displayName = \"SelectValue\";"],"names":[],"mappings":";;;;;;;AAQA;AAA+B;AAE/B;AAQY;AACV;AAAM;AACJ;AACA;AACU;AACP;AAEL;AAAM;AACJ;AACA;AAEF;AACA;AACA;AACA;AACA;AAAmC;AACjC;AACc;AAEhB;AACA;AAAyD;AACvD;AAC4B;AACpB;AACN;AACa;AACf;AAEF;AACF;AACA;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/separator/Separator.js

@@ -0,0 +1,28 @@
+"use client";
+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 = React.useMemo(() => ({
+    orientation
+  }), [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
+};
+//# sourceMappingURL=Separator.js.map

package/dist/node_modules/@base-ui/react/esm/separator/Separator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Separator.js","sources":["../../../../../../node_modules/@base-ui/react/esm/separator/Separator.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport { useRenderElement } from \"../utils/useRenderElement.js\";\n\n/**\n * A separator element accessible to screen readers.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Separator](https://base-ui.com/react/components/separator)\n */\nexport const Separator = /*#__PURE__*/React.forwardRef(function SeparatorComponent(componentProps, forwardedRef) {\n  const {\n    className,\n    render,\n    orientation = 'horizontal',\n    ...elementProps\n  } = componentProps;\n  const state = React.useMemo(() => ({\n    orientation\n  }), [orientation]);\n  const element = useRenderElement('div', componentProps, {\n    state,\n    ref: forwardedRef,\n    props: [{\n      role: 'separator',\n      'aria-orientation': orientation\n    }, elementProps]\n  });\n  return element;\n});\nif (process.env.NODE_ENV !== \"production\") Separator.displayName = \"Separator\";"],"names":[],"mappings":";;;AAWY;AACV;AAAM;AACJ;AACA;AACc;AACX;AAEL;AAAmC;AACjC;AAEF;AAAwD;AACtD;AACK;AACG;AACA;AACc;AACP;AAEjB;AACF;AACA;;;;","x_google_ignoreList":[0]}