@jobber/components 8.23.0 → 8.23.1

package/dist/InputNumberExperimental-es.js

@@ -6,17 +6,22 @@ import { A as ActivityIndicator } from './ActivityIndicator-es.js';
 import { B as Button } from './Button-es.js';
 import { I as Icon } from './Icon-es.js';
 import { f as formatErrorMessage, a as useRefWithInit, m as mergeProps, E as EMPTY_OBJECT, u as useRenderElement } from './useRenderElement-es.js';
-import { u as useBaseUiId, b as useStableCallback, h as useTimeout, S as SafeReact, j as error, t as transitionStatusMapping, k as useTransitionStatus, a as useIsoLayoutEffect, f as useOpenChangeComplete } from './useButton-es.js';
-import { u as useLabelableContext, L as LabelableContext, a as useFormContext, D as DEFAULT_VALIDITY_STATE, g as getCombinedFieldValidityData, f as fieldValidityMapping, F as FieldRootContext, b as useFieldRootContext } from './useLabelableId-es.js';
+import { u as useBaseUiId, b as useStableCallback, h as useTimeout, a as useIsoLayoutEffect, S as SafeReact, j as error, t as transitionStatusMapping, k as useTransitionStatus, f as useOpenChangeComplete } from './useButton-es.js';
+import { u as useLabelableContext, L as LabelableContext, a as useFormContext, D as DEFAULT_VALIDITY_STATE, f as fieldValidityMapping, F as FieldRootContext, b as useFieldRootContext } from './useLabelableId-es.js';
 import { jsx } from 'react/jsx-runtime';
 import { N as NumberFieldRoot, a as NumberFieldGroup, b as NumberFieldInput, c as NumberFieldIncrement, d as NumberFieldDecrement } from './NumberFieldInput-es.js';
 import { u as useLabel } from './useLabel-es.js';
 
