clayui-date-picker 3.165.0

package/lib/cjs/index.js

@@ -0,0 +1,705 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  FirstDayOfWeek: () => FirstDayOfWeek,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var import_button = __toESM(require("@clayui/button"));
+var import_core = require("@clayui/core");
+var import_drop_down = __toESM(require("@clayui/drop-down"));
+var import_form = require("@clayui/form");
+var import_icon = __toESM(require("@clayui/icon"));
+var import_shared = require("@clayui/shared");
+var import_react = __toESM(require("react"));
+var import_DateNavigation = __toESM(require("./DateNavigation"));
+var import_DayNumber = __toESM(require("./DayNumber"));
+var import_DaysTable = __toESM(require("./DaysTable"));
+var import_Helpers = require("./Helpers");
+var import_Hooks = require("./Hooks");
+var import_InputDate = __toESM(require("./InputDate"));
+var import_TimePicker = __toESM(require("./TimePicker"));
+var import_Weekday = __toESM(require("./Weekday"));
+var import_WeekdayHeader = __toESM(require("./WeekdayHeader"));
+var FirstDayOfWeek = /* @__PURE__ */ ((FirstDayOfWeek2) => {
+  FirstDayOfWeek2[FirstDayOfWeek2["Sunday"] = 0] = "Sunday";
+  FirstDayOfWeek2[FirstDayOfWeek2["Monday"] = 1] = "Monday";
+  FirstDayOfWeek2[FirstDayOfWeek2["Tuesday"] = 2] = "Tuesday";
+  FirstDayOfWeek2[FirstDayOfWeek2["Wednesday"] = 3] = "Wednesday";
+  FirstDayOfWeek2[FirstDayOfWeek2["Thursday"] = 4] = "Thursday";
+  FirstDayOfWeek2[FirstDayOfWeek2["Friday"] = 5] = "Friday";
+  FirstDayOfWeek2[FirstDayOfWeek2["Saturday"] = 6] = "Saturday";
+  return FirstDayOfWeek2;
+})(FirstDayOfWeek || {});
+const DEFAULT_DATE_TIME = {
+  hours: 12,
+  milliseconds: 0,
+  minutes: 0,
+  seconds: 0
+};
+const NEW_DATE = /* @__PURE__ */ new Date();
+const TIME_FORMAT = "HH:mm";
+const TIME_FORMAT_12H = "hh:mm aa";
+function normalizeTime(date) {
+  return (0, import_Helpers.setDate)(date, { hours: 12, milliseconds: 0, minutes: 0, seconds: 0 });
+}
+const DatePicker = import_react.default.forwardRef(
+  ({
+    ariaLabels = {
+      buttonChooseDate: "Choose date",
+      buttonDot: "Select current date",
+      buttonNextMonth: "Select the next month",
+      buttonPreviousMonth: "Select the previous month",
+      chooseDate: "Use the calendar to choose a Date. Current selection {0}",
+      dialog: "Choose date",
+      openCalendar: "Open Calendar Picker",
+      outOfRange: "The entered value is outside the allowed range and was not applied",
+      selectMonth: "Select a month",
+      selectYear: "Select a year"
+    },
+    dateFormat = "yyyy-MM-dd",
+    defaultExpanded,
+    defaultMonth,
+    defaultValue,
+    disabled,
+    displayKeyboardArrowsIndicator = false,
+    expanded,
+    firstDayOfWeek = 0,
+    footerElement,
+    id,
+    initialExpanded = false,
+    initialMonth,
+    inputName,
+    max,
+    min,
+    months = [
+      "January",
+      "February",
+      "March",
+      "April",
+      "May",
+      "June",
+      "July",
+      "August",
+      "September",
+      "October",
+      "November",
+      "December"
+    ],
+    onChange,
+    onExpandedChange,
+    onNavigation = () => {
+    },
+    onValueChange,
+    placeholder,
+    range,
+    spritemap,
+    time = false,
+    timezone,
+    use12Hours = false,
+    useNative = false,
+    value,
+    weekdaysShort = ["S", "M", "T", "W", "T", "F", "S"],
+    years = {
+      end: NEW_DATE.getFullYear(),
+      start: NEW_DATE.getFullYear()
+    },
+    yearsCheck = true,
+    ...otherProps
+  }, ref) => {
+    const [parsedMin, parsedMax] = (0, import_react.useMemo)(() => {
+      const parseBound = (value2) => {
+        if (!value2) {
+          return void 0;
+        }
+        const parsed = (0, import_Helpers.parseDate)(
+          value2,
+          time ? `${dateFormat} ${use12Hours ? TIME_FORMAT_12H : TIME_FORMAT}` : dateFormat,
+          NEW_DATE
+        );
+        return (0, import_Helpers.isValid)(parsed) ? parsed : void 0;
+      };
+      const minDate = parseBound(min);
+      const maxDate = parseBound(max);
+      if (minDate && maxDate && !(0, import_Helpers.isBefore)(minDate, maxDate)) {
+        console.warn(
+          "ClayDatePicker: `min` must be earlier than `max`. Both bounds will be ignored."
+        );
+        return [void 0, void 0];
+      }
+      return [minDate, maxDate];
+    }, [min, max, dateFormat, time, use12Hours]);
+    const isDayDisabled = (0, import_react.useCallback)(
+      (date) => {
+        if (parsedMin && (0, import_Helpers.isBefore)(date, parsedMin) && !(0, import_Helpers.isSameDay)(date, parsedMin)) {
+          return true;
+        }
+        if (parsedMax && (0, import_Helpers.isAfter)(date, parsedMax) && !(0, import_Helpers.isSameDay)(date, parsedMax)) {
+          return true;
+        }
+        return false;
+      },
+      [parsedMin, parsedMax]
+    );
+    const isDateTimeOutOfRange = (0, import_react.useCallback)(
+      (date) => {
+        if (parsedMin && (0, import_Helpers.isBefore)(date, parsedMin)) {
+          return true;
+        }
+        if (parsedMax && (0, import_Helpers.isAfter)(date, parsedMax)) {
+          return true;
+        }
+        return false;
+      },
+      [parsedMin, parsedMax]
+    );
+    const getDefaultMonth = (0, import_react.useCallback)(
+      () => (0, import_Helpers.clamp)(
+        defaultMonth ?? initialMonth ?? /* @__PURE__ */ new Date(),
+        parsedMin,
+        parsedMax
+      ),
+      [defaultMonth, initialMonth, parsedMin, parsedMax]
+    );
+    const [internalValue, setValue, isUncontrolled] = (0, import_shared.useControlledState)({
+      defaultName: "defaultValue",
+      defaultValue,
+      handleName: "onChange",
+      name: "value",
+      onChange: onChange ?? onValueChange,
+      value
+    });
+    const [daysSelected, setDaysSelected] = (0, import_Hooks.useDaysSelected)(() => {
+      if (internalValue) {
+        const days = hasDaysSelected({
+          checkRangeYears: yearsCheck,
+          dateFormat,
+          is12Hours: use12Hours,
+          isTime: time,
+          value: internalValue,
+          years
+        });
+        if (days) {
+          return [normalizeTime(days[0]), normalizeTime(days[1])];
+        }
+      }
+      const date = normalizeTime(getDefaultMonth());
+      return [date, date];
+    });
+    const [currentMonth, setCurrentMonth] = (0, import_react.useState)(
+      () => (
+        // Normalize the date to always set noon to avoid time zone problems
+        // and to the 1st of the month.
+        (0, import_Helpers.setDate)(daysSelected[0], { date: 1, ...DEFAULT_DATE_TIME })
+      )
+    );
+    const chooseDateRef = (0, import_react.useRef)(null);
+    const [currentTime, setCurrentTime] = (0, import_Hooks.useCurrentTime)(() => {
+      if (time && internalValue) {
+        const [startDate] = fromStringToRange(
+          internalValue,
+          `${dateFormat} ${use12Hours ? TIME_FORMAT_12H : TIME_FORMAT}`,
+          NEW_DATE
+        );
+        if (startDate.toString() !== "Invalid Date") {
+          const hours = use12Hours ? (0, import_Helpers.formatDate)(startDate, "hh") : (0, import_Helpers.formatDate)(startDate, "HH");
+          const minutes = (0, import_Helpers.formatDate)(startDate, "mm");
+          return use12Hours ? `${hours}:${minutes} ${(0, import_Helpers.formatDate)(startDate, "a")}` : `${hours}:${minutes}`;
+        }
+      }
+      return "--:--";
+    }, use12Hours);
+    const [weeks, setWeeks] = (0, import_Hooks.useWeeks)(currentMonth, firstDayOfWeek);
+    const [expandedValue, setExpandedValue] = (0, import_shared.useControlledState)({
+      defaultName: "defaultExpanded",
+      defaultValue: defaultExpanded === void 0 ? initialExpanded : defaultExpanded,
+      handleName: "onExpandedChange",
+      name: "expanded",
+      onChange: onExpandedChange,
+      value: expanded
+    });
+    const triggerElementRef = (0, import_react.useRef)(null);
+    const liveRegionRef = (0, import_react.useRef)(null);
+    const announceOutOfRange = (0, import_react.useCallback)(() => {
+      const node = liveRegionRef.current;
+      if (!node || !ariaLabels.outOfRange) {
+        return;
+      }
+      node.textContent = "";
+      node.textContent = ariaLabels.outOfRange;
+    }, [ariaLabels.outOfRange]);
+    const menuElementRef = (0, import_react.useRef)(null);
+    const changeMonth = (date) => {
+      const dateNormalized = (0, import_Helpers.setDate)(date, {
+        date: 1,
+        ...DEFAULT_DATE_TIME
+      });
+      setCurrentMonth(dateNormalized);
+      onNavigation(dateNormalized);
+      if (!useNative) {
+        setWeeks(dateNormalized);
+      }
+    };
+    const timePickerConfig = (0, import_react.useMemo)(() => {
+      if (!time || use12Hours || !parsedMin && !parsedMax) {
+        return void 0;
+      }
+      const [day] = daysSelected;
+      let hoursMin = 0;
+      let hoursMax = 23;
+      let minutesMin = 0;
+      let minutesMax = 59;
+      const currentHours = Number(currentTime.split(":")[0]);
+      if (parsedMin && (0, import_Helpers.isSameDay)(day, parsedMin)) {
+        hoursMin = parsedMin.getHours();
+        if (currentHours === hoursMin) {
+          minutesMin = parsedMin.getMinutes();
+        }
+      }
+      if (parsedMax && (0, import_Helpers.isSameDay)(day, parsedMax)) {
+        hoursMax = parsedMax.getHours();
+        if (currentHours === hoursMax) {
+          minutesMax = parsedMax.getMinutes();
+        }
+      }
+      return {
+        use12Hours: {
+          ampm: { am: "AM", pm: "PM" },
+          hours: { max: 12, min: 1 },
+          minutes: { max: 59, min: 0 }
+        },
+        use24Hours: {
+          ampm: { am: "AM", pm: "PM" },
+          hours: { max: hoursMax, min: hoursMin },
+          minutes: { max: minutesMax, min: minutesMin }
+        }
+      };
+    }, [time, use12Hours, daysSelected, currentTime, parsedMin, parsedMax]);
+    const memoizedYears = (0, import_react.useMemo)(
+      () => (0, import_Helpers.range)(years).map((elem) => {
+        return {
+          label: elem,
+          value: elem
+        };
+      }),
+      [years]
+    );
+    const memoizedMonths = (0, import_react.useMemo)(
+      () => months.map((month, index) => {
+        return {
+          label: month,
+          value: index
+        };
+      }),
+      [months]
+    );
+    const handleDayClicked = (date) => {
+      if (isDayDisabled(date)) {
+        announceOutOfRange();
+        return;
+      }
+      const [startDate, endDate] = daysSelected;
+      let newDaysSelected;
+      let daysSelectedToString;
+      if (range) {
+        if (startDate.toString() !== endDate.toString()) {
+          newDaysSelected = [date, date];
+        } else if (date < startDate) {
+          newDaysSelected = [date, endDate];
+        } else {
+          newDaysSelected = [startDate, date];
+        }
+        daysSelectedToString = fromRangeToString(
+          newDaysSelected,
+          dateFormat
+        );
+        const [newStartDate, newEndDate] = newDaysSelected;
+        if (newStartDate.getMonth() !== newEndDate.getMonth()) {
+          changeMonth(startDate);
+        }
+      } else {
+        newDaysSelected = [date, date];
+        daysSelectedToString = (0, import_Helpers.formatDate)(date, dateFormat);
+        if (time) {
+          daysSelectedToString = `${daysSelectedToString} ${currentTime}`;
+        }
+      }
+      setDaysSelected(newDaysSelected);
+      setValue(daysSelectedToString);
+    };
+    const updateDate = (0, import_react.useCallback)(
+      (value2) => {
+        const currentDate = getDefaultMonth();
+        if (!value2) {
+          changeMonth(currentDate);
+          setDaysSelected([currentDate, currentDate]);
+          if (time) {
+            setCurrentTime(
+              "--",
+              "--",
+              use12Hours ? "--" : void 0
+            );
+          }
+        } else {
+          const days = hasDaysSelected({
+            checkRangeYears: yearsCheck,
+            dateFormat,
+            is12Hours: use12Hours,
+            isTime: time,
+            value: value2,
+            years
+          });
+          if (days) {
+            const [startDate, endDate] = days;
+            const referenceStart = time ? startDate : (0, import_Helpers.setDate)(startDate, {
+              hours: 12,
+              milliseconds: 0,
+              minutes: 0,
+              seconds: 0
+            });
+            const referenceEnd = time ? endDate : (0, import_Helpers.setDate)(endDate, {
+              hours: 12,
+              milliseconds: 0,
+              minutes: 0,
+              seconds: 0
+            });
+            const startOutOfRange = time ? isDateTimeOutOfRange(referenceStart) : isDayDisabled(referenceStart);
+            const endOutOfRange = time ? isDateTimeOutOfRange(referenceEnd) : isDayDisabled(referenceEnd);
+            if (startOutOfRange || endOutOfRange) {
+              announceOutOfRange();
+              return;
+            }
+            if (time) {
+              setCurrentTime(
+                startDate.getHours(),
+                startDate.getMinutes(),
+                use12Hours ? (0, import_Helpers.formatDate)(
+                  startDate,
+                  "a"
+                ) : void 0
+              );
+            } else {
+              changeMonth(startDate);
+              setDaysSelected([startDate, endDate]);
+            }
+          }
+        }
+      },
+      [
+        dateFormat,
+        use12Hours,
+        time,
+        years,
+        yearsCheck,
+        isDayDisabled,
+        isDateTimeOutOfRange,
+        announceOutOfRange
+      ]
+    );
+    const inputChange = (event) => {
+      const { value: value2 } = event.target;
+      updateDate(value2);
+      setValue(value2);
+    };
+    (0, import_react.useEffect)(() => {
+      if (!isUncontrolled) {
+        updateDate(internalValue);
+      }
+    }, [isUncontrolled, internalValue]);
+    const handleDotClicked = () => {
+      const currentDateTime = getDefaultMonth();
+      if (isDayDisabled(currentDateTime)) {
+        announceOutOfRange();
+        return;
+      }
+      const [, endDate] = daysSelected;
+      changeMonth(currentDateTime);
+      const newDaysSelected = range && endDate < currentDateTime ? [endDate, currentDateTime] : [currentDateTime, endDate];
+      let dateFormatted;
+      if (range) {
+        dateFormatted = fromRangeToString(newDaysSelected, dateFormat);
+      } else if (time) {
+        dateFormatted = `${(0, import_Helpers.formatDate)(
+          currentDateTime,
+          dateFormat
+        )} ${setCurrentTime(
+          currentDateTime.getHours(),
+          currentDateTime.getMinutes(),
+          use12Hours ? (0, import_Helpers.formatDate)(currentDateTime, "a") : void 0
+        )}`;
+      } else {
+        dateFormatted = (0, import_Helpers.formatDate)(currentDateTime, dateFormat);
+      }
+      setDaysSelected(newDaysSelected);
+      setValue(dateFormatted);
+    };
+    const handleTimeChange = (hours, minutes, ampm) => {
+      const [day] = daysSelected;
+      if (hours === "--" && typeof minutes === "number") {
+        hours = 0;
+      }
+      if (minutes === "--" && typeof hours === "number") {
+        minutes = 0;
+      }
+      if (typeof hours === "number" && typeof minutes === "number" && (parsedMin || parsedMax)) {
+        let hours24 = hours;
+        if (use12Hours) {
+          if (ampm === "PM" && hours < 12) {
+            hours24 = hours + 12;
+          } else if (ampm === "AM" && hours === 12) {
+            hours24 = 0;
+          }
+        }
+        const dateTimeSelected = (0, import_Helpers.setDate)(day, {
+          hours: hours24,
+          minutes
+        });
+        if (isDateTimeOutOfRange(dateTimeSelected)) {
+          announceOutOfRange();
+          return;
+        }
+      }
+      if (internalValue) {
+        let date = typeof hours === "string" && typeof minutes === "string" ? `${(0, import_Helpers.formatDate)(day, dateFormat)} ${hours}:${minutes}` : (0, import_Helpers.formatDate)(
+          (0, import_Helpers.setDate)(day, { hours, minutes }),
+          `${dateFormat} ${TIME_FORMAT}`
+        );
+        if (use12Hours) {
+          date += ` ${ampm}`;
+        }
+        setValue(date);
+      }
+      setCurrentTime(hours, minutes, use12Hours ? ampm : void 0);
+    };
+    const handleCalendarButtonClicked = () => setExpandedValue(!expandedValue);
+    const calendarNavigation = (0, import_Hooks.useCalendarNavigation)({
+      daysSelected,
+      isOpen: expandedValue,
+      onChangeMonth: (month, year) => {
+        if (typeof year === "number") {
+          changeMonth(
+            (0, import_Helpers.setDate)(currentMonth, {
+              year: currentMonth.getFullYear() + year
+            })
+          );
+        } else {
+          const date = (0, import_Helpers.setMonth)(memoizedYears, month, currentMonth);
+          if (date) {
+            changeMonth(date);
+          }
+        }
+      },
+      weeks
+    });
+    const ariaControls = (0, import_shared.useId)();
+    return /* @__PURE__ */ import_react.default.createElement(import_shared.FocusScope, { arrowKeysUpDown: false }, /* @__PURE__ */ import_react.default.createElement("div", { className: "date-picker" }, /* @__PURE__ */ import_react.default.createElement(
+      "div",
+      {
+        "aria-atomic": "true",
+        "aria-live": "polite",
+        className: "sr-only",
+        ref: liveRegionRef
+      }
+    ), /* @__PURE__ */ import_react.default.createElement(import_form.ClayInput.Group, { ref: triggerElementRef }, /* @__PURE__ */ import_react.default.createElement(import_form.ClayInput.GroupItem, { className: "input-group-item-focusable" }, /* @__PURE__ */ import_react.default.createElement(
+      import_InputDate.default,
+      {
+        ...otherProps,
+        ariaLabel: ariaLabels.input,
+        disabled,
+        id,
+        inputName,
+        onChange: inputChange,
+        placeholder,
+        ref,
+        useNative,
+        value: internalValue
+      }
+    ), !useNative && /* @__PURE__ */ import_react.default.createElement(import_form.ClayInput.GroupInsetItem, { after: true }, /* @__PURE__ */ import_react.default.createElement(
+      import_button.default,
+      {
+        "aria-controls": ariaControls,
+        "aria-expanded": expandedValue,
+        "aria-haspopup": "dialog",
+        "aria-label": ariaLabels.buttonChooseDate,
+        className: "date-picker-dropdown-toggle",
+        "data-testid": "date-button",
+        disabled,
+        displayType: "unstyled",
+        onClick: handleCalendarButtonClicked,
+        ref: chooseDateRef,
+        title: ariaLabels.openCalendar
+      },
+      /* @__PURE__ */ import_react.default.createElement(
+        import_icon.default,
+        {
+          spritemap,
+          symbol: "calendar"
+        }
+      )
+    )))), !useNative && /* @__PURE__ */ import_react.default.createElement(
+      import_drop_down.default.Menu,
+      {
+        active: expandedValue,
+        alignElementRef: triggerElementRef,
+        "aria-label": ariaLabels.dialog,
+        className: "date-picker date-picker-dropdown-menu",
+        "data-testid": "dropdown",
+        id: ariaControls,
+        lock: true,
+        onActiveChange: setExpandedValue,
+        ref: menuElementRef,
+        role: "dialog",
+        triggerRef: chooseDateRef
+      },
+      /* @__PURE__ */ import_react.default.createElement(
+        "div",
+        {
+          "aria-label": ariaLabels.chooseDate && (0, import_shared.sub)(ariaLabels.chooseDate, [
+            (0, import_Helpers.formatDate)(currentMonth, "MMMM yyyy")
+          ]),
+          className: "date-picker-calendar",
+          role: "group"
+        },
+        /* @__PURE__ */ import_react.default.createElement(
+          import_DateNavigation.default,
+          {
+            ariaLabels,
+            currentMonth,
+            disabled,
+            months: memoizedMonths,
+            onDotClicked: handleDotClicked,
+            onMonthChange: changeMonth,
+            spritemap,
+            years: memoizedYears
+          }
+        ),
+        /* @__PURE__ */ import_react.default.createElement(
+          "div",
+          {
+            ...calendarNavigation.gridProps,
+            className: "date-picker-calendar-body",
+            role: "grid"
+          },
+          /* @__PURE__ */ import_react.default.createElement(
+            import_WeekdayHeader.default,
+            {
+              firstDayOfWeek,
+              weekdaysShort
+            },
+            ({ key, weekday }) => /* @__PURE__ */ import_react.default.createElement(
+              import_Weekday.default,
+              {
+                key,
+                weekday
+              }
+            )
+          ),
+          /* @__PURE__ */ import_react.default.createElement(import_DaysTable.default, { weeks }, ({ day, key }) => /* @__PURE__ */ import_react.default.createElement(
+            import_DayNumber.default,
+            {
+              day,
+              daysSelected,
+              disabled,
+              index: key,
+              isFocused: calendarNavigation.isFocused(
+                day
+              ),
+              key,
+              onClick: handleDayClicked,
+              outOfRange: isDayDisabled(
+                day.date
+              ),
+              range
+            }
+          ))
+        ),
+        (footerElement || time) && /* @__PURE__ */ import_react.default.createElement("div", { className: "date-picker-calendar-footer" }, time && /* @__PURE__ */ import_react.default.createElement(
+          import_TimePicker.default,
+          {
+            config: timePickerConfig,
+            currentTime,
+            disabled,
+            onTimeChange: handleTimeChange,
+            spritemap,
+            timezone,
+            use12Hours
+          }
+        ), !time && footerElement && import_react.default.Children.only(
+          footerElement({ spritemap })
+        ))
+      )
+    ), !useNative && expandedValue && displayKeyboardArrowsIndicator && /* @__PURE__ */ import_react.default.createElement(import_shared.ClayPortal, null, /* @__PURE__ */ import_react.default.createElement(
+      import_core.KeyboardArrowsIndicator,
+      {
+        anchorRef: menuElementRef,
+        direction: "all"
+      }
+    ))));
+  }
+);
+const RANGE_SEPARATOR = " - ";
+function isYearWithinYears(year, years) {
+  return years.start <= year && year <= years.end;
+}
+function fromStringToRange(value, dateFormat, referenceDate) {
+  const [startDateString, endDateString] = value.split(RANGE_SEPARATOR);
+  const startDate = (0, import_Helpers.parseDate)(startDateString, dateFormat, referenceDate);
+  return [
+    startDate,
+    endDateString ? (0, import_Helpers.parseDate)(endDateString, dateFormat, referenceDate) : startDate
+  ];
+}
+function hasDaysSelected({
+  checkRangeYears,
+  dateFormat,
+  is12Hours,
+  isTime,
+  value,
+  years
+}) {
+  const [startDate, endDate] = fromStringToRange(
+    value,
+    isTime ? `${dateFormat} ${is12Hours ? TIME_FORMAT_12H : TIME_FORMAT}` : dateFormat,
+    NEW_DATE
+  );
+  const isValidYear = checkRangeYears ? isYearWithinYears(startDate.getFullYear(), years) && isYearWithinYears(endDate.getFullYear(), years) : true;
+  if ((0, import_Helpers.isValid)(startDate) && (0, import_Helpers.isValid)(endDate) && isValidYear) {
+    return [startDate, endDate];
+  }
+}
+function fromRangeToString(range, dateFormat) {
+  const [startDate, endDate] = range;
+  return `${(0, import_Helpers.formatDate)(startDate, dateFormat)}${RANGE_SEPARATOR}${(0, import_Helpers.formatDate)(
+    endDate,
+    dateFormat
+  )}`;
+}
+DatePicker.displayName = "ClayDatePicker";
+var index_default = DatePicker;