@servicetitan/anvil2 1.40.3 → 1.42.0

package/dist/{DateFieldRange-BRjBcR4r-CfuSiOfZ.js → DateFieldYearless-M5KDI_hn-akXtkIZA.js}

@@ -1,14 +1,14 @@
 import { jsx, jsxs } from 'react/jsx-runtime';
 import { useState, useCallback, useRef, useLayoutEffect, useEffect, useMemo, forwardRef, useImperativeHandle } from 'react';
-import { D as DateTime, f as Calendar } from './Calendar-KVYGk3wS-CEptqxjI.js';
-import { T as TextField } from './TextField-BIeCvDD--C7yp05g5.js';
+import { T as TextField } from './TextField-CRTh0gL_-D2CjcYXX.js';
 import { u as useMergeRefs$1 } from './floating-ui.react-BFNinq1w.js';
+import { D as DateTime, f as Calendar } from './Calendar-DD5kmVd3-CBGTR11R.js';
 import { I as Icon } from './Icon-B6HmlQiR-BxQkO3X5.js';
 import { u as usePopoverCloseDelayWorkaround, S as SvgEvent } from './usePopoverCloseDelayWorkaround-BhhG-xEB-hfJZaXHC.js';
-import { d as Popover } from './Popover-jcmNuir0-DjlCqU1z.js';
-import { u as useMergeRefs } from './useMergeRefs-Bde85AWI-Bde85AWI.js';
+import { d as Popover } from './Popover-CU2cGVD8-FWJOuFRj.js';
 import { u as useOptionallyControlledState } from './useOptionallyControlledState-DAv5LXXh-DAv5LXXh.js';