-const FieldsetRootContext = /*#__PURE__*/React.createContext({
-  legendId: undefined,
-  setLegendId: () => {},
-  disabled: undefined
+const FieldItemContext = /*#__PURE__*/React.createContext({
+  disabled: false
 });
+if (process.env.NODE_ENV !== "production") FieldItemContext.displayName = "FieldItemContext";
+function useFieldItemContext() {
+  const context = React.useContext(FieldItemContext);
+  return context;
+}
+
+const FieldsetRootContext = /*#__PURE__*/React.createContext(undefined);
 if (process.env.NODE_ENV !== "production") FieldsetRootContext.displayName = "FieldsetRootContext";
 function useFieldsetRootContext(optional = false) {
   const context = React.useContext(FieldsetRootContext);
@@ -64,9 +69,12 @@ const LabelableProvider = function LabelableProvider(props) {
     });
   });
   const getDescriptionProps = React.useCallback(externalProps => {
-    return mergeProps({
-      'aria-describedby': parentMessageIds.concat(messageIds).join(' ') || undefined
-    }, externalProps);
+    const ids = externalProps['aria-describedby'] ? externalProps['aria-describedby'].split(' ') : [];
+    ids.push(...parentMessageIds, ...messageIds);
+    return {
+      ...externalProps,
+      'aria-describedby': Array.from(new Set(ids)).join(' ') || undefined
+    };
   }, [parentMessageIds, messageIds]);
   const contextValue = React.useMemo(() => ({
     controlId,
@@ -84,6 +92,20 @@ const LabelableProvider = function LabelableProvider(props) {
 };
 if (process.env.NODE_ENV !== "production") LabelableProvider.displayName = "LabelableProvider";
 
+/**
+ * Combines the field's client-side, stateful validity data with the external invalid state to
+ * determine the field's true validity.
+ */
+function getCombinedFieldValidityData(validityData, invalid) {
+  return {
+    ...validityData,
+    state: {
+      ...validityData.state,
+      valid: !invalid && validityData.state.valid
+    }
+  };
+}
+
 const validityKeys = Object.keys(DEFAULT_VALIDITY_STATE);
 function isOnlyValueMissing(state) {
   if (!state || state.valid || !state.valueMissing) {
@@ -96,17 +118,45 @@ function isOnlyValueMissing(state) {
     }
     if (key === 'valueMissing') {
       onlyValueMissing = state[key];
-    }
-    if (state[key]) {
+    } else if (state[key]) {
       onlyValueMissing = false;
     }
   }
   return onlyValueMissing;
 }
+
+/**
+ * Picks the input whose native validity should represent a field that owns several inputs (such as a
+ * checkbox group). Prefers the first enabled currently-invalid input, where "first" follows Set
+ * insertion order (mount order), and otherwise returns the first enabled input. Disabled inputs are
+ * skipped because they don't participate in native constraint validation.
+ */
+function findRepresentativeInput(inputs) {
+  let fallback = null;
+  for (const input of inputs) {
+    if (input.disabled) {
+      continue;
+    }
+    if (!input.validity.valid) {
+      return input;
+    }
+    fallback ??= input;
+  }
+  return fallback;
+}
+function clearCustomValidity(element, inputs) {
+  let didClearElement = false;
+  for (const input of inputs) {
+    input.setCustomValidity('');
+    didClearElement ||= input === element;
+  }
+  if (!didClearElement) {
+    element.setCustomValidity('');
+  }
+}
 function useFieldValidation(params) {
   const {
-    formRef,
-    clearErrors
+    formRef
   } = useFormContext();
   const {
     setValidityData,
@@ -116,8 +166,8 @@ function useFieldValidation(params) {
     invalid,
     markedDirtyRef,
     state,
-    name,
-    shouldValidateOnChange
+    shouldValidateOnChange,
+    getRegisteredFieldId
   } = params;
   const {
     controlId,
@@ -125,11 +175,45 @@ function useFieldValidation(params) {
   } = useLabelableContext();
   const timeout = useTimeout();
   const inputRef = React.useRef(null);
+  const registeredInputs = useRefWithInit(() => new Set()).current;
+  const validationCommitIdRef = React.useRef(0);
+
+  // Checkbox groups register several inputs against a single field. Track them so a `required`
+  // checkbox can't be satisfied by another input in the group, matching native per-checkbox behavior.
+  const registerInput = React.useCallback(element => {
+    if (!element) {
+      return undefined;
+    }
+    registeredInputs.add(element);
+    return () => {
+      registeredInputs.delete(element);
+    };
+  }, [registeredInputs]);
   const commit = useStableCallback(async (value, revalidate = false) => {
-    const element = inputRef.current;
+    // A field can own several inputs (a checkbox group), but only the last-mounted one wins the shared
+    // `inputRef`. Validate against the registry instead so every input counts; `inputRef` is the
+    // fallback only when no registered input applies (none registered, or all of them disabled).
+    const element = findRepresentativeInput(registeredInputs) ?? inputRef.current;
     if (!element) {
       return;
     }
+    validationCommitIdRef.current += 1;
+    const validationCommitId = validationCommitIdRef.current;
+    function updateRegisteredFieldValidity(nextValidityData, externalInvalid = invalid) {
+      const fieldId = getRegisteredFieldId() ?? controlId;
+      if (fieldId == null) {
+        return;
+      }
+      const currentFieldData = formRef.current.fields.get(fieldId);
+      if (!currentFieldData) {
+        return;
+      }
+      const validityDataWithFormErrors = getCombinedFieldValidityData(nextValidityData, externalInvalid);
+      formRef.current.fields.set(fieldId, {
+        ...currentFieldData,
+        validityData: validityDataWithFormErrors
+      });
+    }
     if (revalidate) {
       if (state.valid !== false) {
         return;
@@ -149,16 +233,10 @@ function useFieldValidation(params) {
           errors: [],
           initialValue: validityData.initialValue
         };
-        element.setCustomValidity('');
-        if (controlId) {
-          const currentFieldData = formRef.current.fields.get(controlId);
-          if (currentFieldData) {
-            formRef.current.fields.set(controlId, {
-              ...currentFieldData,
-              ...getCombinedFieldValidityData(nextValidityData, false) // invalid = false
-            });
-          }
-        }
+        clearCustomValidity(element, registeredInputs);
+
+        // The required value is now present; ignore stale external invalid state for this pass.
+        updateRegisteredFieldValidity(nextValidityData, false);
         setValidityData(nextValidityData);
         return;
       }
@@ -209,8 +287,8 @@ function useFieldValidation(params) {
     let validationErrors = [];
     const nextState = getState(element);
     let defaultValidationMessage;
-    const validateOnChange = shouldValidateOnChange();
-    if (element.validationMessage && !validateOnChange) {
+    const isValidatingOnChange = shouldValidateOnChange();
+    if (element.validationMessage && !isValidatingOnChange) {
       // not validating on change, if there is a `validationMessage` from
       // native validity, set errors and skip calling the custom validate fn
       defaultValidationMessage = element.validationMessage;
@@ -228,6 +306,9 @@ function useFieldValidation(params) {
       const resultOrPromise = validate(value, formValues);
       if (typeof resultOrPromise === 'object' && resultOrPromise !== null && 'then' in resultOrPromise) {
         result = await resultOrPromise;
+        if (validationCommitId !== validationCommitIdRef.current) {
+          return;
+        }
       } else {
         result = resultOrPromise;
       }
@@ -241,10 +322,10 @@ function useFieldValidation(params) {
           validationErrors = [result];
           element.setCustomValidity(result);
         }
-      } else if (validateOnChange) {
+      } else if (isValidatingOnChange) {
         // validate function returned no errors, if validating on change
         // we need to clear the custom validity state
-        element.setCustomValidity('');
+        clearCustomValidity(element, registeredInputs);
         nextState.customError = false;
         if (element.validationMessage) {
           defaultValidationMessage = element.validationMessage;
@@ -261,57 +342,153 @@ function useFieldValidation(params) {
       errors: validationErrors,
       initialValue: validityData.initialValue
     };
-    if (controlId) {
-      const currentFieldData = formRef.current.fields.get(controlId);
-      if (currentFieldData) {
-        formRef.current.fields.set(controlId, {
-          ...currentFieldData,
-          // Keep Form-level errors part of overall field validity for submit blocking/focus logic.
-          ...getCombinedFieldValidityData(nextValidityData, invalid)
-        });
-      }
-    }
+
+    // Keep Form-level errors part of overall field validity for submit blocking/focus logic.
+    updateRegisteredFieldValidity(nextValidityData);
     setValidityData(nextValidityData);
   });
-  const getValidationProps = React.useCallback((externalProps = {}) => mergeProps(getDescriptionProps, state.valid === false ? {
+  const change = useStableCallback(value => {
+    timeout.clear();
+    const validateOnChange = shouldValidateOnChange();
+    if (validateOnChange && value !== '' && validationDebounceTime) {
+      validationCommitIdRef.current += 1;
+      timeout.start(validationDebounceTime, () => {
+        commit(value);
+      });
+    } else {
+      commit(value, !validateOnChange);
+    }
+  });
+  const getValidationProps = React.useCallback((disabled, externalProps = {}) => mergeProps(getDescriptionProps(externalProps), state.valid === false && !state.disabled && !disabled ? {
     'aria-invalid': true
-  } : EMPTY_OBJECT, externalProps), [getDescriptionProps, state.valid]);
-  const getInputValidationProps = React.useCallback((externalProps = {}) => mergeProps({
-    onChange(event) {
-      // Workaround for https://github.com/facebook/react/issues/9023
-      if (event.nativeEvent.defaultPrevented) {
-        return;
-      }
-      clearErrors(name);
-      if (!shouldValidateOnChange()) {
-        commit(event.currentTarget.value, true);
-        return;
-      }
+  } : EMPTY_OBJECT), [getDescriptionProps, state.disabled, state.valid]);
+  return React.useMemo(() => ({
+    getValidationProps,
+    inputRef,
+    registerInput,
+    commit,
+    change
+  }), [getValidationProps, registerInput, commit, change]);
+}
 
-      // When validating on change, run client-side validation even if
-      // externally invalid
-      const element = event.currentTarget;
-      if (element.value === '') {
-        // Ignore the debounce time for empty values.
-        commit(element.value);
-        return;
+function useFieldControlRegistration(params) {
+  const {
+    commit,
+    invalid,
+    markedDirtyRef,
+    name,
+    setRegisteredFieldName,
+    setRegisteredFieldId,
+    setValidityData,
+    validityData
+  } = params;
+  const {
+    formRef
+  } = useFormContext();
+  const activeFieldControlSourceRef = React.useRef(null);
+  const registrationRef = React.useRef(null);
+  const fallbackControlRef = React.useRef(null);
+  const getValueForForm = useStableCallback(() => {
+    const registration = registrationRef.current;
+    if (!registration) {
+      return undefined;
+    }
+    if (registration.getValue) {
+      return registration.getValue();
+    }
+    return registration.value;
+  });
+  function getRegistrationValue(registration) {
+    return registration.value === undefined ? getValueForForm() : registration.value;
+  }
+  const validate = useStableCallback(() => {
+    const registration = registrationRef.current;
+    markedDirtyRef.current = true;
+    if (!registration) {
+      commit(validityData.value);
+      return;
+    }
+    commit(getRegistrationValue(registration));
+  });
+  function refreshRegistration() {
+    const registration = registrationRef.current;
+    if (!registration || !registration.id) {
+      return;
+    }
+    formRef.current.fields.set(registration.id, {
+      getValue: getValueForForm,
+      name: name ?? registration.name,
+      controlRef: registration.controlRef ?? fallbackControlRef,
+      validityData: getCombinedFieldValidityData(validityData, invalid),
+      validate
+    });
+  }
+  function deleteRegistration(id = registrationRef.current?.id) {
+    if (id) {
+      formRef.current.fields.delete(id);
+    }
+  }
+  function syncInitialValue() {
+    const registration = registrationRef.current;
+    if (!registration) {
+      return;
+    }
+    const initialValue = getRegistrationValue(registration);
+    if (validityData.initialValue === null && initialValue !== null) {
+      setValidityData(prev => ({
+        ...prev,
+        initialValue
+      }));
+    }
+  }
+  useIsoLayoutEffect(() => {
+    const registration = registrationRef.current;
+    if (!registration || !registration.id) {
+      return;
+    }
+    setRegisteredFieldName(name ? undefined : registration.name);
+    formRef.current.fields.set(registration.id, {
+      getValue: getValueForForm,
+      name: name ?? registration.name,
+      controlRef: registration.controlRef ?? fallbackControlRef,
+      validityData: getCombinedFieldValidityData(validityData, invalid),
+      validate
+    });
+  }, [formRef, getValueForForm, invalid, name, setRegisteredFieldName, validate, validityData]);
+  useIsoLayoutEffect(() => {
+    const fields = formRef.current.fields;
+    return () => {
+      const id = registrationRef.current?.id;
+      if (id) {
+        fields.delete(id);
       }
-      timeout.clear();
-      if (validationDebounceTime) {
-        timeout.start(validationDebounceTime, () => {
-          commit(element.value);
-        });
-      } else {
-        commit(element.value);
+    };
+  }, [formRef]);
+  const register = useStableCallback((source, registration) => {
+    if (!registration) {
+      if (activeFieldControlSourceRef.current === source) {
+        activeFieldControlSourceRef.current = null;
+        deleteRegistration();
+        registrationRef.current = null;
+        setRegisteredFieldName(undefined);
+        setRegisteredFieldId(undefined);
       }
+      return;
     }
-  }, getValidationProps(externalProps)), [getValidationProps, clearErrors, name, timeout, commit, validationDebounceTime, shouldValidateOnChange]);
-  return React.useMemo(() => ({
-    getValidationProps,
-    getInputValidationProps,
-    inputRef,
-    commit
-  }), [getValidationProps, getInputValidationProps, commit]);
+    const previousId = registrationRef.current?.id;
+    activeFieldControlSourceRef.current = source;
+    registrationRef.current = registration;
+    if (!name) {
+      setRegisteredFieldName(registration.name);
+    }
+    setRegisteredFieldId(registration.id);
+    if (previousId && previousId !== registration.id) {
+      deleteRegistration(previousId);
+    }
+    syncInitialValue();
+    refreshRegistration();
+  });
+  return [validate, register];
 }
 
 const FieldRootInner = /*#__PURE__*/React.forwardRef(function FieldRootInner(componentProps, forwardedRef) {
@@ -332,11 +509,10 @@ const FieldRootInner = /*#__PURE__*/React.forwardRef(function FieldRootInner(com
     dirty: dirtyProp,
     touched: touchedProp,
     actionsRef,
+    style,
     ...elementProps
   } = componentProps;
-  const {
-    disabled: disabledFieldset
-  } = useFieldsetRootContext();
+  const disabledFieldset = useFieldsetRootContext(true)?.disabled;
   const validate = useStableCallback(validateProp || (() => null));
   const disabled = disabledFieldset || disabledProp;
   const [touchedState, setTouchedUnwrapped] = React.useState(false);
@@ -345,7 +521,19 @@ const FieldRootInner = /*#__PURE__*/React.forwardRef(function FieldRootInner(com
   const [focused, setFocused] = React.useState(false);
   const dirty = dirtyProp ?? dirtyState;
   const touched = touchedProp ?? touchedState;
-  const markedDirtyRef = React.useRef(false);
+  const markedDirtyRef = React.useRef(dirty);
+  const registeredFieldIdRef = React.useRef(undefined);
+  const [registeredFieldName, setRegisteredFieldName] = React.useState();
+  const effectiveName = name ?? registeredFieldName;
+  useIsoLayoutEffect(() => {
+    if (dirtyProp !== undefined) {
+      markedDirtyRef.current = dirtyProp;
+    }
+  }, [dirtyProp]);
+  const getRegisteredFieldId = React.useCallback(() => registeredFieldIdRef.current, []);
+  const setRegisteredFieldId = React.useCallback(id => {
+    registeredFieldIdRef.current = id;
+  }, []);
   const setDirty = useStableCallback(value => {
     if (dirtyProp !== undefined) {
       return;
@@ -362,7 +550,8 @@ const FieldRootInner = /*#__PURE__*/React.forwardRef(function FieldRootInner(com
     setTouchedUnwrapped(value);
   });
   const shouldValidateOnChange = useStableCallback(() => validationMode === 'onChange' || validationMode === 'onSubmit' && submitAttemptedRef.current);
-  const hasFormError = !!name && Object.hasOwn(errors, name) && errors[name] !== undefined;
+  const formError = effectiveName && Object.hasOwn(errors, effectiveName) ? errors[effectiveName] : null;
+  const hasFormError = !!(Array.isArray(formError) ? formError.length : formError);
   const invalid = invalidProp === true || hasFormError;
   const [validityData, setValidityData] = React.useState({
     state: DEFAULT_VALIDITY_STATE,
@@ -371,7 +560,7 @@ const FieldRootInner = /*#__PURE__*/React.forwardRef(function FieldRootInner(com
     value: null,
     initialValue: null
   });
-  const valid = !invalid && validityData.state.valid;
+  const valid = disabled ? null : !invalid && validityData.state.valid;
   const state = React.useMemo(() => ({
     disabled,
     touched,
@@ -388,19 +577,25 @@ const FieldRootInner = /*#__PURE__*/React.forwardRef(function FieldRootInner(com
     invalid,
     markedDirtyRef,
     state,
+    shouldValidateOnChange,
+    getRegisteredFieldId
+  });
+  const [validateFieldControl, registerFieldControl] = useFieldControlRegistration({
+    commit: validation.commit,
+    invalid,
+    markedDirtyRef,
     name,
-    shouldValidateOnChange
+    setRegisteredFieldName,
+    setRegisteredFieldId,
+    setValidityData,
+    validityData
   });
-  const handleImperativeValidate = React.useCallback(() => {
-    markedDirtyRef.current = true;
-    validation.commit(validityData.value);
-  }, [validation, validityData]);
   React.useImperativeHandle(actionsRef, () => ({
-    validate: handleImperativeValidate
-  }), [handleImperativeValidate]);
+    validate: validateFieldControl
+  }), [validateFieldControl]);
   const contextValue = React.useMemo(() => ({
     invalid,
-    name,
+    name: effectiveName,
     validityData,
     setValidityData,
     disabled,
@@ -418,8 +613,9 @@ const FieldRootInner = /*#__PURE__*/React.forwardRef(function FieldRootInner(com
     shouldValidateOnChange,
     state,
     markedDirtyRef,
+    registerFieldControl,
     validation
-  }), [invalid, name, validityData, disabled, touched, setTouched, dirty, setDirty, filled, setFilled, focused, setFocused, validate, validationMode, validationDebounceTime, shouldValidateOnChange, state, validation]);
+  }), [invalid, effectiveName, validityData, disabled, touched, setTouched, dirty, setDirty, filled, setFilled, focused, setFocused, validate, validationMode, validationDebounceTime, shouldValidateOnChange, state, registerFieldControl, validation]);
   const element = useRenderElement('div', componentProps, {
     ref: forwardedRef,
     state,
@@ -459,14 +655,20 @@ const FieldLabel = /*#__PURE__*/React.forwardRef(function FieldLabel(componentPr
   const {
     render,
     className,
+    style,
     id: idProp,
     nativeLabel = true,
     ...elementProps
   } = componentProps;
   const fieldRootContext = useFieldRootContext(false);
+  const fieldItemContext = useFieldItemContext();
   const {
     labelId
   } = useLabelableContext();
+  const state = {
+    ...fieldRootContext.state,
+    disabled: fieldRootContext.disabled || fieldItemContext.disabled
+  };
   const labelRef = React.useRef(null);
   const labelProps = useLabel({
     id: labelId ?? idProp,
@@ -494,7 +696,7 @@ const FieldLabel = /*#__PURE__*/React.forwardRef(function FieldLabel(componentPr
   }
   const element = useRenderElement('label', componentProps, {
     ref: [forwardedRef, labelRef],
-    state: fieldRootContext.state,
+    state,
     props: [labelProps, elementProps],
     stateAttributesMapping: fieldValidityMapping
   });
@@ -519,6 +721,7 @@ const FieldError = /*#__PURE__*/React.forwardRef(function FieldError(componentPr
     id: idProp,
     className,
     match,
+    style,
     ...elementProps
   } = componentProps;
   const id = useBaseUiId(idProp);
@@ -533,14 +736,18 @@ const FieldError = /*#__PURE__*/React.forwardRef(function FieldError(componentPr
   const {
     errors
   } = useFormContext();
-  const formError = name ? errors[name] : null;
+  const formError = name && Object.hasOwn(errors, name) ? errors[name] : null;
+  const hasFormError = !!(Array.isArray(formError) ? formError.length : formError);
+  const hasSpecificMatch = typeof match === 'string';
   let rendered = false;
-  if (formError || match === true) {
+  if (match === true) {
     rendered = true;
-  } else if (match) {
+  } else if (fieldState.disabled) {
+    rendered = false;
+  } else if (hasSpecificMatch) {
     rendered = Boolean(validityData.state[match]);
   } else {
-    rendered = validityData.state.valid === false;
+    rendered = hasFormError || validityData.state.valid === false;
   }
   const {
     mounted,
@@ -559,17 +766,21 @@ const FieldError = /*#__PURE__*/React.forwardRef(function FieldError(componentPr
   const errorRef = React.useRef(null);
   const [lastRenderedMessage, setLastRenderedMessage] = React.useState(null);
   const [lastRenderedMessageKey, setLastRenderedMessageKey] = React.useState(null);
-  const errorMessage = formError || (validityData.errors.length > 1 ? /*#__PURE__*/jsx("ul", {
-    children: validityData.errors.map(message => /*#__PURE__*/jsx("li", {
-      children: message
-    }, message))
-  }) : validityData.error);
-  let errorKey = validityData.error;
-  if (formError != null) {
-    errorKey = Array.isArray(formError) ? JSON.stringify(formError) : formError;
+  let error = validityData.error;
+  if (!hasSpecificMatch && hasFormError) {
+    error = formError;
   } else if (validityData.errors.length > 1) {
-    errorKey = JSON.stringify(validityData.errors);
+    error = validityData.errors;
+  }
+  let errorMessage = error ?? '';
+  if (Array.isArray(error)) {
+    errorMessage = error.length > 1 ? /*#__PURE__*/jsx("ul", {
+      children: error.map(message => /*#__PURE__*/jsx("li", {
+        children: message
+      }, message))
+    }) : error[0] ?? '';
   }
+  const errorKey = Array.isArray(error) ? JSON.stringify(error) : error;
   if (rendered && errorKey !== lastRenderedMessageKey) {
     setLastRenderedMessageKey(errorKey);
     setLastRenderedMessage(errorMessage);
@@ -615,13 +826,19 @@ const FieldDescription = /*#__PURE__*/React.forwardRef(function FieldDescription
     render,
     id: idProp,
     className,
+    style,
     ...elementProps
   } = componentProps;
   const id = useBaseUiId(idProp);
   const fieldRootContext = useFieldRootContext(false);
+  const fieldItemContext = useFieldItemContext();
   const {
     setMessageIds
   } = useLabelableContext();
+  const state = {
+    ...fieldRootContext.state,
+    disabled: fieldRootContext.disabled || fieldItemContext.disabled
+  };
   useIsoLayoutEffect(() => {
     if (!id) {
       return undefined;
@@ -633,7 +850,7 @@ const FieldDescription = /*#__PURE__*/React.forwardRef(function FieldDescription
   }, [id, setMessageIds]);
   const element = useRenderElement('p', componentProps, {
     ref: forwardedRef,
-    state: fieldRootContext.state,
+    state,
     props: [{
       id
     }, elementProps],

package/dist/LightBox/index.cjs

@@ -20,7 +20,7 @@ require('../Heading-cjs.js');
 require('../Tooltip-cjs.js');
 require('../floating-ui.react-cjs.js');
 require('../floating-ui.utils.dom-cjs.js');
-require('../index.esm-cjs.js');
+require('../floating-ui.utils-cjs.js');
 require('react/jsx-runtime');
 require('../floating-ui.react-dom-cjs.js');
 require('../AtlantisThemeContext-cjs.js');

package/dist/LightBox/index.mjs

@@ -18,7 +18,7 @@ import '../Heading-es.js';
 import '../Tooltip-es.js';
 import '../floating-ui.react-es.js';
 import '../floating-ui.utils.dom-es.js';
-import '../index.esm-es.js';
+import '../floating-ui.utils-es.js';
 import 'react/jsx-runtime';
 import '../floating-ui.react-dom-es.js';
 import '../AtlantisThemeContext-es.js';