@bigbinary/neeto-atoms 1.0.9 → 1.0.11

package/dist/cjs/primitives/ScrollArea.js

@@ -5,13 +5,13 @@ var utils = require('../utils-CTr7wn5d.js');
 var React = require('react');
 var index$2 = require('../index-DMbj7vXd.js');
 var index$3 = require('../index-DcCSSgb7.js');
-var index$5 = require('../index-CGUGhyIp.js');
+var index$4 = require('../index-CGUGhyIp.js');
 var index = require('../index-D-iDn9RI.js');
 var index$6 = require('../index-lWVw05cs.js');
 var index$1 = require('../index-9jC1advf.js');
 var index$7 = require('../index-CCdG4z4E.js');
 var index$8 = require('../index-EyWRfsCG.js');
-var index$4 = require('../index-COPkC3I5.js');
+var index$5 = require('../index-COPkC3I5.js');
 require('react-dom');
 
 function _interopNamespace(e) {
@@ -41,7 +41,7 @@ function useStateMachine(initialState, machine) {
   }, initialState);
 }
 var SCROLL_AREA_NAME = "ScrollArea";
-var [createScrollAreaContext] = index$5.createContextScope(SCROLL_AREA_NAME);
+var [createScrollAreaContext] = index$4.createContextScope(SCROLL_AREA_NAME);
 var [ScrollAreaProvider, useScrollAreaContext] = createScrollAreaContext(SCROLL_AREA_NAME);
 var ScrollArea$2 = React__namespace.forwardRef(
   (props, forwardedRef) => {
@@ -254,8 +254,8 @@ var ScrollAreaScrollbarScroll = React__namespace.forwardRef((props, forwardedRef
       "data-state": state === "hidden" ? "hidden" : "visible",
       ...scrollbarProps,
       ref: forwardedRef,
-      onPointerEnter: index$4.composeEventHandlers(props.onPointerEnter, () => send("POINTER_ENTER")),
-      onPointerLeave: index$4.composeEventHandlers(props.onPointerLeave, () => send("POINTER_LEAVE"))
+      onPointerEnter: index$5.composeEventHandlers(props.onPointerEnter, () => send("POINTER_ENTER")),
+      onPointerLeave: index$5.composeEventHandlers(props.onPointerLeave, () => send("POINTER_LEAVE"))
     }
   ) });
 });
