@servicetitan/anvil2 1.42.2 → 1.43.0

package/dist/DateFieldYearless-CAUHW6Ow-EUWxJ0OY.js

@@ -0,0 +1,1431 @@
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { u as usePopoverSupport, a as useMaskito, m as maskitoDateRangeOptionsGenerator, b as maskitoWithPlaceholder, c as maskitoParseDate, d as maskitoDateOptionsGenerator } from './usePopoverSupport-B9Lsqryr-DhZHMoNb.js';
+import { T as TextField } from './TextField-CRTh0gL_-D2CjcYXX.js';
+import { useRef, useState, useMemo, forwardRef, useCallback, useEffect, useImperativeHandle } from 'react';
+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 { S as SvgEvent } from './event-BEJFimi3.js';
+import { P as Popover } from './Popover-CU2cGVD8-Casl3vM1.js';
+import { u as useOptionallyControlledState } from './useOptionallyControlledState-DAv5LXXh-DAv5LXXh.js';
+import { u as useMergeRefs } from './useMergeRefs-Bde85AWI-Bde85AWI.js';
+import { u as usePopoverCloseDelayWorkaround } from './usePopoverCloseDelayWorkaround-BZcjPkvT-BZcjPkvT.js';
+import { u as useKeyboardFocusables } from './ProgressBar-BRvB-bD4-DppwBrFg.js';
+
+function usePrevious(value) {
+  const ref = useRef();
+  useEffect(() => {
+    ref.current = value;
+  }, [value]);
+  return ref.current;
+}
+
+const makeZeroShortcutPreprocessor = (templateString, separator) => {
+  const zeroShortcutPreprocessor = ({ elementState, data }, actionType) => {
+    if (actionType === "insert" && // the user is inserting a character
+    data === separator && // the user typed the separator character
+    elementState.selection[0] === elementState.selection[1]) {
+      const selectionIndex = elementState.selection[0];
+      const separatorPositions = templateString.split("").map((char, index) => char === separator ? index : null).filter((position) => position !== null).filter((position) => position > selectionIndex);
+      const noRemainingSegments = !separatorPositions.length;
+      const nothingEnteredYet = !elementState.value.length;
+      const previousCharacterIsNotADigit = !/^\d$/.test(
+        elementState.value.slice(-1)
+      );
+      const currentCharacterIsSeparator = templateString[selectionIndex] === separator;
+      if (noRemainingSegments || nothingEnteredYet || previousCharacterIsNotADigit || currentCharacterIsSeparator) {
+        return { elementState, data };
+      }
+      const firstIndexOfSegment = Math.max(
+        elementState.value.lastIndexOf(separator) + 1,
+        elementState.value.lastIndexOf(" ") + 1,
+        0
+      );
+      const lastIndexOfSegment = separatorPositions[0];
+      const digitsCurrentlyInSegment = elementState.value.slice(firstIndexOfSegment);
+      const targetNumberOfDigitsInSegment = templateString.slice(
+        firstIndexOfSegment,
+        lastIndexOfSegment
+      ).length;
+      const newSegment = digitsCurrentlyInSegment.padStart(
+        targetNumberOfDigitsInSegment,
+        "0"
+      );
+      const newValue = `${elementState.value.slice(0, firstIndexOfSegment)}${newSegment}`;
+      return {
+        elementState: {
+          value: newValue + data,
+          selection: [newValue.length, newValue.length]
+        },
+        data
+      };
+    }
+    return { elementState, data };
+  };
+  return zeroShortcutPreprocessor;
+};
+
+const datePlaceholderMask$1 = ({
+  mode,
+  separator = "/",
+  placeholder
+}) => {
+  const dateOptions = maskitoDateOptionsGenerator({
+    mode,
+    separator
+  });
+  const { plugins, removePlaceholder, ...placeholderOptions } = maskitoWithPlaceholder(placeholder);
+  const datePlaceholderMask2 = {
+    ...dateOptions,
+    plugins: plugins.concat(dateOptions.plugins || []),
+    preprocessors: [
+      ...placeholderOptions.preprocessors,
+      ...dateOptions.preprocessors,
+      makeZeroShortcutPreprocessor(mode, separator)
+    ],
+    postprocessors: [
+      ...dateOptions.postprocessors,
+      ...placeholderOptions.postprocessors
+    ]
+  };
+  return { options: datePlaceholderMask2, removePlaceholder };
+};
+
+const DateModeToFormatMap = {
+  "mm/dd/yyyy": "MM/dd/yyyy",
+  "dd/mm/yyyy": "dd/MM/yyyy",
+  "yyyy/mm/dd": "yyyy/MM/dd"
+};
+const DateModeToPlaceholderMap = {
+  "dd/mm/yyyy": "__/__/____",
+  "mm/dd/yyyy": "__/__/____",
+  "yyyy/mm/dd": "____/__/__"
+};
+
+const MaskedDateInput = forwardRef(
+  ({
+    onChange,
+    mode = "mm/dd/yyyy",
+    lastValidDate,
+    disableHint = false,
+    ...props
+  }, ref) => {
+    const placeholder = DateModeToPlaceholderMap[mode];
+    const [inputValue, setInputValue] = useState(placeholder);
+    const { options, removePlaceholder } = datePlaceholderMask$1({
+      mode,
+      placeholder
+    });
+    const maskedInputRef = useMaskito({ options });
+    const inputRef = useRef(null);
+    const combinedRef = useMergeRefs$1([maskedInputRef, inputRef, ref]);
+    const previousDateRef = useRef(null);
+    const previousMode = usePrevious(mode);
+    useEffect(() => {
+      if (mode !== previousMode) {
+        setInputValue(
+          (oldInputValue) => swapMode$2(oldInputValue, previousMode ?? mode, mode)
+        );
+      }
+    }, [mode, previousMode]);
+    useEffect(() => {
+      if (lastValidDate === void 0) return;
+      if (lastValidDate === previousDateRef.current) return;
+      if (!lastValidDate?.equals(previousDateRef.current ?? DateTime.now())) {
+        setInputValue(
+          lastValidDate?.toFormat(DateModeToFormatMap[mode]) ?? placeholder
+        );
+        previousDateRef.current = lastValidDate;
+      }
+    }, [lastValidDate, mode, placeholder]);
+    const currentParsedData = useMemo(() => {
+      return parseInputValue$1(inputValue, mode, removePlaceholder);
+    }, [inputValue, mode, removePlaceholder]);
+    const handleChange = (event) => {
+      setInputValue(event.target.value);
+      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?.({
+        date: date ?? lastValidDate ?? null,
+        isInputValid,
+        isInputEmpty
+      });
+    };
+    useImperativeHandle(ref, () => {
+      const input = inputRef.current;
+      if (!input) return null;
+      return Object.assign(input, {
+        setDate: (date) => {
+          setInputValue(
+            date?.toFormat(DateModeToFormatMap[mode]) ?? placeholder
+          );
+        }
+      });
+    }, [mode, placeholder]);
+    return /* @__PURE__ */ jsx(
+      TextField,
+      {
+        ref: combinedRef,
+        "data-date": lastValidDate?.toISODate() ?? "",
+        "data-input-valid": currentParsedData.isInputValid,
+        "data-input-empty": currentParsedData.isInputEmpty,
+        ...props,
+        showCounter: false,
+        value: inputValue,
+        onChange: handleChange,
+        prefix: /* @__PURE__ */ jsx(Icon, { svg: SvgEvent }),
+        hint: disableHint ? void 0 : `Format: ${mode}`
+      }
+    );
+  }
+);
+MaskedDateInput.displayName = "MaskedDateInput";
+function parseInputValue$1(value, mode, removePlaceholder) {
+  const valueMinusPlaceholder = removePlaceholder(value);
+  const jsDate = maskitoParseDate(valueMinusPlaceholder, { mode });
+  const luxonDate = jsDate ? DateTime.fromJSDate(jsDate, { zone: "utc" }) : null;
+  return {
+    date: luxonDate,
+    isInputValid: !!luxonDate,
+    isInputEmpty: valueMinusPlaceholder === ""
+  };
+}
+function swapMode$2(inputString, previousMode, mode) {
+  const { day, month, year } = divideSegments$1(inputString, previousMode);
+  return orderSegmentsByMode(day, month, year, mode);
+}
+function divideSegments$1(value, mode) {
+  const [segment1, segment2, segment3] = value.split("/");
+  if (mode === "dd/mm/yyyy") {
+    return { day: segment1, month: segment2, year: segment3 };
+  } else if (mode === "mm/dd/yyyy") {
+    return { day: segment2, month: segment1, year: segment3 };
+  } else if (mode === "yyyy/mm/dd") {
+    return { day: segment3, month: segment2, year: segment1 };
+  }
+  return { day: "__", month: "__", year: "____" };
+}
+function orderSegmentsByMode(day, month, year, mode) {
+  if (mode === "dd/mm/yyyy") {
+    return `${day}/${month}/${year}`;
+  } else if (mode === "mm/dd/yyyy") {
+    return `${month}/${day}/${year}`;
+  } else if (mode === "yyyy/mm/dd") {
+    return `${year}/${month}/${day}`;
+  } else {
+    return "";
+  }
+}
+
+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,
+  popoverContentRef,
+  disableCalendar = false
+}) => {
+  const documentRef = useRef(document.body);
+  const [calendarOpen, setCalendarOpen] = useState(calendarDefaultOpen);
+  const { focusables } = useKeyboardFocusables(documentRef, {
+    observeChange: true
+  });
+  const { focusables: popoverFocusables } = useKeyboardFocusables(
+    popoverContentRef,
+    {
+      observeChange: true
+    }
+  );
+  const pageFocusables = focusables?.filter(
+    (item) => !popoverFocusables?.includes(item)
+  );
+  const handleCalendarKeyDown = (event) => {
+    if (event.key === "Escape") {
+      inputRef.current?.focus();
+    }
+  };
+  const focusToCalendar = () => {
+    if (popoverContentRef.current) {
+      const currentFocusable = popoverContentRef.current.querySelectorAll('[tabindex = "0"]')[0];
+      if (currentFocusable) {
+        currentFocusable.focus();
+      }
+    }
+  };
+  const handleInputKeyDown = (ev) => {
+    if (disableCalendar) {
+      return;
+    }
+    let currentFocusIndex = 0;
+    switch (ev.key) {
+      case "Escape":
+        setCalendarOpen(false);
+        break;
+      case "Tab":
+        if (!calendarOpen || !pageFocusables?.length) {
+          break;
+        }
+        ev.preventDefault();
+        currentFocusIndex = pageFocusables.indexOf(inputRef.current) || 0;
+        setCalendarOpen(false);
+        if (ev.shiftKey) {
+          if (currentFocusIndex === 0) {
+            requestAnimationFrame(
+              () => pageFocusables[pageFocusables.length - 1].focus()
+            );
+          } else {
+            requestAnimationFrame(
+              () => pageFocusables[currentFocusIndex - 1].focus()
+            );
+          }
+          break;
+        }
+        if (pageFocusables.length > currentFocusIndex + 1) {
+          requestAnimationFrame(
+            () => pageFocusables[currentFocusIndex + 1].focus()
+          );
+        } else {
+          requestAnimationFrame(() => pageFocusables[0].focus());
+        }
+        break;
+      case "ArrowDown":
+        if (!calendarOpen) {
+          setCalendarOpen(true);
+          setTimeout(focusToCalendar, 200);
+        } else {
+          focusToCalendar();
+        }
+    }
+  };
+  return {
+    calendarOpen,
+    setCalendarOpen,
+    handleCalendarKeyDown,
+    handleInputKeyDown
+  };
+};
+
+function useDateFieldSingleState({
+  valueProp,
+  defaultValueProp,
+  inputRef,
+  onChange
+}) {
+  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 DateFieldSingle = ({
+  onFocus,
+  onBlur,
+  disableCalendar,
+  required,
+  mode,
+  value: valueProp,
+  defaultValue: defaultValueProp,
+  minDate: minDateProp,
+  maxDate: maxDateProp,
+  unavailable: unavailableProp,
+  onChange: onChangeProp,
+  ...rest
+}) => {
+  const inputRef = useRef(null);
+  const {
+    value: normalizedValue,
+    defaultValue: normalizedDefaultValue,
+    minDate,
+    maxDate,
+    unavailable,
+    onChange
+  } = useDateFieldSingleConversion({
+    value: valueProp,
+    defaultValue: defaultValueProp,
+    onChange: onChangeProp,
+    minDate: minDateProp,
+    maxDate: maxDateProp,
+    unavailable: unavailableProp
+  });
+  const handleChange = (change) => {
+    onChange?.({
+      ...change,
+      isDateValid: validateDate({
+        date: change.date,
+        constraints: {
+          required,
+          unavailable,
+          minDate: minDate ?? void 0,
+          maxDate: maxDate ?? void 0
+        }
+      })
+    });
+  };
+  const { value, handleInputChange, handleCalendarSelection } = useDateFieldSingleState({
+    valueProp: normalizedValue,
+    defaultValueProp: normalizedDefaultValue,
+    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,
+        unavailable,
+        minDate: minDate ?? void 0,
+        maxDate: maxDate ?? void 0
+      }
+    }),
+    [value, required, unavailable, minDate, maxDate]
+  );
+  const justTheField = /* @__PURE__ */ jsx(
+    MaskedDateInput,
+    {
+      ...rest,
+      mode,
+      ref: combinedRef,
+      onChange: handleInputChange,
+      onKeyDown: handleInputKeyDown,
+      onClick: () => setCalendarOpen(true),
+      lastValidDate: value,
+      required,
+      autoComplete: "off",
+      "data-date-valid": currentValidity
+    }
+  );
+  if (disableCalendar) {
+    return justTheField;
+  }
+  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,
+      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
+          }
+        ) })
+      ]
+    }
+  ) });
+};
+DateFieldSingle.displayName = "DateFieldSingle";
+
+const datePlaceholderMask = ({
+  mode,
+  dateSeparator = "/",
+  rangeSeparator = " - ",
+  placeholder
+}) => {
+  const dateRangeOptions = maskitoDateRangeOptionsGenerator({
+    mode,
+    dateSeparator,
+    rangeSeparator
+  });
+  const { plugins, removePlaceholder, ...placeholderOptions } = maskitoWithPlaceholder(placeholder);
+  const datePlaceholderMask2 = {
+    ...dateRangeOptions,
+    plugins: plugins.concat(dateRangeOptions.plugins || []),
+    preprocessors: [
+      ...placeholderOptions.preprocessors,
+      ...dateRangeOptions.preprocessors,
+      makeZeroShortcutPreprocessor(placeholder, dateSeparator)
+    ],
+    postprocessors: [
+      // NOTE this is super fragile. If Maskito maintainers change the order of the post-processors, this will break.
+      // The last postprocessor is the date swap postprocessor, which we don't want to run.
+      // A unit test is added to ensure this doesn't break on a dependency update.
+      ...dateRangeOptions.postprocessors.slice(0, -1),
+      ...placeholderOptions.postprocessors
+    ]
+  };
+  return { options: datePlaceholderMask2, removePlaceholder };
+};
+
+const RANGE_SEPARATOR = " - ";
+const MaskedDateRangeInput = forwardRef(
+  ({
+    onChange,
+    mode = "mm/dd/yyyy",
+    startDate,
+    endDate,
+    disableHint = false,
+    ...props
+  }, ref) => {
+    const halfPlaceholder = DateModeToPlaceholderMap[mode];
+    const fullPlaceholder = `${halfPlaceholder}${RANGE_SEPARATOR}${halfPlaceholder}`;
+    const [inputValue, setInputValue] = useState(fullPlaceholder);
+    const { options, removePlaceholder } = datePlaceholderMask({
+      mode,
+      placeholder: fullPlaceholder,
+      dateSeparator: "/",
+      rangeSeparator: RANGE_SEPARATOR
+    });
+    const maskedInputRef = useMaskito({ options });
+    const inputRef = useRef(null);
+    const combinedRef = useMergeRefs$1([maskedInputRef, inputRef, ref]);
+    const previousStartDate = usePrevious(startDate);
+    const previousEndDate = usePrevious(endDate);
+    const previousMode = usePrevious(mode);
+    useEffect(() => {
+      if (mode !== previousMode) {
+        setInputValue(
+          (previousInputValue) => swapMode$1(previousInputValue, previousMode ?? mode, mode)
+        );
+      }
+    }, [mode, fullPlaceholder, previousMode]);
+    useEffect(() => {
+      if (startDate === void 0 || endDate === void 0) return;
+      if (startDate === previousStartDate && endDate === previousEndDate)
+        return;
+      if (
+        // plus one just represents a date that is guaranteed to be different.
+        startDate?.equals(previousStartDate ?? startDate?.plus({ days: 1 })) && (endDate?.equals(previousEndDate ?? endDate?.plus({ days: 1 })) || endDate === previousEndDate)
+      )
+        return;
+      const startDateString = startDate?.toFormat(DateModeToFormatMap[mode]) ?? halfPlaceholder;
+      const endDateString = endDate?.toFormat(DateModeToFormatMap[mode]) ?? halfPlaceholder;
+      const newInputValue = `${startDateString}${RANGE_SEPARATOR}${endDateString}`;
+      setInputValue(newInputValue);
+    }, [
+      startDate,
+      endDate,
+      mode,
+      halfPlaceholder,
+      previousStartDate,
+      previousEndDate
+    ]);
+    const currentParsedData = useMemo(() => {
+      return parseRangeInputValue(inputValue, mode, removePlaceholder);
+    }, [inputValue, mode, removePlaceholder]);
+    const handleChange = (event) => {
+      setInputValue(event.target.value);
+      const {
+        startDate: parsedStartDate,
+        endDate: parsedEndDate,
+        isInputValid,
+        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?.({
+        startDate: isInputEmpty ? null : parsedStartDate ?? startDate ?? null,
+        endDate: isInputEmpty || isHalfEmpty ? null : parsedEndDate ?? endDate ?? null,
+        isInputValid,
+        isInputEmpty
+      });
+    };
+    useImperativeHandle(ref, () => {
+      const input = inputRef.current;
+      if (!input) return null;
+      return Object.assign(input, {
+        setDateRange: (startDate2, endDate2) => {
+          const startDateString = startDate2?.toFormat(
+            DateModeToFormatMap[mode]
+          );
+          const endDateString = endDate2?.toFormat(DateModeToFormatMap[mode]);
+          const newInputValue = `${startDateString ?? halfPlaceholder}${RANGE_SEPARATOR}${endDateString ?? halfPlaceholder}`;
+          setInputValue(newInputValue);
+        }
+      });
+    }, [mode, halfPlaceholder]);
+    return /* @__PURE__ */ jsx(
+      TextField,
+      {
+        ref: combinedRef,
+        "data-start-date": startDate?.toISODate() ?? "",
+        "data-end-date": endDate?.toISODate() ?? "",
+        "data-input-valid": currentParsedData.isInputValid,
+        "data-input-empty": currentParsedData.isInputEmpty,
+        ...props,
+        showCounter: false,
+        value: inputValue,
+        onChange: handleChange,
+        prefix: /* @__PURE__ */ jsx(Icon, { svg: SvgEvent }),
+        hint: disableHint ? void 0 : `Format: ${mode}`
+      }
+    );
+  }
+);
+MaskedDateRangeInput.displayName = "MaskedDateRangeInput";
+function parseRangeInputValue(value, mode, removePlaceholder) {
+  const valueMinusPlaceholder = removePlaceholder(value);
+  const [startDate, endDate] = valueMinusPlaceholder.split(RANGE_SEPARATOR);
+  const startJsDate = maskitoParseDate(startDate, { mode });
+  const endJsDate = endDate ? maskitoParseDate(endDate, { mode }) : null;
+  const startLuxonDate = startJsDate ? DateTime.fromJSDate(startJsDate, { zone: "utc" }) : null;
+  const endLuxonDate = endJsDate ? DateTime.fromJSDate(endJsDate, { zone: "utc" }) : null;
+  return {
+    startDate: startLuxonDate,
+    endDate: endLuxonDate,
+    isInputValid: !!(startLuxonDate && endLuxonDate),
+    // input valid if both dates are filled
+    isInputEmpty: valueMinusPlaceholder === "",
+    // input empty if nothing is typed
+    isHalfEmpty: endDate === void 0
+  };
+}
+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;
+  if (previousMode === "mm/dd/yyyy") {
+    startDay = segments[0][1];
+    startMonth = segments[0][0];
+    startYear = segments[0][2];
+    endDay = segments[1][1];
+    endMonth = segments[1][0];
+    endYear = segments[1][2];
+  }
+  if (previousMode === "dd/mm/yyyy") {
+    startDay = segments[0][0];
+    startMonth = segments[0][1];
+    startYear = segments[0][2];
+    endDay = segments[1][0];
+    endMonth = segments[1][1];
+    endYear = segments[1][2];
+  }
+  if (previousMode === "yyyy/mm/dd") {
+    startDay = segments[0][2];
+    startMonth = segments[0][1];
+    startYear = segments[0][0];
+    endDay = segments[1][2];
+    endMonth = segments[1][1];
+    endYear = segments[1][0];
+  }
+  if (mode === "mm/dd/yyyy") {
+    return `${startMonth}/${startDay}/${startYear}${RANGE_SEPARATOR}${endMonth}/${endDay}/${endYear}`;
+  }
+  if (mode === "dd/mm/yyyy") {
+    return `${startDay}/${startMonth}/${startYear}${RANGE_SEPARATOR}${endDay}/${endMonth}/${endYear}`;
+  }
+  if (mode === "yyyy/mm/dd") {
+    return `${startYear}/${startMonth}/${startDay}${RANGE_SEPARATOR}${endYear}/${endMonth}/${endDay}`;
+  }
+  return inputString;
+}
+
+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?.({
+        ...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
+    };
+    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,
+  value: valueProp,
+  defaultValue: defaultValueProp,
+  minDate: minDateProp,
+  maxDate: maxDateProp,
+  unavailable: unavailableProp,
+  onChange: onChangeProp,
+  ...rest
+}) => {
+  const { ref: wrapperRef } = useFocusWithin({
+    onBlur,
+    onFocus
+  });
+  const { value, defaultValue, minDate, maxDate, unavailable, onChange } = useDateFieldRangeConversion({
+    value: valueProp,
+    defaultValue: defaultValueProp,
+    minDate: minDateProp,
+    maxDate: maxDateProp,
+    unavailable: unavailableProp,
+    onChange: onChangeProp
+  });
+  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
+    };
+    onChange?.({
+      startDate: change.startDate?.startOf("day") ?? null,
+      endDate: change.endDate?.startOf("day") ?? null,
+      isInputValid: change.isInputValid,
+      isInputEmpty: change.isInputEmpty,
+      isDateRangeValid: validateDateRange({
+        required,
+        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
+      }
+    });
+  }, [required, startDate, endDate, minDate, maxDate, unavailable]);
+  const justTheField = /* @__PURE__ */ jsx(
+    MaskedDateRangeInput,
+    {
+      ...rest,
+      mode,
+      ref: combinedRef,
+      startDate: startDate ?? null,
+      endDate: endDate ?? null,
+      onChange: handleInputChange,
+      disableHint: rest.disableHint,
+      onKeyDown: handleInputKeyDown,
+      onClick: () => setCalendarOpen(true),
+      required,
+      autoComplete: "off",
+      "data-date-range-valid": currentValidity
+    }
+  );
+  if (disableCalendar) {
+    return justTheField;
+  }
+  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,
+  endDate,
+  startDateConstraints,
+  endDateConstraints
+}) {
+  if (!required && !startDate && !endDate) return true;
+  return validateDate({
+    date: startDate,
+    constraints: { ...startDateConstraints, required: true }
+  }) && validateDate({
+    date: endDate,
+    constraints: { ...endDateConstraints, required: true }
+  }) && (!startDate || !endDate || startDate <= endDate);
+}
+
+const yearlessDatePlaceholderMask = ({
+  mode,
+  separator = "/",
+  placeholder
+}) => {
+  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);
+    const isDateDifferent = v === null !== (currentParsedData.value === null) || v?.day !== currentParsedData.value?.day || v?.month !== currentParsedData.value?.month;
+    if (!isDateDifferent) {
+      return;
+    }
+    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}`
+    }
+  );
+});
+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)
+    },
+    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 DateFieldYearless = ({
+  value: valueProp,
+  defaultValue: defaultValueProp,
+  onChange,
+  minDate,
+  maxDate,
+  unavailable,
+  required,
+  ...restProps
+}) => {
+  const [value, setValue] = useOptionallyControlledState({
+    controlledValue: valueProp,
+    defaultValue: defaultValueProp
+  });
+  const currentValidity = useMemo(
+    () => validateYearlessDate({
+      value: value ?? null,
+      constraints: {
+        required,
+        unavailable,
+        minDate,
+        maxDate
+      }
+    }),
+    [value, required, unavailable, minDate, maxDate]
+  );
+  const handleInputChange = (change) => {
+    const { event, value: value2, ...restChange } = change;
+    setValue(value2);
+    return onChange?.({
+      ...restChange,
+      value: value2,
+      isValid: validateYearlessDate({
+        value: value2,
+        constraints: {
+          required,
+          unavailable,
+          minDate,
+          maxDate
+        }
+      })
+    });
+  };
+  return /* @__PURE__ */ jsx(
+    MaskedYearlessDateInput,
+    {
+      required,
+      ...restProps,
+      autoComplete: "off",
+      onChange: handleInputChange,
+      value,
+      "data-valid": currentValidity
+    }
+  );
+};
+DateFieldYearless.displayName = "DateFieldYearless";
+
+export { DateFieldRange as D, DateFieldSingle as a, DateFieldYearless as b };
+//# sourceMappingURL=DateFieldYearless-CAUHW6Ow-EUWxJ0OY.js.map