@eintrek/erp-theme 1.4.6 → 1.4.7

package/dist/components/ui/select.d.ts

@@ -1,6 +1,6 @@
 import { Select as SelectPrimitive } from "radix-ui";
 import * as React from "react";
-declare function Select({ onValueChange, ...props }: React.ComponentProps<typeof SelectPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function Select({ onValueChange, onOpenChange, open, defaultOpen, ...props }: React.ComponentProps<typeof SelectPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
 declare function SelectGroup({ ...props }: React.ComponentProps<typeof SelectPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
 declare function SelectValue({ ...props }: React.ComponentProps<typeof SelectPrimitive.Value>): import("react/jsx-runtime").JSX.Element;
 declare function SelectTrigger({ className, size, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Trigger> & {

package/dist/index.esm.js

@@ -15986,14 +15986,22 @@ function ScrollBar({ className, orientation = "vertical", ...props }) {
             "h-2.5 flex-col border-t border-t-transparent", className), ...props, children: jsx(ScrollAreaPrimitive.ScrollAreaThumb, { "data-slot": "scroll-area-thumb", className: "bg-border relative flex-1 rounded-full" }) }));
 }
 
-function Select({ onValueChange, ...props }) {
-    return (jsx(SelectPrimitive.Root, { "data-slot": "select", ...props, onValueChange: value => {
-            // Swallow the empty value Radix emits on its own.
+function Select({ onValueChange, onOpenChange, open, defaultOpen, ...props }) {
+    // Tracked in a ref, not state: this only needs to be readable inside the
+    // callback below, and putting it in state would re-render on every open.
+    const isOpenRef = React.useRef(defaultOpen ?? false);
+    if (open !== undefined)
+        isOpenRef.current = open;
+    return (jsx(SelectPrimitive.Root, { "data-slot": "select", ...props, open: open, defaultOpen: defaultOpen, onOpenChange: next => {
+            isOpenRef.current = next;
+            onOpenChange?.(next);
+        }, onValueChange: value => {
+            // Drop ONLY the empty value Radix echoes back on its own.
             //
-            // Radix keeps a hidden native <select> so the control participates in
+            // Radix keeps a hidden native <select> so the control works inside
             // real forms. Whenever the controlled value changes it assigns that
             // value to the native node and dispatches a synthetic change event,
-            // which comes back out through onValueChange:
+            // which comes straight back out through onValueChange:
             //
             //   setValue.call(select, selectValue);
             //   select.dispatchEvent(new Event("change", { bubbles: true }));
@@ -16001,24 +16009,23 @@ function Select({ onValueChange, ...props }) {
             //   onChange: (event) => onValueChange(event.target.value)
             //
             // The native <option> list is registered by SelectItem, and the items
-            // live inside SelectContent — which is portalled and only mounted
-            // while the menu is open. So on a closed select the option for the
-            // incoming value usually does not exist yet, the DOM refuses the
-            // assignment, `select.value` collapses to "", and that empty string is
-            // what every consumer receives.
+            // live inside SelectContent — portalled, and only mounted while the
+            // menu is open. On a closed select the option for the incoming value
+            // usually does not exist yet, the DOM refuses the assignment,
+            // `select.value` collapses to "", and that empty string reaches the
+            // consumer. In a form this lands exactly when saved data arrives: the
+            // field is set to its stored value, Radix echoes "", and the handler
+            // writes that back — enum fields then snap to their fallback and zod
+            // rejects the submit with "received ''".
             //
-            // In practice this fires exactly when server data lands in a form:
-            // the field is set to the saved value, Radix echoes back "", and the
-            // handler writes it into form state. Fields normalised through an
-            // enum/fallback then snap to their default; fields validated by zod
-            // fail on submit with "received ''".
-            //
-            // A genuine selection can never be empty — that path is
-            // `context.onValueChange(value)` from SelectItem's handleSelect, using
-            // the item's own value — so dropping "" costs nothing. Consumers that
-            // really want a "none" option should give it an explicit sentinel
-            // value; Radix reserves "" for the placeholder.
-            if (value === "")
+            // The open check is what keeps a real "none" option working. Radix
+            // does NOT forbid <SelectItem value="">, and picking one is a
+            // legitimate way to clear a selection. A user pick always arrives
+            // while the menu is still open — SelectItem's handleSelect calls
+            // onValueChange(value) BEFORE onOpenChange(false) — whereas the echo
+            // above fires from an effect with the menu closed. So only the closed
+            // case is suppressed.
+            if (value === "" && !isOpenRef.current)
                 return;
             onValueChange?.(value);
         } }));