-import { s as supportsPopover, u as useKeyboardFocusables } from './ProgressBar-CzXzPpIX-Clg1J71o.js';
+import { u as useMergeRefs } from './useMergeRefs-Bde85AWI-Bde85AWI.js';
+import { s as supportsPopover, u as useKeyboardFocusables } from './ProgressBar-BRvB-bD4-DppwBrFg.js';
 
 function getContentEditableSelection(element) {
     const { anchorOffset = 0, focusOffset = 0 } = element.ownerDocument.getSelection() || {};
@@ -1887,7 +1887,7 @@ const MaskedDateInput = forwardRef(
     useEffect(() => {
       if (mode !== previousMode) {
         setInputValue(
-          (oldInputValue) => swapMode$1(oldInputValue, previousMode ?? mode, mode)
+          (oldInputValue) => swapMode$2(oldInputValue, previousMode ?? mode, mode)
         );
       }
     }, [mode, previousMode]);
@@ -1902,17 +1902,21 @@ const MaskedDateInput = forwardRef(
       }
     }, [lastValidDate, mode, placeholder]);
     const currentParsedData = useMemo(() => {
-      return parseInputValue(inputValue, mode, removePlaceholder);
+      return parseInputValue$1(inputValue, mode, removePlaceholder);
     }, [inputValue, mode, removePlaceholder]);
     const handleChange = (event) => {
       setInputValue(event.target.value);
-      const { date, isInputValid, isInputEmpty } = parseInputValue(
+      const { date, isInputValid, isInputEmpty } = parseInputValue$1(
         event.target.value,
         mode,
         removePlaceholder
       );
+      const isValueDifferent = isInputValid !== currentParsedData.isInputValid || // The input has changed validity
+      isInputEmpty !== currentParsedData.isInputEmpty || // The input has changed emptiness
+      date === null !== (lastValidDate === null) || // The input has changed from empty to non-empty or vice versa
+      date !== null && lastValidDate !== null && !date.equals(lastValidDate);
+      if (!isValueDifferent) return;
       onChange?.({
-        event,
         date: date ?? lastValidDate ?? null,
         isInputValid,
         isInputEmpty
@@ -1941,13 +1945,13 @@ const MaskedDateInput = forwardRef(
         value: inputValue,
         onChange: handleChange,
         prefix: /* @__PURE__ */ jsx(Icon, { svg: SvgEvent }),
-        hint: disableHint ? void 0 : `format: ${mode}`
+        hint: disableHint ? void 0 : `Format: ${mode}`
       }
     );
   }
 );
 MaskedDateInput.displayName = "MaskedDateInput";
-function parseInputValue(value, mode, removePlaceholder) {
+function parseInputValue$1(value, mode, removePlaceholder) {
   const valueMinusPlaceholder = removePlaceholder(value);
   const jsDate = maskitoParseDate(valueMinusPlaceholder, { mode });
   const luxonDate = jsDate ? DateTime.fromJSDate(jsDate, { zone: "utc" }) : null;
@@ -1957,11 +1961,11 @@ function parseInputValue(value, mode, removePlaceholder) {
     isInputEmpty: valueMinusPlaceholder === ""
   };
 }
-function swapMode$1(inputString, previousMode, mode) {
-  const { day, month, year } = divideSegments(inputString, previousMode);
+function swapMode$2(inputString, previousMode, mode) {
+  const { day, month, year } = divideSegments$1(inputString, previousMode);
   return orderSegmentsByMode(day, month, year, mode);
 }
-function divideSegments(value, mode) {
+function divideSegments$1(value, mode) {
   const [segment1, segment2, segment3] = value.split("/");
   if (mode === "dd/mm/yyyy") {
     return { day: segment1, month: segment2, year: segment3 };
@@ -1984,6 +1988,206 @@ function orderSegmentsByMode(day, month, year, mode) {
   }
 }
 
+function containsRelatedTarget(event) {
+  if (event.currentTarget instanceof HTMLElement && event.relatedTarget instanceof HTMLElement) {
+    return event.currentTarget.contains(event.relatedTarget);
+  }
+  return false;
+}
+function useFocusWithin({
+  onBlur,
+  onFocus
+} = {}) {
+  const [focused, setFocused] = useState(false);
+  const focusedRef = useRef(false);
+  const elementRef = useRef(null);
+  const _setFocused = useCallback((value) => {
+    setFocused(value);
+    focusedRef.current = value;
+  }, []);
+  const handleFocusIn = useCallback(
+    (event) => {
+      if (!focusedRef.current) {
+        _setFocused(true);
+        onFocus?.(event);
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [onFocus]
+  );
+  const handleFocusOut = useCallback(
+    (event) => {
+      if (focusedRef.current && !containsRelatedTarget(event)) {
+        _setFocused(false);
+        onBlur?.(event);
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [onBlur]
+  );
+  useEffect(() => {
+    const element = elementRef.current;
+    if (!element) {
+      return;
+    }
+    element.addEventListener("focusin", handleFocusIn);
+    element.addEventListener("focusout", handleFocusOut);
+    return () => {
+      element.removeEventListener("focusin", handleFocusIn);
+      element.removeEventListener("focusout", handleFocusOut);
+    };
+  }, [handleFocusIn, handleFocusOut]);
+  return { ref: elementRef, focused };
+}
+
+function convertStringToDate(v) {
+  if (v === void 0 || v === null) {
+    return v;
+  }
+  const date = DateTime.fromISO(v, { setZone: true, zone: "utc" }).startOf(
+    "day"
+  );
+  if (date.isValid) {
+    return date;
+  }
+  return null;
+}
+function validateDate({
+  date,
+  constraints
+}) {
+  const { required, unavailable, minDate, maxDate } = constraints;
+  if (!date) {
+    return required ? false : true;
+  }
+  if (unavailable?.dates?.some((d) => d.equals(date))) {
+    return false;
+  }
+  if (unavailable?.daysOfWeek?.includes(date.weekday)) {
+    return false;
+  }
+  if (minDate && date < minDate) {
+    return false;
+  }
+  if (maxDate && date > maxDate) {
+    return false;
+  }
+  return true;
+}
+function validateYearlessDate({
+  value,
+  constraints
+}) {
+  const { required, unavailable, minDate, maxDate } = constraints;
+  if (!value || !value?.day && !value?.month) {
+    return required ? false : true;
+  }
+  if (value.day === null || value.month === null) {
+    return false;
+  }
+  if (unavailable?.dates?.some(
+    (d) => d.day === value.day && d.month === value.month
+  )) {
+    return false;
+  }
+  const minDateMonth = minDate?.month ?? 1;
+  const minDateDay = minDate?.day ?? 1;
+  const maxDateMonth = maxDate?.month ?? 12;
+  const maxDateDay = maxDate?.day ?? 31;
+  if (value.month < minDateMonth || // Earlier month
+  value.month === minDateMonth && value.day < minDateDay) {
+    return false;
+  }
+  if (value.month > maxDateMonth || // Later month
+  value.month === maxDateMonth && value.day > maxDateDay) {
+    return false;
+  }
+  return true;
+}
+
+function useDateFieldSingleConversion({
+  value,
+  defaultValue,
+  minDate,
+  maxDate,
+  unavailable,
+  onChange
+}) {
+  const normalizedValue = useMemo(() => convertStringToDate(value), [value]);
+  const normalizedDefaultValue = useMemo(
+    () => convertStringToDate(defaultValue),
+    [defaultValue]
+  );
+  const normalizedMinDate = useMemo(
+    () => convertStringToDate(minDate),
+    [minDate]
+  );
+  const normalizedMaxDate = useMemo(
+    () => convertStringToDate(maxDate),
+    [maxDate]
+  );
+  const normalizedUnavailableDates = useMemo(
+    () => unavailable?.dates?.map((d) => convertStringToDate(d)).filter((d) => d !== null && d !== void 0),
+    [unavailable?.dates]
+  );
+  const handleChange = useCallback(
+    (change) => {
+      onChange?.({
+        ...change,
+        date: change.date?.toISODate() ?? null
+      });
+    },
+    [onChange]
+  );
+  return {
+    value: normalizedValue,
+    defaultValue: normalizedDefaultValue,
+    minDate: normalizedMinDate,
+    maxDate: normalizedMaxDate,
+    unavailable: {
+      dates: normalizedUnavailableDates,
+      daysOfWeek: unavailable?.daysOfWeek
+    },
+    onChange: handleChange
+  };
+}
+
+function DateFieldSingleCalendar({
+  onKeyDown,
+  value,
+  onSelection,
+  minDate,
+  maxDate,
+  unavailable,
+  ...rest
+}) {
+  const handleCalendarSelection = (data) => {
+    if (data.value) {
+      const date = DateTime.fromISO(data.value, { zone: "utc" });
+      onSelection(date);
+    }
+  };
+  return /* @__PURE__ */ jsx(
+    Calendar,
+    {
+      ...rest,
+      range: false,
+      onKeyDown,
+      defaultFocusedDate: value?.toISODate() || DateTime.now().toISODate(),
+      value: value?.toISODate() || void 0,
+      onSelection: handleCalendarSelection,
+      defaultTimeZone: "UTC",
+      minDate: minDate?.toISODate() ?? void 0,
+      maxDate: maxDate?.toISODate() ?? void 0,
+      unavailable: unavailable ? {
+        dates: unavailable.dates?.map((d) => d.toISODate() ?? ""),
+        daysOfWeek: unavailable.daysOfWeek
+      } : void 0,
+      _disableAutofocus: true
+    }
+  );
+}
+
 const useDateFieldOrchestration = ({
   inputRef,
   calendarDefaultOpen,
@@ -2070,330 +2274,172 @@ const useDateFieldOrchestration = ({
   };
 };
 
-function convertStringToDate(v) {
-  if (v === void 0 || v === null) {
-    return v;
-  }
-  const date = DateTime.fromISO(v, { setZone: true, zone: "utc" }).startOf(
-    "day"
-  );
-  if (date.isValid) {
-    return date;
-  }
-  return null;
-}
-function validateDate({
-  date,
-  constraints
+function useDateFieldSingleState({
+  valueProp,
+  defaultValueProp,
+  inputRef,
+  onChange
 }) {
-  const { required, unavailable, minDate, maxDate } = constraints;
-  if (!date) {
-    return required ? false : true;
-  }
-  if (unavailable?.dates?.some((d) => d.equals(date))) {
-    return false;
-  }
-  if (unavailable?.daysOfWeek?.includes(date.weekday)) {
-    return false;
-  }
-  if (minDate && date < minDate) {
-    return false;
-  }
-  if (maxDate && date > maxDate) {
-    return false;
-  }
-  return true;
+  const [value, setValue] = useOptionallyControlledState({
+    controlledValue: valueProp,
+    defaultValue: defaultValueProp
+  });
+  const setSharedValue = (date) => {
+    inputRef.current?.setDate(date);
+    setValue(date);
+  };
+  const handleInputChange = (change) => {
+    const date = change.isInputEmpty ? null : change.date?.startOf("day") ?? null;
+    onChange?.({
+      date,
+      isInputValid: change.isInputValid,
+      isInputEmpty: change.isInputEmpty
+    });
+    if (change.isInputValid) {
+      setSharedValue(change.isInputEmpty ? null : change.date);
+    }
+    if (change.isInputEmpty) {
+      setSharedValue(null);
+      return;
+    }
+    if (change.date) {
+      setSharedValue(change.date);
+    }
+  };
+  const handleCalendarSelection = (date) => {
+    setSharedValue(date);
+    onChange?.({
+      date,
+      isInputValid: true,
+      isInputEmpty: false
+    });
+  };
+  return {
+    value,
+    setValue: setSharedValue,
+    handleInputChange,
+    handleCalendarSelection
+  };
 }
 
-const NormalizedDateFieldSingle = forwardRef(
-  ({
+const DateFieldSingle = ({
+  onFocus,
+  onBlur,
+  disableCalendar,
+  required,
+  mode,
+  ...rest
+}) => {
+  const inputRef = useRef(null);
+  const {
     value: valueProp,
-    mode = "mm/dd/yyyy",
     defaultValue: defaultValueProp,
-    onChange,
-    disableCalendar = false,
-    unavailable,
     minDate,
     maxDate,
-    onFocus,
-    onBlur,
-    required = false,
-    ...rest
-  }, ref) => {
-    const inputRef = useRef(null);
-    const [popoverTriggerRef, setPopoverTriggerRef] = useState();
-    const popoverContentRef = useRef(null);
-    const combinedRef = useMergeRefs([popoverTriggerRef, inputRef, ref]);
-    const {
-      calendarOpen,
-      setCalendarOpen,
-      handleCalendarKeyDown,
-      handleInputKeyDown
-    } = useDateFieldOrchestration({
-      inputRef,
-      calendarDefaultOpen: false,
-      popoverContentRef,
-      disableCalendar
-    });
-    const [lastValidDate, setLastValidDate] = useOptionallyControlledState({
-      controlledValue: valueProp,
-      defaultValue: defaultValueProp
-    });
-    const popoverSupported = usePopoverSupport();
-    const shouldShowCalendar = usePopoverCloseDelayWorkaround(calendarOpen);
-    const currentValidity = useMemo(
-      () => validateDate({
-        date: lastValidDate,
+    unavailable,
+    onChange
+  } = useDateFieldSingleConversion(rest);
+  const handleChange = (change) => {
+    onChange?.({
+      ...change,
+      isDateValid: validateDate({
+        date: change.date,
         constraints: {
           required,
           unavailable,
           minDate: minDate ?? void 0,
           maxDate: maxDate ?? void 0
         }
-      }),
-      [lastValidDate, required, unavailable, minDate, maxDate]
-    );
-    const handleInputChange = (change) => {
-      const date = change.isInputEmpty ? null : change.date?.startOf("day") ?? null;
-      onChange?.({
-        date: date?.toISODate() ?? null,
-        isInputValid: change.isInputValid,
-        isInputEmpty: change.isInputEmpty,
-        isDateValid: validateDate({
-          date,
-          constraints: {
-            required,
-            unavailable,
-            minDate: minDate ?? void 0,
-            maxDate: maxDate ?? void 0
-          }
-        })
-      });
-      if (change.isInputValid) {
-        setLastValidDate(change.isInputEmpty ? null : change.date);
-      }
-      if (change.isInputEmpty) {
-        setLastValidDate(null);
-        return;
-      }
-      if (change.date) {
-        setLastValidDate(change.date);
-      }
-    };
-    const handleCalendarSelection = (data) => {
-      if (data.value) {
-        const date = DateTime.fromISO(data.value, { zone: "utc" });
-        setLastValidDate(date);
-        inputRef.current?.setDate(date);
-        onChange?.({
-          date: date.toISODate(),
-          isInputValid: true,
-          isInputEmpty: false,
-          isDateValid: validateDate({
-            date,
-            constraints: {
-              required,
-              unavailable,
-              minDate: minDate ?? void 0,
-              maxDate: maxDate ?? void 0
-            }
-          })
-        });
-      }
-    };
-    const justTheField = /* @__PURE__ */ jsx(
-      MaskedDateInput,
-      {
-        mode,
-        ref: combinedRef,
-        ...rest,
-        onChange: handleInputChange,
-        onKeyDown: handleInputKeyDown,
-        onClick: () => setCalendarOpen(true),
-        lastValidDate,
+      })
+    });
+  };
+  const { value, handleInputChange, handleCalendarSelection } = useDateFieldSingleState({
+    valueProp,
+    defaultValueProp,
+    inputRef,
+    onChange: handleChange
+  });
+  const { ref: wrapperRef } = useFocusWithin({
+    onBlur,
+    onFocus
+  });
+  const [popoverTriggerRef, setPopoverTriggerRef] = useState();
+  const popoverContentRef = useRef(null);
+  const combinedRef = useMergeRefs([popoverTriggerRef, inputRef]);
+  const {
+    calendarOpen,
+    setCalendarOpen,
+    handleCalendarKeyDown,
+    handleInputKeyDown
+  } = useDateFieldOrchestration({
+    inputRef,
+    calendarDefaultOpen: false,
+    popoverContentRef,
+    disableCalendar
+  });
+  const popoverSupported = usePopoverSupport();
+  const shouldShowCalendar = usePopoverCloseDelayWorkaround(calendarOpen);
+  const currentValidity = useMemo(
+    () => validateDate({
+      date: value,
+      constraints: {
         required,
-        autoComplete: "off",
-        "data-date-valid": currentValidity
+        unavailable,
+        minDate: minDate ?? void 0,
+        maxDate: maxDate ?? void 0
       }
-    );
-    if (disableCalendar) {
-      return justTheField;
-    }
-    if (!popoverSupported) {
-      return justTheField;
-    }
-    return /* @__PURE__ */ jsxs(
-      Popover,
-      {
-        open: calendarOpen,
-        modal: true,
-        placement: "bottom-start",
-        disableFlipFallback: true,
-        disableTriggerFocus: true,
-        onClose: () => setCalendarOpen(false),
-        disableAutoUpdate: true,
-        onClickOutside: () => setCalendarOpen(false),
-        children: [
-          /* @__PURE__ */ jsx(Popover.Trigger, { children: ({ ref: iRef }) => {
-            setPopoverTriggerRef(iRef);
-            return justTheField;
-          } }),
-          /* @__PURE__ */ jsx(Popover.Content, { ref: popoverContentRef, "data-testid": "calendar-popover", children: shouldShowCalendar && /* @__PURE__ */ jsx(
-            Calendar,
-            {
-              range: false,
-              onKeyDown: handleCalendarKeyDown,
-              defaultFocusedDate: lastValidDate?.toISODate() || DateTime.now().toISODate(),
-              value: lastValidDate?.toISODate() || void 0,
-              onSelection: handleCalendarSelection,
-              defaultTimeZone: "UTC",
-              minDate: minDate?.toISODate() ?? void 0,
-              maxDate: maxDate?.toISODate() ?? void 0,
-              unavailable: unavailable ? {
-                dates: unavailable.dates?.map((d) => d.toISODate() ?? ""),
-                daysOfWeek: unavailable.daysOfWeek
-              } : void 0,
-              _disableAutofocus: true
-            }
-          ) })
-        ]
-      }
-    );
-  }
-);
-NormalizedDateFieldSingle.displayName = "NormalizedDateFieldSingle";
-
-function containsRelatedTarget(event) {
-  if (event.currentTarget instanceof HTMLElement && event.relatedTarget instanceof HTMLElement) {
-    return event.currentTarget.contains(event.relatedTarget);
-  }
-  return false;
-}
-function useFocusWithin({
-  onBlur,
-  onFocus
-} = {}) {
-  const [focused, setFocused] = useState(false);
-  const focusedRef = useRef(false);
-  const elementRef = useRef(null);
-  const _setFocused = useCallback((value) => {
-    setFocused(value);
-    focusedRef.current = value;
-  }, []);
-  const handleFocusIn = useCallback(
-    (event) => {
-      if (!focusedRef.current) {
-        _setFocused(true);
-        onFocus?.(event);
-      }
-    },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [onFocus]
+    }),
+    [value, required, unavailable, minDate, maxDate]
   );
-  const handleFocusOut = useCallback(
-    (event) => {
-      if (focusedRef.current && !containsRelatedTarget(event)) {
-        _setFocused(false);
-        onBlur?.(event);
-      }
-    },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [onBlur]
-  );
-  useEffect(() => {
-    const element = elementRef.current;
-    if (!element) {
-      return;
+  const justTheField = /* @__PURE__ */ jsx(
+    MaskedDateInput,
+    {
+      mode,
+      ref: combinedRef,
+      ...rest,
+      onChange: handleInputChange,
+      onKeyDown: handleInputKeyDown,
+      onClick: () => setCalendarOpen(true),
+      lastValidDate: value,
+      required,
+      autoComplete: "off",
+      "data-date-valid": currentValidity
     }
-    element.addEventListener("focusin", handleFocusIn);
-    element.addEventListener("focusout", handleFocusOut);
-    return () => {
-      element.removeEventListener("focusin", handleFocusIn);
-      element.removeEventListener("focusout", handleFocusOut);
-    };
-  }, [handleFocusIn, handleFocusOut]);
-  return { ref: elementRef, focused };
-}
-
-const useConditionalChange = ({
-  changeHandler,
-  compareFn
-}) => {
-  const lastChangeRef = useRef(null);
-  const onChange = useCallback(
-    (change) => {
-      if (!!lastChangeRef.current && !compareFn(lastChangeRef.current, change)) {
-        return;
-      }
-      changeHandler?.(change);
-      lastChangeRef.current = change;
-    },
-    [changeHandler, compareFn]
-  );
-  return onChange;
-};
-
-const DateFieldSingle = ({
-  value,
-  defaultValue,
-  minDate,
-  maxDate,
-  unavailable,
-  onChange,
-  onFocus,
-  onBlur,
-  ...rest
-}) => {
-  const handleBlur = useCallback(
-    (event) => {
-      onBlur?.(event);
-    },
-    [onBlur]
-  );
-  const handleFocus = useCallback(
-    (event) => {
-      onFocus?.(event);
-    },
-    [onFocus]
-  );
-  const { ref: wrapperRef } = useFocusWithin({
-    onBlur: handleBlur,
-    onFocus: handleFocus
-  });
-  const normalizedValue = useMemo(() => convertStringToDate(value), [value]);
-  const normalizedDefaultValue = useMemo(
-    () => convertStringToDate(defaultValue),
-    [defaultValue]
-  );
-  const normalizedMinDate = useMemo(
-    () => convertStringToDate(minDate),
-    [minDate]
-  );
-  const normalizedMaxDate = useMemo(
-    () => convertStringToDate(maxDate),
-    [maxDate]
-  );
-  const normalizedUnavailableDates = useMemo(
-    () => unavailable?.dates?.map((d) => convertStringToDate(d)).filter((d) => d !== null && d !== void 0),
-    [unavailable?.dates]
   );
-  const handleChange = useConditionalChange({
-    changeHandler: onChange,
-    compareFn: (a, b) => a.isInputValid !== b.isInputValid || a.isInputEmpty !== b.isInputEmpty || a.isDateValid !== b.isDateValid || a.date !== b.date
-  });
-  return /* @__PURE__ */ jsx("div", { ref: wrapperRef, children: /* @__PURE__ */ jsx(
-    NormalizedDateFieldSingle,
+  if (disableCalendar) {
+    return justTheField;
+  }
+  if (!popoverSupported) {
+    return justTheField;
+  }
+  return /* @__PURE__ */ jsx("div", { ref: wrapperRef, children: /* @__PURE__ */ jsxs(
+    Popover,
     {
-      ...rest,
-      onChange: handleChange,
-      value: normalizedValue,
-      defaultValue: normalizedDefaultValue,
-      minDate: normalizedMinDate,
-      maxDate: normalizedMaxDate,
-      unavailable: unavailable ? {
-        dates: normalizedUnavailableDates,
-        daysOfWeek: unavailable?.daysOfWeek
-      } : void 0
+      open: calendarOpen,
+      modal: true,
+      placement: "bottom-start",
+      disableFlipFallback: true,
+      disableTriggerFocus: true,
+      onClose: () => setCalendarOpen(false),
+      disableAutoUpdate: true,
+      onClickOutside: () => setCalendarOpen(false),
+      children: [
+        /* @__PURE__ */ jsx(Popover.Trigger, { children: ({ ref: iRef }) => {
+          setPopoverTriggerRef(iRef);
+          return justTheField;
+        } }),
+        /* @__PURE__ */ jsx(Popover.Content, { ref: popoverContentRef, "data-testid": "calendar-popover", children: shouldShowCalendar && /* @__PURE__ */ jsx(
+          DateFieldSingleCalendar,
+          {
+            onKeyDown: handleCalendarKeyDown,
+            value,
+            onSelection: handleCalendarSelection,
+            minDate,
+            maxDate,
+            unavailable
+          }
+        ) })
+      ]
     }
   ) });
 };
@@ -2458,7 +2504,7 @@ const MaskedDateRangeInput = forwardRef(
     useEffect(() => {
       if (mode !== previousMode) {
         setInputValue(
-          (previousInputValue) => swapMode(previousInputValue, previousMode ?? mode, mode)
+          (previousInputValue) => swapMode$1(previousInputValue, previousMode ?? mode, mode)
         );
       }
     }, [mode, fullPlaceholder, previousMode]);
@@ -2483,6 +2529,9 @@ const MaskedDateRangeInput = forwardRef(
       previousStartDate,
       previousEndDate
     ]);
+    const currentParsedData = useMemo(() => {
+      return parseRangeInputValue(inputValue, mode, removePlaceholder);
+    }, [inputValue, mode, removePlaceholder]);
     const handleChange = (event) => {
       setInputValue(event.target.value);
       const {
@@ -2492,17 +2541,20 @@ const MaskedDateRangeInput = forwardRef(
         isInputEmpty,
         isHalfEmpty
       } = parseRangeInputValue(event.target.value, mode, removePlaceholder);
+      const isValueDifferent = isInputValid !== currentParsedData.isInputValid || // The input has changed validity
+      isInputEmpty !== currentParsedData.isInputEmpty || // The input has changed emptiness
+      parsedStartDate === null !== (startDate === null) || // The start date has changed from empty to non-empty or vice versa
+      parsedEndDate === null !== (endDate === null) || // The end date has changed from empty to non-empty or vice versa
+      parsedStartDate !== null && startDate !== null && !parsedStartDate.equals(startDate) || // The start date has changed
+      parsedEndDate !== null && endDate !== null && !parsedEndDate.equals(endDate);
+      if (!isValueDifferent) return;
       onChange?.({
-        event,
         startDate: isInputEmpty ? null : parsedStartDate ?? startDate ?? null,
         endDate: isInputEmpty || isHalfEmpty ? null : parsedEndDate ?? endDate ?? null,
         isInputValid,
         isInputEmpty
       });
     };
-    const currentParsedData = useMemo(() => {
-      return parseRangeInputValue(inputValue, mode, removePlaceholder);
-    }, [inputValue, mode, removePlaceholder]);
     useImperativeHandle(ref, () => {
       const input = inputRef.current;
       if (!input) return null;
@@ -2530,7 +2582,7 @@ const MaskedDateRangeInput = forwardRef(
         value: inputValue,
         onChange: handleChange,
         prefix: /* @__PURE__ */ jsx(Icon, { svg: SvgEvent }),
-        hint: disableHint ? void 0 : `format: ${mode}`
+        hint: disableHint ? void 0 : `Format: ${mode}`
       }
     );
   }
@@ -2553,7 +2605,7 @@ function parseRangeInputValue(value, mode, removePlaceholder) {
     isHalfEmpty: endDate === void 0
   };
 }
-function swapMode(inputString, previousMode, mode) {
+function swapMode$1(inputString, previousMode, mode) {
   const halves = inputString.split(RANGE_SEPARATOR);
   const segments = halves.map((half) => half.split("/"));
   let startDay, startMonth, startYear, endDay, endMonth, endYear;
@@ -2593,202 +2645,299 @@ function swapMode(inputString, previousMode, mode) {
   return inputString;
 }
 
-const NormalizedDateFieldRange = forwardRef(
-  ({
-    value: valueProp,
-    mode = "mm/dd/yyyy",
-    defaultValue: defaultValueProp,
-    onChange,
-    disableCalendar = false,
-    unavailable,
-    minDate,
-    maxDate,
-    required = false,
-    onFocus,
-    onBlur,
-    ...rest
-  }, ref) => {
-    const inputRef = useRef(null);
-    const [popoverTriggerRef, setPopoverTriggerRef] = useState();
-    const popoverContentRef = useRef(null);
-    const combinedRef = useMergeRefs([popoverTriggerRef, inputRef, ref]);
-    const [startDate, setStartDate] = useOptionallyControlledState({
-      controlledValue: valueProp !== void 0 ? valueProp?.startDate : void 0,
-      defaultValue: defaultValueProp !== void 0 ? defaultValueProp?.startDate : void 0
-    });
-    const [endDate, setEndDate] = useOptionallyControlledState(
-      {
-        controlledValue: valueProp !== void 0 ? valueProp?.endDate : void 0,
-        defaultValue: defaultValueProp !== void 0 ? defaultValueProp?.endDate : void 0
-      }
-    );
-    const previousStartDate = usePrevious(startDate);
-    const previousEndDate = usePrevious(endDate);
-    const popoverSupported = usePopoverSupport();
-    const {
-      calendarOpen,
-      setCalendarOpen,
-      handleCalendarKeyDown,
-      handleInputKeyDown
-    } = useDateFieldOrchestration({
-      inputRef,
-      calendarDefaultOpen: false,
-      popoverContentRef,
-      disableCalendar
-    });
-    const shouldShowCalendar = usePopoverCloseDelayWorkaround(calendarOpen);
-    const isDateRangeValid = useMemo(() => {
-      return validateDate({
-        date: startDate ?? null,
-        constraints: {
-          required,
-          unavailable,
-          minDate: minDate ?? void 0,
-          maxDate: maxDate ?? void 0
-        }
-      }) && validateDate({
-        date: endDate ?? null,
-        constraints: {
-          required,
-          unavailable,
-          minDate: minDate ?? void 0,
-          maxDate: maxDate ?? void 0
-        }
-      }) && (!startDate || !endDate || startDate <= endDate);
-    }, [required, unavailable, minDate, maxDate, startDate, endDate]);
-    const defaultFocusedDate = useMemo(() => {
-      if (!startDate && !endDate) return DateTime.now().toISODate();
-      if (!startDate) return endDate?.toISODate();
-      if (!endDate) return startDate?.toISODate();
-      if (endDate && !previousEndDate?.equals(endDate)) {
-        return endDate.toISODate();
-      } else if (startDate && !previousStartDate?.equals(startDate)) {
-        return startDate.toISODate();
-      }
-      if (endDate) return endDate.toISODate();
-      if (startDate) return startDate.toISODate();
-      return DateTime.now().toISODate();
-    }, [previousStartDate, previousEndDate, startDate, endDate]);
-    const handleInputChange = (change) => {
-      const sharedConstraints = {
-        unavailable,
-        minDate: minDate ?? void 0,
-        maxDate: maxDate ?? void 0
-      };
-      const range = change.isInputEmpty ? null : {
-        startDate: change.startDate?.startOf("day") ?? null,
-        endDate: change.endDate?.startOf("day") ?? null
-      };
-      setStartDate(range?.startDate ?? null);
-      setEndDate(range?.endDate ?? null);
+const useDateFieldRangeConversion = (props) => {
+  const { value, defaultValue, minDate, maxDate, unavailable, onChange } = props;
+  const normalizedValue = useMemo(() => {
+    if (value === null || value === void 0) return value;
+    return {
+      startDate: convertStringToDate(value.startDate) ?? null,
+      endDate: convertStringToDate(value.endDate) ?? null
+    };
+  }, [value]);
+  const normalizedDefaultValue = useMemo(() => {
+    if (defaultValue === null || defaultValue === void 0)
+      return defaultValue;
+    return {
+      startDate: convertStringToDate(defaultValue.startDate) ?? null,
+      endDate: convertStringToDate(defaultValue.endDate) ?? null
+    };
+  }, [defaultValue]);
+  const normalizedMinDate = useMemo(
+    () => convertStringToDate(minDate),
+    [minDate]
+  );
+  const normalizedMaxDate = useMemo(
+    () => convertStringToDate(maxDate),
+    [maxDate]
+  );
+  const normalizedUnavailableDates = useMemo(() => {
+    return unavailable?.dates?.map((date) => convertStringToDate(date)).filter((date) => date !== null && date !== void 0);
+  }, [unavailable?.dates]);
+  const handleChange = useCallback(
+    (change) => {
       onChange?.({
-        startDate: range?.startDate?.toISODate() ?? null,
-        endDate: range?.endDate?.toISODate() ?? null,
-        isInputValid: change.isInputValid,
-        isInputEmpty: change.isInputEmpty,
-        isDateRangeValid: validateDateRange({
-          required,
-          startDate: range?.startDate ?? null,
-          endDate: range?.endDate ?? null,
-          startDateConstraints: sharedConstraints,
-          endDateConstraints: sharedConstraints
-        })
+        ...change,
+        startDate: change.startDate?.toISODate() ?? null,
+        endDate: change.endDate?.toISODate() ?? null
       });
+    },
+    [onChange]
+  );
+  return {
+    value: normalizedValue,
+    defaultValue: normalizedDefaultValue,
+    minDate: normalizedMinDate,
+    maxDate: normalizedMaxDate,
+    unavailable: {
+      dates: normalizedUnavailableDates,
+      daysOfWeek: unavailable?.daysOfWeek
+    },
+    onChange: handleChange
+  };
+};
+
+function useDateFieldRangeState({
+  valueProp,
+  defaultValueProp,
+  inputRef,
+  onChange
+}) {
+  const [startDate, setStartDate] = useOptionallyControlledState({
+    controlledValue: valueProp !== void 0 ? valueProp?.startDate : void 0,
+    defaultValue: defaultValueProp !== void 0 ? defaultValueProp?.startDate : void 0
+  });
+  const [endDate, setEndDate] = useOptionallyControlledState({
+    controlledValue: valueProp !== void 0 ? valueProp?.endDate : void 0,
+    defaultValue: defaultValueProp !== void 0 ? defaultValueProp?.endDate : void 0
+  });
+  const setSharedValue = (value) => {
+    inputRef.current?.setDateRange(value.startDate, value.endDate);
+    setStartDate(value.startDate);
+    setEndDate(value.endDate);
+  };
+  const handleInputChange = (change) => {
+    const range = change.isInputEmpty ? null : {
+      startDate: change.startDate?.startOf("day") ?? null,
+      endDate: change.endDate?.startOf("day") ?? null
     };
-    const handleCalendarSelection = (data) => {
-      if (data.value) {
-        const calStartDate = data.value.start ? DateTime.fromISO(data.value.start, { zone: "utc" }) : null;
-        const calEndDate = data.value.end ? DateTime.fromISO(data.value.end, { zone: "utc" }) : null;
-        setStartDate(calStartDate);
-        setEndDate(calEndDate);
-        inputRef.current?.setDateRange(calStartDate, calEndDate);
-        const sharedConstraints = {
-          unavailable,
-          minDate: minDate ?? void 0,
-          maxDate: maxDate ?? void 0
-        };
-        onChange?.({
-          startDate: calStartDate?.toISODate() ?? null,
-          endDate: calEndDate?.toISODate() ?? null,
-          isInputValid: !!calStartDate && !!calEndDate,
-          isInputEmpty: !calStartDate && !calEndDate,
-          isDateRangeValid: validateDateRange({
-            required,
-            startDate: calStartDate,
-            endDate: calEndDate,
-            startDateConstraints: sharedConstraints,
-            endDateConstraints: sharedConstraints
-          })
-        });
-      }
+    setStartDate(range?.startDate ?? null);
+    setEndDate(range?.endDate ?? null);
+    onChange?.({
+      startDate: range?.startDate ?? null,
+      endDate: range?.endDate ?? null,
+      isInputValid: change.isInputValid,
+      isInputEmpty: change.isInputEmpty
+    });
+  };
+  const handleCalendarSelection = ({
+    startDate: startDate2,
+    endDate: endDate2
+  }) => {
+    setSharedValue({ startDate: startDate2, endDate: endDate2 });
+    onChange?.({
+      startDate: startDate2,
+      endDate: endDate2,
+      isInputValid: true,
+      isInputEmpty: false
+    });
+  };
+  return {
+    startDate,
+    endDate,
+    setStartDate,
+    setEndDate,
+    handleInputChange,
+    handleCalendarSelection
+  };
+}
+
+const DateFieldRangeCalendar = ({
+  startDate,
+  endDate,
+  onKeyDown,
+  onSelection,
+  minDate,
+  maxDate,
+  unavailable
+}) => {
+  const previousStartDate = usePrevious(startDate);
+  const previousEndDate = usePrevious(endDate);
+  const handleCalendarSelection = (data) => {
+    if (!data.value) return;
+    const calStartDate = data.value.start ? DateTime.fromISO(data.value.start, { zone: "utc" }) : null;
+    const calEndDate = data.value.end ? DateTime.fromISO(data.value.end, { zone: "utc" }) : null;
+    onSelection({
+      startDate: calStartDate,
+      endDate: calEndDate
+    });
+  };
+  const defaultFocusedDate = useMemo(() => {
+    if (!startDate && !endDate) return DateTime.now().toISODate();
+    if (!startDate) return endDate?.toISODate();
+    if (!endDate) return startDate?.toISODate();
+    if (endDate && !previousEndDate?.equals(endDate)) {
+      return endDate.toISODate();
+    } else if (startDate && !previousStartDate?.equals(startDate)) {
+      return startDate.toISODate();
+    }
+    if (endDate) return endDate.toISODate();
+    if (startDate) return startDate.toISODate();
+    return DateTime.now().toISODate();
+  }, [previousStartDate, previousEndDate, startDate, endDate]);
+  return /* @__PURE__ */ jsx(
+    Calendar,
+    {
+      range: true,
+      onKeyDown,
+      defaultFocusedDate,
+      value: {
+        start: startDate?.toISODate() || void 0,
+        end: endDate?.toISODate() || void 0
+      },
+      onSelection: handleCalendarSelection,
+      defaultTimeZone: "UTC",
+      minDate: minDate?.toISODate() ?? void 0,
+      maxDate: maxDate?.toISODate() ?? void 0,
+      unavailable: unavailable ? {
+        dates: unavailable.dates?.map((d) => d.toISODate() ?? ""),
+        daysOfWeek: unavailable.daysOfWeek
+      } : void 0,
+      _disableAutofocus: true
+    },
+    `${startDate?.toISODate()}-${endDate?.toISODate()}`
+  );
+};
+
+const DateFieldRange = ({
+  onFocus,
+  onBlur,
+  disableCalendar,
+  required,
+  mode,
+  ...rest
+}) => {
+  const { ref: wrapperRef } = useFocusWithin({
+    onBlur,
+    onFocus
+  });
+  const { value, defaultValue, minDate, maxDate, unavailable, onChange } = useDateFieldRangeConversion(rest);
+  const inputRef = useRef(null);
+  const [popoverTriggerRef, setPopoverTriggerRef] = useState();
+  const popoverContentRef = useRef(null);
+  const combinedRef = useMergeRefs([popoverTriggerRef, inputRef]);
+  const popoverSupported = usePopoverSupport();
+  const handleChange = (change) => {
+    const sharedConstraints = {
+      unavailable,
+      minDate: minDate ?? void 0,
+      maxDate: maxDate ?? void 0
     };
-    const justTheField = /* @__PURE__ */ jsx(
-      MaskedDateRangeInput,
-      {
-        mode,
-        ref: combinedRef,
-        ...rest,
-        onChange: handleInputChange,
-        disableHint: rest.disableHint,
-        onKeyDown: handleInputKeyDown,
-        onClick: () => setCalendarOpen(true),
+    onChange?.({
+      startDate: change.startDate?.startOf("day") ?? null,
+      endDate: change.endDate?.startOf("day") ?? null,
+      isInputValid: change.isInputValid,
+      isInputEmpty: change.isInputEmpty,
+      isDateRangeValid: validateDateRange({
         required,
-        autoComplete: "off",
-        "data-date-range-valid": isDateRangeValid,
-        startDate: startDate ?? null,
-        endDate: endDate ?? null
+        startDate: change.startDate?.startOf("day") ?? null,
+        endDate: change.endDate?.startOf("day") ?? null,
+        startDateConstraints: sharedConstraints,
+        endDateConstraints: sharedConstraints
+      })
+    });
+  };
+  const { startDate, endDate, handleInputChange, handleCalendarSelection } = useDateFieldRangeState({
+    valueProp: value,
+    defaultValueProp: defaultValue,
+    inputRef,
+    onChange: handleChange
+  });
+  const {
+    calendarOpen,
+    setCalendarOpen,
+    handleCalendarKeyDown,
+    handleInputKeyDown
+  } = useDateFieldOrchestration({
+    inputRef,
+    calendarDefaultOpen: false,
+    popoverContentRef,
+    disableCalendar
+  });
+  const shouldShowCalendar = usePopoverCloseDelayWorkaround(calendarOpen);
+  const currentValidity = useMemo(() => {
+    return validateDateRange({
+      required,
+      startDate,
+      endDate,
+      startDateConstraints: {
+        unavailable,
+        minDate: minDate ?? void 0,
+        maxDate: maxDate ?? void 0
+      },
+      endDateConstraints: {
+        unavailable,
+        minDate: minDate ?? void 0,
+        maxDate: maxDate ?? void 0
       }
-    );
-    if (disableCalendar) {
-      return justTheField;
-    }
-    if (!popoverSupported) {
-      return justTheField;
+    });
+  }, [required, startDate, endDate, minDate, maxDate, unavailable]);
+  const { defaultValue: _, ...passthroughProps } = rest;
+  const justTheField = /* @__PURE__ */ jsx(
+    MaskedDateRangeInput,
+    {
+      mode,
+      ref: combinedRef,
+      ...passthroughProps,
+      startDate: startDate ?? null,
+      endDate: endDate ?? null,
+      onChange: handleInputChange,
+      disableHint: rest.disableHint,
+      onKeyDown: handleInputKeyDown,
+      onClick: () => setCalendarOpen(true),
+      required,
+      autoComplete: "off",
+      "data-date-range-valid": currentValidity
     }
-    return /* @__PURE__ */ jsxs(
-      Popover,
-      {
-        open: calendarOpen,
-        modal: true,
-        placement: "bottom-start",
-        disableFlipFallback: true,
-        disableTriggerFocus: true,
-        onClose: () => setCalendarOpen(false),
-        disableAutoUpdate: true,
-        onOutsidePress: () => setCalendarOpen(false),
-        children: [
-          /* @__PURE__ */ jsx(Popover.Trigger, { children: ({ ref: iRef }) => {
-            setPopoverTriggerRef(iRef);
-            return justTheField;
-          } }),
-          /* @__PURE__ */ jsx(Popover.Content, { ref: popoverContentRef, "data-testid": "calendar-popover", children: shouldShowCalendar && /* @__PURE__ */ jsx(
-            Calendar,
-            {
-              range: true,
-              onKeyDown: handleCalendarKeyDown,
-              defaultFocusedDate,
-              value: {
-                start: startDate?.toISODate() || void 0,
-                end: endDate?.toISODate() || void 0
-              },
-              onSelection: handleCalendarSelection,
-              defaultTimeZone: "UTC",
-              minDate: minDate?.toISODate() ?? void 0,
-              maxDate: maxDate?.toISODate() ?? void 0,
-              unavailable: unavailable ? {
-                dates: unavailable.dates?.map((d) => d.toISODate() ?? ""),
-                daysOfWeek: unavailable.daysOfWeek
-              } : void 0,
-              _disableAutofocus: true
-            },
-            `${startDate?.toISODate()}-${endDate?.toISODate()}`
-          ) })
-        ]
-      }
-    );
+  );
+  if (disableCalendar) {
+    return justTheField;
   }
-);
-NormalizedDateFieldRange.displayName = "NormalizedDateFieldRange";
+  if (!popoverSupported) {
+    return justTheField;
+  }
+  return /* @__PURE__ */ jsx("div", { ref: wrapperRef, children: /* @__PURE__ */ jsxs(
+    Popover,
+    {
+      open: calendarOpen,
+      modal: true,
+      placement: "bottom-start",
+      disableFlipFallback: true,
+      disableTriggerFocus: true,
+      onClose: () => setCalendarOpen(false),
+      disableAutoUpdate: true,
+      onOutsidePress: () => setCalendarOpen(false),
+      children: [
+        /* @__PURE__ */ jsx(Popover.Trigger, { children: ({ ref: iRef }) => {
+          setPopoverTriggerRef(iRef);
+          return justTheField;
+        } }),
+        /* @__PURE__ */ jsx(Popover.Content, { ref: popoverContentRef, "data-testid": "calendar-popover", children: shouldShowCalendar && /* @__PURE__ */ jsx(
+          DateFieldRangeCalendar,
+          {
+            startDate,
+            endDate,
+            onKeyDown: handleCalendarKeyDown,
+            onSelection: handleCalendarSelection,
+            minDate,
+            maxDate,
+            unavailable
+          }
+        ) })
+      ]
+    }
+  ) });
+};
+DateFieldRange.displayName = "DateFieldRange";
 function validateDateRange({
   required,
   startDate,
@@ -2806,80 +2955,233 @@ function validateDateRange({
   }) && (!startDate || !endDate || startDate <= endDate);
 }
 
-const DateFieldRange = ({
-  value,
-  defaultValue,
-  minDate,
-  maxDate,
-  unavailable,
-  onChange,
-  onFocus,
-  onBlur,
-  ...rest
+const yearlessDatePlaceholderMask = ({
+  mode,
+  separator = "/",
+  placeholder
 }) => {
-  const handleBlur = useCallback(
-    (event) => {
-      onBlur?.(event);
-    },
-    [onBlur]
+  const dateOptions = maskitoDateOptionsGenerator({
+    mode,
+    separator
+  });
+  const { plugins, removePlaceholder, ...placeholderOptions } = maskitoWithPlaceholder(placeholder);
+  const datePlaceholderMask = {
+    ...dateOptions,
+    plugins: plugins.concat(dateOptions.plugins || []),
+    preprocessors: [
+      ...placeholderOptions.preprocessors,
+      ...dateOptions.preprocessors,
+      makeZeroShortcutPreprocessor(mode, separator)
+    ],
+    postprocessors: [
+      ...dateOptions.postprocessors,
+      ...placeholderOptions.postprocessors
+    ]
+  };
+  return { options: datePlaceholderMask, removePlaceholder };
+};
+
+const MaskedYearlessDateInput = forwardRef(({ onChange, mode = "mm/dd", value, disableHint = false, ...props }, ref) => {
+  const placeholder = "__/__";
+  const [inputValue, setInputValue] = useState(placeholder);
+  const { options, removePlaceholder } = yearlessDatePlaceholderMask({
+    mode,
+    placeholder
+  });
+  const maskedInputRef = useMaskito({ options });
+  const inputRef = useRef(null);
+  const combinedRef = useMergeRefs$1([maskedInputRef, inputRef, ref]);
+  const previousValue = usePrevious(value);
+  const previousMode = usePrevious(mode);
+  useEffect(() => {
+    if (mode !== previousMode) {
+      setInputValue(
+        (oldInputValue) => swapMode(oldInputValue, previousMode ?? mode, mode)
+      );
+    }
+  }, [mode, previousMode]);
+  useEffect(() => {
+    if (previousValue?.day !== value?.day || previousValue?.month !== value?.month) {
+      if (value?.day && value?.month) {
+        setInputValue(stringifyYearlessDate(value.day, value.month, mode));
+      } else if (previousValue !== null && previousValue !== void 0 && (value === null || value?.day === null && value?.month === null)) {
+        setInputValue(placeholder);
+      } else {
+        return;
+      }
+    }
+  }, [value, mode, previousValue]);
+  const currentParsedData = useMemo(() => {
+    return parseInputValue(inputValue, mode, removePlaceholder);
+  }, [inputValue, mode, removePlaceholder]);
+  const handleChange = (event) => {
+    setInputValue(event.target.value);
+    const {
+      value: v,
+      isInputValid,
+      isInputEmpty
+    } = parseInputValue(event.target.value, mode, removePlaceholder);
+    onChange?.({
+      event,
+      value: v ?? currentParsedData.value ?? null,
+      isInputValid,
+      isInputEmpty
+    });
+  };
+  useImperativeHandle(ref, () => {
+    const input = inputRef.current;
+    if (!input) return null;
+    return Object.assign(input, {
+      setValue: (value2) => {
+        if (!value2) {
+          setInputValue(placeholder);
+          return;
+        }
+        setInputValue(
+          stringifyYearlessDate(value2.day ?? 1, value2.month ?? 1, mode)
+        );
+      }
+    });
+  }, [mode, placeholder]);
+  return /* @__PURE__ */ jsx(
+    TextField,
+    {
+      ref: combinedRef,
+      "data-month-value": value?.month,
+      "data-day-value": value?.day,
+      "data-input-valid": currentParsedData.isInputValid,
+      "data-input-empty": currentParsedData.isInputEmpty,
+      ...props,
+      showCounter: false,
+      value: inputValue,
+      onChange: handleChange,
+      hint: disableHint ? void 0 : `Format: ${mode}`
+    }
   );
-  const handleFocus = useCallback(
-    (event) => {
-      onFocus?.(event);
+});
+MaskedYearlessDateInput.displayName = "MaskedYearlessDateInput";
+function parseInputValue(value, mode, removePlaceholder) {
+  const valueMinusPlaceholder = removePlaceholder(value);
+  const [segment1, segment2] = valueMinusPlaceholder.split("/");
+  const incompleteFirstSegment = segment1?.length !== 2;
+  const incompleteSecondSegment = segment2?.length !== 2;
+  if (mode === "dd/mm") {
+    return {
+      value: {
+        day: incompleteFirstSegment ? null : parseInt(segment1),
+        month: incompleteSecondSegment ? null : parseInt(segment2)
+      },
+      isInputValid: !incompleteFirstSegment && !incompleteSecondSegment,
+      isInputEmpty: valueMinusPlaceholder === ""
+    };
+  }
+  return {
+    value: {
+      day: incompleteSecondSegment ? null : parseInt(segment2),
+      month: incompleteFirstSegment ? null : parseInt(segment1)
     },
-    [onFocus]
+    isInputValid: !incompleteFirstSegment && !incompleteSecondSegment,
+    isInputEmpty: valueMinusPlaceholder === ""
+  };
+}
+function swapMode(inputString, previousMode, mode) {
+  const { day, month } = divideSegments(inputString, previousMode);
+  return stringifyYearlessDate(day, month, mode);
+}
+function divideSegments(value, mode) {
+  const [segment1, segment2] = value.split("/");
+  if (mode === "dd/mm") {
+    return { day: segment1, month: segment2 };
+  }
+  return { day: segment2, month: segment1 };
+}
+function stringifyYearlessDate(day, month, mode) {
+  const dd = day.toString().padStart(2, "0");
+  const mm = month.toString().padStart(2, "0");
+  if (mode === "dd/mm") {
+    return `${dd}/${mm}`;
+  }
+  return `${mm}/${dd}`;
+}
+
+const useConditionalChange = ({
+  changeHandler,
+  compareFn
+}) => {
+  const lastChangeRef = useRef(null);
+  const onChange = useCallback(
+    (change) => {
+      if (!!lastChangeRef.current && !compareFn(lastChangeRef.current, change)) {
+        return;
+      }
+      changeHandler?.(change);
+      lastChangeRef.current = change;
+    },
+    [changeHandler, compareFn]
   );
-  const { ref: wrapperRef } = useFocusWithin({
-    onBlur: handleBlur,
-    onFocus: handleFocus
+  return onChange;
+};
+
+const DateFieldYearless = ({
+  value: valueProp,
+  defaultValue: defaultValueProp,
+  onChange,
+  minDate,
+  maxDate,
+  unavailable,
+  required,
+  ...restProps
+}) => {
+  const [value, setValue] = useOptionallyControlledState({
+    controlledValue: valueProp,
+    defaultValue: defaultValueProp
   });
-  const normalizedValue = useMemo(
-    () => value !== void 0 ? {
-      startDate: convertStringToDate(value?.startDate ?? null) ?? null,
-      endDate: convertStringToDate(value?.endDate ?? null) ?? null
-    } : void 0,
-    [value]
-  );
-  const normalizedDefaultValue = useMemo(
-    () => defaultValue !== void 0 ? {
-      startDate: convertStringToDate(defaultValue?.startDate ?? null) ?? null,
-      endDate: convertStringToDate(defaultValue?.endDate ?? null) ?? null
-    } : void 0,
-    [defaultValue]
-  );
-  const normalizedMinDate = useMemo(
-    () => convertStringToDate(minDate),
-    [minDate]
-  );
-  const normalizedMaxDate = useMemo(
-    () => convertStringToDate(maxDate),
-    [maxDate]
-  );
-  const normalizedUnavailableDates = useMemo(
-    () => unavailable?.dates?.map((d) => convertStringToDate(d)).filter((d) => d !== null && d !== void 0),
-    [unavailable?.dates]
+  const currentValidity = useMemo(
+    () => validateYearlessDate({
+      value: value ?? null,
+      constraints: {
+        required,
+        unavailable,
+        minDate,
+        maxDate
+      }
+    }),
+    [value, required, unavailable, minDate, maxDate]
   );
-  const handleChange = useConditionalChange({
+  const conditionalChange = useConditionalChange({
     changeHandler: onChange,
-    compareFn: (a, b) => a.isInputValid !== b.isInputValid || a.isInputEmpty !== b.isInputEmpty || a.isDateRangeValid !== b.isDateRangeValid || a.startDate !== b.startDate || a.endDate !== b.endDate
+    compareFn: (a, b) => a.isInputValid !== b.isInputValid || a.isInputEmpty !== b.isInputEmpty || a.isValid !== b.isValid || a.value?.day !== b.value?.day || a.value?.month !== b.value?.month
   });
-  return /* @__PURE__ */ jsx("div", { ref: wrapperRef, children: /* @__PURE__ */ jsx(
-    NormalizedDateFieldRange,
+  const handleInputChange = (change) => {
+    const { event, value: value2, ...restChange } = change;
+    setValue(value2);
+    return conditionalChange({
+      ...restChange,
+      value: value2,
+      isValid: validateYearlessDate({
+        value: value2,
+        constraints: {
+          required,
+          unavailable,
+          minDate,
+          maxDate
+        }
+      })
+    });
+  };
+  return /* @__PURE__ */ jsx(
+    MaskedYearlessDateInput,
     {
-      ...rest,
-      value: normalizedValue,
-      defaultValue: normalizedDefaultValue,
-      minDate: normalizedMinDate,
-      maxDate: normalizedMaxDate,
-      unavailable: unavailable ? {
-        dates: normalizedUnavailableDates,
-        daysOfWeek: unavailable?.daysOfWeek
-      } : void 0,
-      onChange: handleChange
+      required,
+      ...restProps,
+      autoComplete: "off",
+      onChange: handleInputChange,
+      value,
+      "data-valid": currentValidity
     }
-  ) });
+  );
 };
-DateFieldRange.displayName = "DateFieldRange";
+DateFieldYearless.displayName = "DateFieldYearless";
 
-export { DateFieldRange as D, DateFieldSingle as a };
-//# sourceMappingURL=DateFieldRange-BRjBcR4r-CfuSiOfZ.js.map
+export { DateFieldRange as D, DateFieldSingle as a, DateFieldYearless as b };
+//# sourceMappingURL=DateFieldYearless-M5KDI_hn-akXtkIZA.js.map