@servicetitan/anvil2 1.44.2 → 1.45.1

package/dist/DateFieldYearless-pejtv7-x-DBHpW83U.js

@@ -1,1373 +0,0 @@
-import { jsx, jsxs } from 'react/jsx-runtime';
-import { u as useMaskito, m as maskitoDateRangeOptionsGenerator, a as maskitoWithPlaceholder, b as maskitoParseDate, c as maskitoDateOptionsGenerator } from './index.esm-dyoPQhi6.js';
-import { T as TextField } from './TextField-DoPP1CQ--UWAOTYiv.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-BvftKznl-D4_xp9Rv.js';
-import { I as Icon } from './Icon-B6HmlQiR-BxQkO3X5.js';
-import { S as SvgEvent } from './event-BEJFimi3.js';
-import { u as useFocusWithin, a as usePrevious } from './useFocusWithin-Cxz14Zyz-DEudRcSI.js';
-import { P as Popover } from './Popover-CU2cGVD8-Casl3vM1.js';
-import { u as usePopoverSupport } from './usePopoverSupport-B9Lsqryr-CYJxXiun.js';
-import { u as useOptionallyControlledState } from './useOptionallyControlledState-DbDuos5L-DbDuos5L.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';
-
-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 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-pejtv7-x-DBHpW83U.js.map