@@ -514,7 +514,7 @@ var ScrollAreaScrollbarImpl = React__namespace.forwardRef((props, forwardedRef)
           ...scrollbarProps,
           ref: composeRefs,
           style: { position: "absolute", ...scrollbarProps.style },
-          onPointerDown: index$4.composeEventHandlers(props.onPointerDown, (event) => {
+          onPointerDown: index$5.composeEventHandlers(props.onPointerDown, (event) => {
             const mainPointer = 0;
             if (event.button === mainPointer) {
               const element = event.target;
@@ -526,8 +526,8 @@ var ScrollAreaScrollbarImpl = React__namespace.forwardRef((props, forwardedRef)
               handleDragScroll(event);
             }
           }),
-          onPointerMove: index$4.composeEventHandlers(props.onPointerMove, handleDragScroll),
-          onPointerUp: index$4.composeEventHandlers(props.onPointerUp, (event) => {
+          onPointerMove: index$5.composeEventHandlers(props.onPointerMove, handleDragScroll),
+          onPointerUp: index$5.composeEventHandlers(props.onPointerUp, (event) => {
             const element = event.target;
             if (element.hasPointerCapture(event.pointerId)) {
               element.releasePointerCapture(event.pointerId);
@@ -593,14 +593,14 @@ var ScrollAreaThumbImpl = React__namespace.forwardRef(
           height: "var(--radix-scroll-area-thumb-height)",
           ...style
         },
-        onPointerDownCapture: index$4.composeEventHandlers(props.onPointerDownCapture, (event) => {
+        onPointerDownCapture: index$5.composeEventHandlers(props.onPointerDownCapture, (event) => {
           const thumb = event.target;
           const thumbRect = thumb.getBoundingClientRect();
           const x = event.clientX - thumbRect.left;
           const y = event.clientY - thumbRect.top;
           scrollbarContext.onThumbPointerDown({ x, y });
         }),
-        onPointerUp: index$4.composeEventHandlers(props.onPointerUp, scrollbarContext.onThumbPointerUp)
+        onPointerUp: index$5.composeEventHandlers(props.onPointerUp, scrollbarContext.onThumbPointerUp)
       }
     );
   }

package/dist/cjs/primitives/Select.js

@@ -2,28 +2,28 @@
 
 var jsxRuntime = require('react/jsx-runtime');
 var utils = require('../utils-CTr7wn5d.js');
+var check = require('../check-BQgcDXys.js');
 var chevronDown = require('../chevron-down-CPsWSS51.js');
 var chevronUp = require('../chevron-up-BpwpBnZU.js');
-var check = require('../check-BQgcDXys.js');
 var React = require('react');
 var ReactDOM = require('react-dom');
 var index$g = require('../index-EyWRfsCG.js');
-var index$3 = require('../index-COPkC3I5.js');
-var index$5 = require('../index-Ch55j1or.js');
+var index$8 = require('../index-COPkC3I5.js');
+var index$9 = require('../index-Ch55j1or.js');
 var index = require('../index-D-iDn9RI.js');
-var index$7 = require('../index-CGUGhyIp.js');
-var index$8 = require('../index-9jC1advf.js');
-var index$f = require('../index-Bvu9MiFi.js');
-var index$e = require('../index-ChSOMM8b.js');
-var index$a = require('../index-BwAq9ba8.js');
-var index$1 = require('../index-C9ICrOhM.js');
-var index$b = require('../index-Df-Ffa3s.js');
-var index$2 = require('../index-DMbj7vXd.js');
-var index$6 = require('../index-lWVw05cs.js');
-var index$9 = require('../index-CyrAgb4H.js');
-var index$4 = require('../index-CCdG4z4E.js');
-var index$c = require('../index-CF951Pw9.js');
-var index$d = require('../index-CB9xFokC.js');
+var index$f = require('../index-CGUGhyIp.js');
+var index$1 = require('../index-9jC1advf.js');
+var index$d = require('../index-Bvu9MiFi.js');
+var index$c = require('../index-ChSOMM8b.js');
+var index$4 = require('../index-BwAq9ba8.js');
+var index$3 = require('../index-C9ICrOhM.js');
+var index$5 = require('../index-Df-Ffa3s.js');
+var index$7 = require('../index-DMbj7vXd.js');
+var index$e = require('../index-lWVw05cs.js');
+var index$2 = require('../index-CyrAgb4H.js');
+var index$6 = require('../index-CCdG4z4E.js');
+var index$a = require('../index-CF951Pw9.js');
+var index$b = require('../index-CB9xFokC.js');
 require('../createLucideIcon-D0tRgV6l.js');
 require('../floating-ui.react-dom-B4Aw6O7R.js');
 require('../index-Bf0WsHta.js');
@@ -136,12 +136,12 @@ function getElementRef(element) {
 var OPEN_KEYS = [" ", "Enter", "ArrowUp", "ArrowDown"];
 var SELECTION_KEYS = [" ", "Enter"];
 var SELECT_NAME = "Select";
-var [Collection, useCollection, createCollectionScope] = index$5.createCollection(SELECT_NAME);
-var [createSelectContext] = index$7.createContextScope(SELECT_NAME, [
+var [Collection, useCollection, createCollectionScope] = index$9.createCollection(SELECT_NAME);
+var [createSelectContext] = index$f.createContextScope(SELECT_NAME, [
   createCollectionScope,
-  index$1.createPopperScope
+  index$3.createPopperScope
 ]);
-var usePopperScope = index$1.createPopperScope();
+var usePopperScope = index$3.createPopperScope();
 var [SelectProvider, useSelectContext] = createSelectContext(SELECT_NAME);
 var [SelectNativeOptionsProvider, useSelectNativeOptionsContext] = createSelectContext(SELECT_NAME);
 var Select$2 = (props) => {
@@ -165,14 +165,14 @@ var Select$2 = (props) => {
   const [trigger, setTrigger] = React__namespace.useState(null);
   const [valueNode, setValueNode] = React__namespace.useState(null);
   const [valueNodeHasChildren, setValueNodeHasChildren] = React__namespace.useState(false);
-  const direction = index$8.useDirection(dir);
-  const [open, setOpen] = index$9.useControllableState({
+  const direction = index$1.useDirection(dir);
+  const [open, setOpen] = index$2.useControllableState({
     prop: openProp,
     defaultProp: defaultOpen ?? false,
     onChange: onOpenChange,
     caller: SELECT_NAME
   });
-  const [value, setValue] = index$9.useControllableState({
+  const [value, setValue] = index$2.useControllableState({
     prop: valueProp,
     defaultProp: defaultValue,
     onChange: onValueChange,
@@ -182,7 +182,7 @@ var Select$2 = (props) => {
   const isFormControl = trigger ? form || !!trigger.closest("form") : true;
   const [nativeOptionsSet, setNativeOptionsSet] = React__namespace.useState(/* @__PURE__ */ new Set());
   const nativeSelectKey = Array.from(nativeOptionsSet).map((option) => option.props.value).join(";");
-  return /* @__PURE__ */ jsxRuntime.jsx(index$1.Root2, { ...popperScope, children: /* @__PURE__ */ jsxRuntime.jsxs(
+  return /* @__PURE__ */ jsxRuntime.jsx(index$3.Root2, { ...popperScope, children: /* @__PURE__ */ jsxRuntime.jsxs(
     SelectProvider,
     {
       required,
@@ -193,7 +193,7 @@ var Select$2 = (props) => {
       onValueNodeChange: setValueNode,
       valueNodeHasChildren,
       onValueNodeHasChildrenChange: setValueNodeHasChildren,
-      contentId: index$a.useId(),
+      contentId: index$4.useId(),
       value,
       onValueChange: setValue,
       open,
@@ -273,8 +273,8 @@ var SelectTrigger$2 = React__namespace.forwardRef(
         };
       }
     };
-    return /* @__PURE__ */ jsxRuntime.jsx(index$1.Anchor, { asChild: true, ...popperScope, children: /* @__PURE__ */ jsxRuntime.jsx(
-      index$2.Primitive.button,
+    return /* @__PURE__ */ jsxRuntime.jsx(index$3.Anchor, { asChild: true, ...popperScope, children: /* @__PURE__ */ jsxRuntime.jsx(
+      index$7.Primitive.button,
       {
         type: "button",
         role: "combobox",
@@ -289,13 +289,13 @@ var SelectTrigger$2 = React__namespace.forwardRef(
         "data-placeholder": shouldShowPlaceholder(context.value) ? "" : void 0,
         ...triggerProps,
         ref: composedRefs,
-        onClick: index$3.composeEventHandlers(triggerProps.onClick, (event) => {
+        onClick: index$8.composeEventHandlers(triggerProps.onClick, (event) => {
           event.currentTarget.focus();
           if (pointerTypeRef.current !== "mouse") {
             handleOpen(event);
           }
         }),
-        onPointerDown: index$3.composeEventHandlers(triggerProps.onPointerDown, (event) => {
+        onPointerDown: index$8.composeEventHandlers(triggerProps.onPointerDown, (event) => {
           pointerTypeRef.current = event.pointerType;
           const target = event.target;
           if (target.hasPointerCapture(event.pointerId)) {
@@ -306,7 +306,7 @@ var SelectTrigger$2 = React__namespace.forwardRef(
             event.preventDefault();
           }
         }),
-        onKeyDown: index$3.composeEventHandlers(triggerProps.onKeyDown, (event) => {
+        onKeyDown: index$8.composeEventHandlers(triggerProps.onKeyDown, (event) => {
           const isTypingAhead = searchRef.current !== "";
           const isModifierKey = event.ctrlKey || event.altKey || event.metaKey;
           if (!isModifierKey && event.key.length === 1) handleTypeaheadSearch(event.key);
@@ -329,11 +329,11 @@ var SelectValue$2 = React__namespace.forwardRef(
     const { onValueNodeHasChildrenChange } = context;
     const hasChildren = children !== void 0;
     const composedRefs = index.useComposedRefs(forwardedRef, context.onValueNodeChange);
-    index$4.useLayoutEffect2(() => {
+    index$6.useLayoutEffect2(() => {
       onValueNodeHasChildrenChange(hasChildren);
     }, [onValueNodeHasChildrenChange, hasChildren]);
     return /* @__PURE__ */ jsxRuntime.jsx(
-      index$2.Primitive.span,
+      index$7.Primitive.span,
       {
         ...valueProps,
         ref: composedRefs,
@@ -348,13 +348,13 @@ var ICON_NAME = "SelectIcon";
 var SelectIcon = React__namespace.forwardRef(
   (props, forwardedRef) => {
     const { __scopeSelect, children, ...iconProps } = props;
-    return /* @__PURE__ */ jsxRuntime.jsx(index$2.Primitive.span, { "aria-hidden": true, ...iconProps, ref: forwardedRef, children: children || "\u25BC" });
+    return /* @__PURE__ */ jsxRuntime.jsx(index$7.Primitive.span, { "aria-hidden": true, ...iconProps, ref: forwardedRef, children: children || "\u25BC" });
   }
 );
 SelectIcon.displayName = ICON_NAME;
 var PORTAL_NAME = "SelectPortal";
 var SelectPortal = (props) => {
-  return /* @__PURE__ */ jsxRuntime.jsx(index$b.Portal, { asChild: true, ...props });
+  return /* @__PURE__ */ jsxRuntime.jsx(index$5.Portal, { asChild: true, ...props });
 };
 SelectPortal.displayName = PORTAL_NAME;
 var CONTENT_NAME = "SelectContent";
@@ -362,7 +362,7 @@ var SelectContent$2 = React__namespace.forwardRef(
   (props, forwardedRef) => {
     const context = useSelectContext(CONTENT_NAME, props.__scopeSelect);
     const [fragment, setFragment] = React__namespace.useState();
-    index$4.useLayoutEffect2(() => {
+    index$6.useLayoutEffect2(() => {
       setFragment(new DocumentFragment());
     }, []);
     if (!context.open) {
@@ -415,9 +415,9 @@ var SelectContentImpl = React__namespace.forwardRef(
     const [isPositioned, setIsPositioned] = React__namespace.useState(false);
     const firstValidItemFoundRef = React__namespace.useRef(false);
     React__namespace.useEffect(() => {
-      if (content) return index$e.hideOthers(content);
+      if (content) return index$c.hideOthers(content);
     }, [content]);
-    index$e.useFocusGuards();
+    index$c.useFocusGuards();
     const focusFirst = React__namespace.useCallback(
       (candidates) => {
         const [firstItem, ...restItems] = getItems().map((item) => item.ref.current);
@@ -542,20 +542,20 @@ var SelectContentImpl = React__namespace.forwardRef(
         position,
         isPositioned,
         searchRef,
-        children: /* @__PURE__ */ jsxRuntime.jsx(index$e.ReactRemoveScroll, { as: Slot, allowPinchZoom: true, children: /* @__PURE__ */ jsxRuntime.jsx(
-          index$e.FocusScope,
+        children: /* @__PURE__ */ jsxRuntime.jsx(index$c.ReactRemoveScroll, { as: Slot, allowPinchZoom: true, children: /* @__PURE__ */ jsxRuntime.jsx(
+          index$c.FocusScope,
           {
             asChild: true,
             trapped: context.open,
             onMountAutoFocus: (event) => {
               event.preventDefault();
             },
-            onUnmountAutoFocus: index$3.composeEventHandlers(onCloseAutoFocus, (event) => {
+            onUnmountAutoFocus: index$8.composeEventHandlers(onCloseAutoFocus, (event) => {
               context.trigger?.focus({ preventScroll: true });
               event.preventDefault();
             }),
             children: /* @__PURE__ */ jsxRuntime.jsx(
-              index$f.DismissableLayer,
+              index$d.DismissableLayer,
               {
                 asChild: true,
                 disableOutsidePointerEvents: true,
@@ -583,7 +583,7 @@ var SelectContentImpl = React__namespace.forwardRef(
                       outline: "none",
                       ...contentProps.style
                     },
-                    onKeyDown: index$3.composeEventHandlers(contentProps.onKeyDown, (event) => {
+                    onKeyDown: index$8.composeEventHandlers(contentProps.onKeyDown, (event) => {
                       const isModifierKey = event.ctrlKey || event.altKey || event.metaKey;
                       if (event.key === "Tab") event.preventDefault();
                       if (!isModifierKey && event.key.length === 1) handleTypeaheadSearch(event.key);
@@ -724,9 +724,9 @@ var SelectItemAlignedPosition = React__namespace.forwardRef((props, forwardedRef
     context.dir,
     onPlaced
   ]);
-  index$4.useLayoutEffect2(() => position(), [position]);
+  index$6.useLayoutEffect2(() => position(), [position]);
   const [contentZIndex, setContentZIndex] = React__namespace.useState();
-  index$4.useLayoutEffect2(() => {
+  index$6.useLayoutEffect2(() => {
     if (content) setContentZIndex(window.getComputedStyle(content).zIndex);
   }, [content]);
   const handleScrollButtonChange = React__namespace.useCallback(
@@ -757,7 +757,7 @@ var SelectItemAlignedPosition = React__namespace.forwardRef((props, forwardedRef
             zIndex: contentZIndex
           },
           children: /* @__PURE__ */ jsxRuntime.jsx(
-            index$2.Primitive.div,
+            index$7.Primitive.div,
             {
               ...popperProps,
               ref: composedRefs,
@@ -787,7 +787,7 @@ var SelectPopperPosition = React__namespace.forwardRef((props, forwardedRef) =>
   } = props;
   const popperScope = usePopperScope(__scopeSelect);
   return /* @__PURE__ */ jsxRuntime.jsx(
-    index$1.Content,
+    index$3.Content,
     {
       ...popperScope,
       ...popperProps,
@@ -831,7 +831,7 @@ var SelectViewport = React__namespace.forwardRef(
         }
       ),
       /* @__PURE__ */ jsxRuntime.jsx(Collection.Slot, { scope: __scopeSelect, children: /* @__PURE__ */ jsxRuntime.jsx(
-        index$2.Primitive.div,
+        index$7.Primitive.div,
         {
           "data-radix-select-viewport": "",
           role: "presentation",
@@ -850,7 +850,7 @@ var SelectViewport = React__namespace.forwardRef(
             overflow: "hidden auto",
             ...viewportProps.style
           },
-          onScroll: index$3.composeEventHandlers(viewportProps.onScroll, (event) => {
+          onScroll: index$8.composeEventHandlers(viewportProps.onScroll, (event) => {
             const viewport = event.currentTarget;
             const { contentWrapper, shouldExpandOnScrollRef } = viewportContext;
             if (shouldExpandOnScrollRef?.current && contentWrapper) {
@@ -885,8 +885,8 @@ var [SelectGroupContextProvider, useSelectGroupContext] = createSelectContext(GR
 var SelectGroup$2 = React__namespace.forwardRef(
   (props, forwardedRef) => {
     const { __scopeSelect, ...groupProps } = props;
-    const groupId = index$a.useId();
-    return /* @__PURE__ */ jsxRuntime.jsx(SelectGroupContextProvider, { scope: __scopeSelect, id: groupId, children: /* @__PURE__ */ jsxRuntime.jsx(index$2.Primitive.div, { role: "group", "aria-labelledby": groupId, ...groupProps, ref: forwardedRef }) });
+    const groupId = index$4.useId();
+    return /* @__PURE__ */ jsxRuntime.jsx(SelectGroupContextProvider, { scope: __scopeSelect, id: groupId, children: /* @__PURE__ */ jsxRuntime.jsx(index$7.Primitive.div, { role: "group", "aria-labelledby": groupId, ...groupProps, ref: forwardedRef }) });
   }
 );
 SelectGroup$2.displayName = GROUP_NAME;
@@ -895,7 +895,7 @@ var SelectLabel$2 = React__namespace.forwardRef(
   (props, forwardedRef) => {
     const { __scopeSelect, ...labelProps } = props;
     const groupContext = useSelectGroupContext(LABEL_NAME, __scopeSelect);
-    return /* @__PURE__ */ jsxRuntime.jsx(index$2.Primitive.div, { id: groupContext.id, ...labelProps, ref: forwardedRef });
+    return /* @__PURE__ */ jsxRuntime.jsx(index$7.Primitive.div, { id: groupContext.id, ...labelProps, ref: forwardedRef });
   }
 );
 SelectLabel$2.displayName = LABEL_NAME;
@@ -919,7 +919,7 @@ var SelectItem$2 = React__namespace.forwardRef(
       forwardedRef,
       (node) => contentContext.itemRefCallback?.(node, value, disabled)
     );
-    const textId = index$a.useId();
+    const textId = index$4.useId();
     const pointerTypeRef = React__namespace.useRef("touch");
     const handleSelect = () => {
       if (!disabled) {
@@ -951,7 +951,7 @@ var SelectItem$2 = React__namespace.forwardRef(
             disabled,
             textValue,
             children: /* @__PURE__ */ jsxRuntime.jsx(
-              index$2.Primitive.div,
+              index$7.Primitive.div,
               {
                 role: "option",
                 "aria-labelledby": textId,
@@ -963,18 +963,18 @@ var SelectItem$2 = React__namespace.forwardRef(
                 tabIndex: disabled ? void 0 : -1,
                 ...itemProps,
                 ref: composedRefs,
-                onFocus: index$3.composeEventHandlers(itemProps.onFocus, () => setIsFocused(true)),
-                onBlur: index$3.composeEventHandlers(itemProps.onBlur, () => setIsFocused(false)),
-                onClick: index$3.composeEventHandlers(itemProps.onClick, () => {
+                onFocus: index$8.composeEventHandlers(itemProps.onFocus, () => setIsFocused(true)),
+                onBlur: index$8.composeEventHandlers(itemProps.onBlur, () => setIsFocused(false)),
+                onClick: index$8.composeEventHandlers(itemProps.onClick, () => {
                   if (pointerTypeRef.current !== "mouse") handleSelect();
                 }),
-                onPointerUp: index$3.composeEventHandlers(itemProps.onPointerUp, () => {
+                onPointerUp: index$8.composeEventHandlers(itemProps.onPointerUp, () => {
                   if (pointerTypeRef.current === "mouse") handleSelect();
                 }),
-                onPointerDown: index$3.composeEventHandlers(itemProps.onPointerDown, (event) => {
+                onPointerDown: index$8.composeEventHandlers(itemProps.onPointerDown, (event) => {
                   pointerTypeRef.current = event.pointerType;
                 }),
-                onPointerMove: index$3.composeEventHandlers(itemProps.onPointerMove, (event) => {
+                onPointerMove: index$8.composeEventHandlers(itemProps.onPointerMove, (event) => {
                   pointerTypeRef.current = event.pointerType;
                   if (disabled) {
                     contentContext.onItemLeave?.();
@@ -982,12 +982,12 @@ var SelectItem$2 = React__namespace.forwardRef(
                     event.currentTarget.focus({ preventScroll: true });
                   }
                 }),
-                onPointerLeave: index$3.composeEventHandlers(itemProps.onPointerLeave, (event) => {
+                onPointerLeave: index$8.composeEventHandlers(itemProps.onPointerLeave, (event) => {
                   if (event.currentTarget === document.activeElement) {
                     contentContext.onItemLeave?.();
                   }
                 }),
-                onKeyDown: index$3.composeEventHandlers(itemProps.onKeyDown, (event) => {
+                onKeyDown: index$8.composeEventHandlers(itemProps.onKeyDown, (event) => {
                   const isTypingAhead = contentContext.searchRef?.current !== "";
                   if (isTypingAhead && event.key === " ") return;
                   if (SELECTION_KEYS.includes(event.key)) handleSelect();
@@ -1023,12 +1023,12 @@ var SelectItemText = React__namespace.forwardRef(
       [itemContext.disabled, itemContext.value, textContent]
     );
     const { onNativeOptionAdd, onNativeOptionRemove } = nativeOptionsContext;
-    index$4.useLayoutEffect2(() => {
+    index$6.useLayoutEffect2(() => {
       onNativeOptionAdd(nativeOption);
       return () => onNativeOptionRemove(nativeOption);
     }, [onNativeOptionAdd, onNativeOptionRemove, nativeOption]);
     return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-      /* @__PURE__ */ jsxRuntime.jsx(index$2.Primitive.span, { id: itemContext.textId, ...itemTextProps, ref: composedRefs }),
+      /* @__PURE__ */ jsxRuntime.jsx(index$7.Primitive.span, { id: itemContext.textId, ...itemTextProps, ref: composedRefs }),
       itemContext.isSelected && context.valueNode && !context.valueNodeHasChildren ? ReactDOM__namespace.createPortal(itemTextProps.children, context.valueNode) : null
     ] });
   }
@@ -1039,7 +1039,7 @@ var SelectItemIndicator = React__namespace.forwardRef(
   (props, forwardedRef) => {
     const { __scopeSelect, ...itemIndicatorProps } = props;
     const itemContext = useSelectItemContext(ITEM_INDICATOR_NAME, __scopeSelect);
-    return itemContext.isSelected ? /* @__PURE__ */ jsxRuntime.jsx(index$2.Primitive.span, { "aria-hidden": true, ...itemIndicatorProps, ref: forwardedRef }) : null;
+    return itemContext.isSelected ? /* @__PURE__ */ jsxRuntime.jsx(index$7.Primitive.span, { "aria-hidden": true, ...itemIndicatorProps, ref: forwardedRef }) : null;
   }
 );
 SelectItemIndicator.displayName = ITEM_INDICATOR_NAME;
@@ -1049,7 +1049,7 @@ var SelectScrollUpButton$2 = React__namespace.forwardRef((props, forwardedRef) =
   const viewportContext = useSelectViewportContext(SCROLL_UP_BUTTON_NAME, props.__scopeSelect);
   const [canScrollUp, setCanScrollUp] = React__namespace.useState(false);
   const composedRefs = index.useComposedRefs(forwardedRef, viewportContext.onScrollButtonChange);
-  index$4.useLayoutEffect2(() => {
+  index$6.useLayoutEffect2(() => {
     if (contentContext.viewport && contentContext.isPositioned) {
       let handleScroll2 = function() {
         const canScrollUp2 = viewport.scrollTop > 0;
@@ -1082,7 +1082,7 @@ var SelectScrollDownButton$2 = React__namespace.forwardRef((props, forwardedRef)
   const viewportContext = useSelectViewportContext(SCROLL_DOWN_BUTTON_NAME, props.__scopeSelect);
   const [canScrollDown, setCanScrollDown] = React__namespace.useState(false);
   const composedRefs = index.useComposedRefs(forwardedRef, viewportContext.onScrollButtonChange);
-  index$4.useLayoutEffect2(() => {
+  index$6.useLayoutEffect2(() => {
     if (contentContext.viewport && contentContext.isPositioned) {
       let handleScroll2 = function() {
         const maxScroll = viewport.scrollHeight - viewport.clientHeight;
@@ -1124,29 +1124,29 @@ var SelectScrollButtonImpl = React__namespace.forwardRef((props, forwardedRef) =
   React__namespace.useEffect(() => {
     return () => clearAutoScrollTimer();
   }, [clearAutoScrollTimer]);
-  index$4.useLayoutEffect2(() => {
+  index$6.useLayoutEffect2(() => {
     const activeItem = getItems().find((item) => item.ref.current === document.activeElement);
     activeItem?.ref.current?.scrollIntoView({ block: "nearest" });
   }, [getItems]);
   return /* @__PURE__ */ jsxRuntime.jsx(
-    index$2.Primitive.div,
+    index$7.Primitive.div,
     {
       "aria-hidden": true,
       ...scrollIndicatorProps,
       ref: forwardedRef,
       style: { flexShrink: 0, ...scrollIndicatorProps.style },
-      onPointerDown: index$3.composeEventHandlers(scrollIndicatorProps.onPointerDown, () => {
+      onPointerDown: index$8.composeEventHandlers(scrollIndicatorProps.onPointerDown, () => {
         if (autoScrollTimerRef.current === null) {
           autoScrollTimerRef.current = window.setInterval(onAutoScroll, 50);
         }
       }),
-      onPointerMove: index$3.composeEventHandlers(scrollIndicatorProps.onPointerMove, () => {
+      onPointerMove: index$8.composeEventHandlers(scrollIndicatorProps.onPointerMove, () => {
         contentContext.onItemLeave?.();
         if (autoScrollTimerRef.current === null) {
           autoScrollTimerRef.current = window.setInterval(onAutoScroll, 50);
         }
       }),
-      onPointerLeave: index$3.composeEventHandlers(scrollIndicatorProps.onPointerLeave, () => {
+      onPointerLeave: index$8.composeEventHandlers(scrollIndicatorProps.onPointerLeave, () => {
         clearAutoScrollTimer();
       })
     }
@@ -1156,7 +1156,7 @@ var SEPARATOR_NAME = "SelectSeparator";
 var SelectSeparator$2 = React__namespace.forwardRef(
   (props, forwardedRef) => {
     const { __scopeSelect, ...separatorProps } = props;
-    return /* @__PURE__ */ jsxRuntime.jsx(index$2.Primitive.div, { "aria-hidden": true, ...separatorProps, ref: forwardedRef });
+    return /* @__PURE__ */ jsxRuntime.jsx(index$7.Primitive.div, { "aria-hidden": true, ...separatorProps, ref: forwardedRef });
   }
 );
 SelectSeparator$2.displayName = SEPARATOR_NAME;
@@ -1167,7 +1167,7 @@ var SelectArrow = React__namespace.forwardRef(
     const popperScope = usePopperScope(__scopeSelect);
     const context = useSelectContext(ARROW_NAME, __scopeSelect);
     const contentContext = useSelectContentContext(ARROW_NAME, __scopeSelect);
-    return context.open && contentContext.position === "popper" ? /* @__PURE__ */ jsxRuntime.jsx(index$1.Arrow, { ...popperScope, ...arrowProps, ref: forwardedRef }) : null;
+    return context.open && contentContext.position === "popper" ? /* @__PURE__ */ jsxRuntime.jsx(index$3.Arrow, { ...popperScope, ...arrowProps, ref: forwardedRef }) : null;
   }
 );
 SelectArrow.displayName = ARROW_NAME;
@@ -1176,7 +1176,7 @@ var SelectBubbleInput = React__namespace.forwardRef(
   ({ __scopeSelect, value, ...props }, forwardedRef) => {
     const ref = React__namespace.useRef(null);
     const composedRefs = index.useComposedRefs(forwardedRef, ref);
-    const prevValue = index$c.usePrevious(value);
+    const prevValue = index$a.usePrevious(value);
     React__namespace.useEffect(() => {
       const select = ref.current;
       if (!select) return;
@@ -1193,10 +1193,10 @@ var SelectBubbleInput = React__namespace.forwardRef(
       }
     }, [prevValue, value]);
     return /* @__PURE__ */ jsxRuntime.jsx(
-      index$2.Primitive.select,
+      index$7.Primitive.select,
       {
         ...props,
-        style: { ...index$d.VISUALLY_HIDDEN_STYLES, ...props.style },
+        style: { ...index$b.VISUALLY_HIDDEN_STYLES, ...props.style },
         ref: composedRefs,
         defaultValue: value
       }
@@ -1208,7 +1208,7 @@ function shouldShowPlaceholder(value) {
   return value === "" || value === void 0;
 }
 function useTypeaheadSearch(onSearchChange) {
-  const handleSearchChange = index$6.useCallbackRef(onSearchChange);
+  const handleSearchChange = index$e.useCallbackRef(onSearchChange);
   const searchRef = React__namespace.useRef("");
   const timerRef = React__namespace.useRef(0);
   const handleTypeaheadSearch = React__namespace.useCallback(

package/dist/cjs/primitives/index.js

@@ -9,7 +9,7 @@ var primitives_Badge = require('./Badge.js');
 var primitives_Breadcrumb = require('./Breadcrumb.js');
 var primitives_Button = require('./Button.js');
 var primitives_ButtonGroup = require('./ButtonGroup.js');
-var primitives_Calendar = require('./Calendar.js');
+var primitives_Calendar = require('../Calendar-Nk76Y9yP.js');
 var primitives_Card = require('./Card.js');
 var primitives_Carousel = require('./Carousel.js');
 var primitives_Chart = require('./Chart.js');
@@ -88,7 +88,8 @@ require('../ellipsis-4aubOI2n.js');
 require('../chevron-right-0jNdwX2Q.js');
 require('../separator-CPy2gyg1.js');
 require('../chevron-left-BldoOh5p.js');
-require('../with-selector-u4xTSzCv.js');
+require('../redux-DEF7lAd1.js');
+require('../with-selector-DeKHbQY7.js');
 require('../check-BQgcDXys.js');
 require('../index-CF951Pw9.js');
 require('../index-Bf0WsHta.js');

package/dist/cjs/primitives/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}