@react-stately/calendar 3.0.0-alpha.1 → 3.0.0-alpha.4

package/dist/module.js

@@ -1,410 +1,411 @@
-import _babelRuntimeHelpersEsmObjectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-import { useEffect, useMemo, useRef, useState } from "react";
-import { useDateFormatter } from "@react-aria/i18n";
-import { useControlledState } from "@react-stately/utils";
-import { maxDate, minDate, startOfMonth, startOfWeek, startOfYear, toCalendarDate, GregorianCalendar, isSameDay, toCalendar, today } from "@internationalized/date";
-import _babelRuntimeHelpersEsmExtends from "@babel/runtime/helpers/esm/extends";
+import {DateFormatter as $keQhS$DateFormatter, toCalendar as $keQhS$toCalendar, toCalendarDate as $keQhS$toCalendarDate, today as $keQhS$today, GregorianCalendar as $keQhS$GregorianCalendar, isSameDay as $keQhS$isSameDay, startOfYear as $keQhS$startOfYear, startOfMonth as $keQhS$startOfMonth, startOfWeek as $keQhS$startOfWeek, maxDate as $keQhS$maxDate, minDate as $keQhS$minDate, isEqualDay as $keQhS$isEqualDay} from "@internationalized/date";
+import {useControlledState as $keQhS$useControlledState} from "@react-stately/utils";
+import {useMemo as $keQhS$useMemo, useState as $keQhS$useState, useRef as $keQhS$useRef} from "react";
 
-function $e9245e22e7d2e30e959129f8619bae$export$isInvalid(date, minValue, maxValue) {
-  return minValue != null && date.compare(minValue) < 0 || maxValue != null && date.compare(maxValue) > 0;
+function $parcel$export(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
 }
+var $77b8da46fac7b53e$exports = {};
 
-function $e9245e22e7d2e30e959129f8619bae$export$alignCenter(date, duration, locale, minValue, maxValue) {
-  let halfDuration = {};
 
-  for (let key in duration) {
-    halfDuration[key] = Math.floor(duration[key] / 2);
+var $131cf43a05231e1e$exports = {};
 
-    if (halfDuration[key] > 0 && duration[key] % 2 === 0) {
-      halfDuration[key]--;
-    }
-  }
+$parcel$export($131cf43a05231e1e$exports, "useCalendarState", () => $131cf43a05231e1e$export$6d095e787d2b5e1f);
 
-  let aligned = $e9245e22e7d2e30e959129f8619bae$export$alignStart(date, duration, locale).subtract(halfDuration);
-  return $e9245e22e7d2e30e959129f8619bae$export$constrainStart(date, aligned, duration, locale, minValue, maxValue);
+function $f62d864046160412$export$eac50920cf2fd59a(date, minValue, maxValue) {
+    return minValue != null && date.compare(minValue) < 0 || maxValue != null && date.compare(maxValue) > 0;
 }
-
-function $e9245e22e7d2e30e959129f8619bae$export$alignStart(date, duration, locale, minValue, maxValue) {
-  // align to the start of the largest unit
-  let aligned = date;
-
-  if (duration.years) {
-    aligned = startOfYear(date);
-  } else if (duration.months) {
-    aligned = startOfMonth(date);
-  } else if (duration.weeks) {
-    aligned = startOfWeek(date, locale);
-  }
-
-  return $e9245e22e7d2e30e959129f8619bae$export$constrainStart(date, aligned, duration, locale, minValue, maxValue);
+function $f62d864046160412$export$f4a51ff076cc9a09(date, duration, locale, minValue, maxValue) {
+    let halfDuration = {
+    };
+    for(let key in duration){
+        halfDuration[key] = Math.floor(duration[key] / 2);
+        if (halfDuration[key] > 0 && duration[key] % 2 === 0) halfDuration[key]--;
+    }
+    let aligned = $f62d864046160412$export$144a00ba6044eb9(date, duration, locale).subtract(halfDuration);
+    return $f62d864046160412$export$5bb865b12696a77d(date, aligned, duration, locale, minValue, maxValue);
 }
-
-function $e9245e22e7d2e30e959129f8619bae$export$alignEnd(date, duration, locale, minValue, maxValue) {
-  let d = _babelRuntimeHelpersEsmExtends({}, duration); // subtract 1 from the smallest unit
-
-
-  if (duration.days) {
-    d.days--;
-  } else if (duration.weeks) {
-    d.weeks--;
-  } else if (duration.months) {
-    d.months--;
-  } else if (duration.years) {
-    d.years--;
-  }
-
-  let aligned = $e9245e22e7d2e30e959129f8619bae$export$alignStart(date, duration, locale).subtract(d);
-  return $e9245e22e7d2e30e959129f8619bae$export$constrainStart(date, aligned, duration, locale, minValue, maxValue);
+function $f62d864046160412$export$144a00ba6044eb9(date, duration, locale, minValue, maxValue) {
+    // align to the start of the largest unit
+    let aligned = date;
+    if (duration.years) aligned = $keQhS$startOfYear(date);
+    else if (duration.months) aligned = $keQhS$startOfMonth(date);
+    else if (duration.weeks) aligned = $keQhS$startOfWeek(date, locale);
+    return $f62d864046160412$export$5bb865b12696a77d(date, aligned, duration, locale, minValue, maxValue);
 }
-
-function $e9245e22e7d2e30e959129f8619bae$export$constrainStart(date, aligned, duration, locale, minValue, maxValue) {
-  if (minValue && date.compare(minValue) >= 0) {
-    aligned = maxDate(aligned, $e9245e22e7d2e30e959129f8619bae$export$alignStart(toCalendarDate(minValue), duration, locale));
-  }
-
-  if (maxValue && date.compare(maxValue) <= 0) {
-    aligned = minDate(aligned, $e9245e22e7d2e30e959129f8619bae$export$alignEnd(toCalendarDate(maxValue), duration, locale));
-  }
-
-  return aligned;
+function $f62d864046160412$export$530edbfc915b2b04(date, duration, locale, minValue, maxValue) {
+    let d = {
+        ...duration
+    };
+    // subtract 1 from the smallest unit
+    if (duration.days) d.days--;
+    else if (duration.weeks) d.weeks--;
+    else if (duration.months) d.months--;
+    else if (duration.years) d.years--;
+    let aligned = $f62d864046160412$export$144a00ba6044eb9(date, duration, locale).subtract(d);
+    return $f62d864046160412$export$5bb865b12696a77d(date, aligned, duration, locale, minValue, maxValue);
 }
-
-function $e9245e22e7d2e30e959129f8619bae$export$constrainValue(date, minValue, maxValue) {
-  if (minValue) {
-    date = maxDate(date, toCalendarDate(minValue));
-  }
-
-  if (maxValue) {
-    date = minDate(date, toCalendarDate(maxValue));
-  }
-
-  return date;
+function $f62d864046160412$export$5bb865b12696a77d(date, aligned, duration, locale, minValue, maxValue) {
+    if (minValue && date.compare(minValue) >= 0) aligned = $keQhS$maxDate(aligned, $f62d864046160412$export$144a00ba6044eb9($keQhS$toCalendarDate(minValue), duration, locale));
+    if (maxValue && date.compare(maxValue) <= 0) aligned = $keQhS$minDate(aligned, $f62d864046160412$export$530edbfc915b2b04($keQhS$toCalendarDate(maxValue), duration, locale));
+    return aligned;
+}
+function $f62d864046160412$export$4f5203c0d889109e(date, minValue, maxValue) {
+    if (minValue) date = $keQhS$maxDate(date, $keQhS$toCalendarDate(minValue));
+    if (maxValue) date = $keQhS$minDate(date, $keQhS$toCalendarDate(maxValue));
+    return date;
 }
 
-export function useCalendarState(props) {
-  let defaultFormatter = useDateFormatter();
-  let resolvedOptions = useMemo(() => defaultFormatter.resolvedOptions(), [defaultFormatter]);
-  let {
-    locale,
-    createCalendar,
-    timeZone = resolvedOptions.timeZone,
-    visibleDuration = {
-      months: 1
-    },
-    minValue,
-    maxValue,
-    selectionAlignment
-  } = props;
-  let calendar = useMemo(() => createCalendar(resolvedOptions.calendar), [createCalendar, resolvedOptions.calendar]);
-  let [value, setControlledValue] = useControlledState(props.value, props.defaultValue, props.onChange);
-  let calendarDateValue = useMemo(() => value ? toCalendar(toCalendarDate(value), calendar) : null, [value, calendar]);
-  let defaultDate = useMemo(() => calendarDateValue || $e9245e22e7d2e30e959129f8619bae$export$constrainValue(toCalendar(today(timeZone), calendar), minValue, maxValue), [calendarDateValue, timeZone, calendar, minValue, maxValue]);
-  let [startDate, setStartDate] = useState(() => {
-    switch (selectionAlignment) {
-      case 'start':
-        return $e9245e22e7d2e30e959129f8619bae$export$alignStart(defaultDate, visibleDuration, locale, minValue, maxValue);
 
-      case 'end':
-        return $e9245e22e7d2e30e959129f8619bae$export$alignEnd(defaultDate, visibleDuration, locale, minValue, maxValue);
 
-      case 'center':
-      default:
-        return $e9245e22e7d2e30e959129f8619bae$export$alignCenter(defaultDate, visibleDuration, locale, minValue, maxValue);
-    }
-  });
-  let [focusedDate, setFocusedDate] = useState(defaultDate);
-  let [isFocused, setFocused] = useState(props.autoFocus || false);
-  let endDate = useMemo(() => startDate.add(visibleDuration).subtract({
-    days: 1
-  }), [startDate, visibleDuration]); // Reset focused date and visible range when calendar changes.
 
-  let lastCalendarIdentifier = useRef(calendar.identifier);
-  useEffect(() => {
+
+function $131cf43a05231e1e$export$6d095e787d2b5e1f(props) {
+    let defaultFormatter = $keQhS$useMemo(()=>new $keQhS$DateFormatter(props.locale)
+    , [
+        props.locale
+    ]);
+    let resolvedOptions = $keQhS$useMemo(()=>defaultFormatter.resolvedOptions()
+    , [
+        defaultFormatter
+    ]);
+    let { locale: locale , createCalendar: createCalendar , visibleDuration: visibleDuration = {
+        months: 1
+    } , minValue: minValue , maxValue: maxValue , selectionAlignment: selectionAlignment  } = props;
+    let calendar = $keQhS$useMemo(()=>createCalendar(resolvedOptions.calendar)
+    , [
+        createCalendar,
+        resolvedOptions.calendar
+    ]);
+    let [value, setControlledValue] = $keQhS$useControlledState(props.value, props.defaultValue, props.onChange);
+    let calendarDateValue = $keQhS$useMemo(()=>value ? $keQhS$toCalendar($keQhS$toCalendarDate(value), calendar) : null
+    , [
+        value,
+        calendar
+    ]);
+    let timeZone = $keQhS$useMemo(()=>value && 'timeZone' in value ? value.timeZone : resolvedOptions.timeZone
+    , [
+        value,
+        resolvedOptions.timeZone
+    ]);
+    let focusedCalendarDate = $keQhS$useMemo(()=>props.focusedValue ? $f62d864046160412$export$4f5203c0d889109e($keQhS$toCalendar($keQhS$toCalendarDate(props.focusedValue), calendar), minValue, maxValue) : undefined
+    , [
+        props.focusedValue,
+        calendar,
+        minValue,
+        maxValue
+    ]);
+    let defaultFocusedCalendarDate = $keQhS$useMemo(()=>$f62d864046160412$export$4f5203c0d889109e(props.defaultFocusedValue ? $keQhS$toCalendar($keQhS$toCalendarDate(props.defaultFocusedValue), calendar) : calendarDateValue || $keQhS$toCalendar($keQhS$today(timeZone), calendar), minValue, maxValue)
+    , [
+        props.defaultFocusedValue,
+        calendarDateValue,
+        timeZone,
+        calendar,
+        minValue,
+        maxValue
+    ]);
+    let [focusedDate, setFocusedDate] = $keQhS$useControlledState(focusedCalendarDate, defaultFocusedCalendarDate, props.onFocusChange);
+    let [startDate, setStartDate] = $keQhS$useState(()=>{
+        switch(selectionAlignment){
+            case 'start':
+                return $f62d864046160412$export$144a00ba6044eb9(focusedDate, visibleDuration, locale, minValue, maxValue);
+            case 'end':
+                return $f62d864046160412$export$530edbfc915b2b04(focusedDate, visibleDuration, locale, minValue, maxValue);
+            case 'center':
+            default:
+                return $f62d864046160412$export$f4a51ff076cc9a09(focusedDate, visibleDuration, locale, minValue, maxValue);
+        }
+    });
+    let [isFocused, setFocused] = $keQhS$useState(props.autoFocus || false);
+    let endDate = $keQhS$useMemo(()=>startDate.add(visibleDuration).subtract({
+            days: 1
+        })
+    , [
+        startDate,
+        visibleDuration
+    ]);
+    // Reset focused date and visible range when calendar changes.
+    let lastCalendarIdentifier = $keQhS$useRef(calendar.identifier);
     if (calendar.identifier !== lastCalendarIdentifier.current) {
-      let newFocusedDate = toCalendar(focusedDate, calendar);
-      setStartDate($e9245e22e7d2e30e959129f8619bae$export$alignCenter(newFocusedDate, visibleDuration, locale, minValue, maxValue));
-      setFocusedDate(newFocusedDate);
-      lastCalendarIdentifier.current = calendar.identifier;
+        let newFocusedDate = $keQhS$toCalendar(focusedDate, calendar);
+        setStartDate($f62d864046160412$export$f4a51ff076cc9a09(newFocusedDate, visibleDuration, locale, minValue, maxValue));
+        setFocusedDate(newFocusedDate);
+        lastCalendarIdentifier.current = calendar.identifier;
     }
-  }, [calendar, focusedDate, visibleDuration, locale, minValue, maxValue]); // Sets focus to a specific cell date
-
-  function focusCell(date) {
-    // date = constrain(focusedDate, date, visibleDuration, locale, minValue, maxValue);
-    date = $e9245e22e7d2e30e959129f8619bae$export$constrainValue(date, minValue, maxValue);
-    let next = startDate.add(visibleDuration);
-
-    if (date.compare(startDate) < 0) {
-      setStartDate($e9245e22e7d2e30e959129f8619bae$export$alignEnd(date, visibleDuration, locale, minValue, maxValue));
-    } else if (date.compare(next) >= 0) {
-      setStartDate($e9245e22e7d2e30e959129f8619bae$export$alignStart(date, visibleDuration, locale, minValue, maxValue));
+    if ($f62d864046160412$export$eac50920cf2fd59a(focusedDate, minValue, maxValue)) // If the focused date was moved to an invalid value, it can't be focused, so constrain it.
+    setFocusedDate($f62d864046160412$export$4f5203c0d889109e(focusedDate, minValue, maxValue));
+    else if (focusedDate.compare(startDate) < 0) setStartDate($f62d864046160412$export$530edbfc915b2b04(focusedDate, visibleDuration, locale, minValue, maxValue));
+    else if (focusedDate.compare(startDate.add(visibleDuration)) >= 0) setStartDate($f62d864046160412$export$144a00ba6044eb9(focusedDate, visibleDuration, locale, minValue, maxValue));
+    // Sets focus to a specific cell date
+    function focusCell(date) {
+        date = $f62d864046160412$export$4f5203c0d889109e(date, minValue, maxValue);
+        setFocusedDate(date);
     }
-
-    setFocusedDate(date);
-  }
-
-  function setValue(newValue) {
-    if (!props.isDisabled && !props.isReadOnly) {
-      // The display calendar should not have any effect on the emitted value.
-      // Emit dates in the same calendar as the original value, if any, otherwise gregorian.
-      newValue = toCalendar(newValue, (value == null ? void 0 : value.calendar) || new GregorianCalendar()); // Preserve time if the input value had one.
-
-      if (value && 'hour' in value) {
-        setControlledValue(value.set(newValue));
-      } else {
-        setControlledValue(newValue);
-      }
+    function setValue(newValue) {
+        if (!props.isDisabled && !props.isReadOnly) {
+            // The display calendar should not have any effect on the emitted value.
+            // Emit dates in the same calendar as the original value, if any, otherwise gregorian.
+            newValue = $keQhS$toCalendar(newValue, (value === null || value === void 0 ? void 0 : value.calendar) || new $keQhS$GregorianCalendar());
+            // Preserve time if the input value had one.
+            if (value && 'hour' in value) setControlledValue(value.set(newValue));
+            else setControlledValue(newValue);
+        }
     }
-  }
-
-  return {
-    isDisabled: props.isDisabled,
-    isReadOnly: props.isReadOnly,
-    value: calendarDateValue,
-    setValue,
-    visibleRange: {
-      start: startDate,
-      end: endDate
-    },
-    focusedDate,
-    timeZone,
-
-    setFocusedDate(date) {
-      setFocusedDate(date);
-      setFocused(true);
-    },
-
-    focusNextDay() {
-      focusCell(focusedDate.add({
-        days: 1
-      }));
-    },
-
-    focusPreviousDay() {
-      focusCell(focusedDate.subtract({
-        days: 1
-      }));
-    },
-
-    focusNextRow() {
-      if (visibleDuration.days) {
-        this.focusNextPage();
-      } else if (visibleDuration.weeks || visibleDuration.months || visibleDuration.years) {
-        focusCell(focusedDate.add({
-          weeks: 1
-        }));
-      }
-    },
-
-    focusPreviousRow() {
-      if (visibleDuration.days) {
-        this.focusPreviousPage();
-      } else if (visibleDuration.weeks || visibleDuration.months || visibleDuration.years) {
-        focusCell(focusedDate.subtract({
-          weeks: 1
-        }));
-      }
-    },
-
-    focusNextPage() {
-      let start = startDate.add(visibleDuration);
-      setStartDate($e9245e22e7d2e30e959129f8619bae$export$constrainStart(focusedDate, start, visibleDuration, locale, minValue, maxValue));
-      setFocusedDate($e9245e22e7d2e30e959129f8619bae$export$constrainValue(focusedDate.add(visibleDuration), minValue, maxValue));
-    },
-
-    focusPreviousPage() {
-      let start = startDate.subtract(visibleDuration);
-      setStartDate($e9245e22e7d2e30e959129f8619bae$export$constrainStart(focusedDate, start, visibleDuration, locale, minValue, maxValue));
-      setFocusedDate($e9245e22e7d2e30e959129f8619bae$export$constrainValue(focusedDate.subtract(visibleDuration), minValue, maxValue));
-    },
-
-    focusPageStart() {
-      focusCell(startDate);
-    },
-
-    focusPageEnd() {
-      focusCell(endDate);
-    },
-
-    focusNextSection() {
-      if (visibleDuration.days) {
-        this.focusNextPage();
-      } else if (visibleDuration.weeks) {
-        focusCell(focusedDate.add({
-          months: 1
-        }));
-      } else if (visibleDuration.months || visibleDuration.years) {
-        focusCell(focusedDate.add({
-          years: 1
-        }));
-      }
-    },
-
-    focusPreviousSection() {
-      if (visibleDuration.days) {
-        this.focusPreviousPage();
-      } else if (visibleDuration.weeks) {
-        focusCell(focusedDate.subtract({
-          months: 1
-        }));
-      } else if (visibleDuration.months || visibleDuration.years) {
-        focusCell(focusedDate.subtract({
-          years: 1
-        }));
-      }
-    },
-
-    selectFocusedDate() {
-      setValue(focusedDate);
-    },
+    return {
+        isDisabled: props.isDisabled,
+        isReadOnly: props.isReadOnly,
+        value: calendarDateValue,
+        setValue: setValue,
+        visibleRange: {
+            start: startDate,
+            end: endDate
+        },
+        focusedDate: focusedDate,
+        timeZone: timeZone,
+        setFocusedDate (date) {
+            focusCell(date);
+            setFocused(true);
+        },
+        focusNextDay () {
+            focusCell(focusedDate.add({
+                days: 1
+            }));
+        },
+        focusPreviousDay () {
+            focusCell(focusedDate.subtract({
+                days: 1
+            }));
+        },
+        focusNextRow () {
+            if (visibleDuration.days) this.focusNextPage();
+            else if (visibleDuration.weeks || visibleDuration.months || visibleDuration.years) focusCell(focusedDate.add({
+                weeks: 1
+            }));
+        },
+        focusPreviousRow () {
+            if (visibleDuration.days) this.focusPreviousPage();
+            else if (visibleDuration.weeks || visibleDuration.months || visibleDuration.years) focusCell(focusedDate.subtract({
+                weeks: 1
+            }));
+        },
+        focusNextPage () {
+            let start = startDate.add(visibleDuration);
+            setFocusedDate($f62d864046160412$export$4f5203c0d889109e(focusedDate.add(visibleDuration), minValue, maxValue));
+            setStartDate($f62d864046160412$export$5bb865b12696a77d(focusedDate, start, visibleDuration, locale, minValue, maxValue));
+        },
+        focusPreviousPage () {
+            let start = startDate.subtract(visibleDuration);
+            setFocusedDate($f62d864046160412$export$4f5203c0d889109e(focusedDate.subtract(visibleDuration), minValue, maxValue));
+            setStartDate($f62d864046160412$export$5bb865b12696a77d(focusedDate, start, visibleDuration, locale, minValue, maxValue));
+        },
+        focusPageStart () {
+            focusCell(startDate);
+        },
+        focusPageEnd () {
+            focusCell(endDate);
+        },
+        focusNextSection () {
+            if (visibleDuration.days) this.focusNextPage();
+            else if (visibleDuration.weeks) focusCell(focusedDate.add({
+                months: 1
+            }));
+            else if (visibleDuration.months || visibleDuration.years) focusCell(focusedDate.add({
+                years: 1
+            }));
+        },
+        focusPreviousSection () {
+            if (visibleDuration.days) this.focusPreviousPage();
+            else if (visibleDuration.weeks) focusCell(focusedDate.subtract({
+                months: 1
+            }));
+            else if (visibleDuration.months || visibleDuration.years) focusCell(focusedDate.subtract({
+                years: 1
+            }));
+        },
+        selectFocusedDate () {
+            setValue(focusedDate);
+        },
+        selectDate (date) {
+            setValue(date);
+        },
+        isFocused: isFocused,
+        setFocused: setFocused,
+        isInvalid (date) {
+            return $f62d864046160412$export$eac50920cf2fd59a(date, minValue, maxValue);
+        },
+        isSelected (date) {
+            return calendarDateValue != null && $keQhS$isSameDay(date, calendarDateValue) && !this.isCellDisabled(date) && !this.isCellUnavailable(date);
+        },
+        isCellFocused (date) {
+            return isFocused && focusedDate && $keQhS$isSameDay(date, focusedDate);
+        },
+        isCellDisabled (date) {
+            return props.isDisabled || date.compare(startDate) < 0 || date.compare(endDate) > 0 || this.isInvalid(date, minValue, maxValue);
+        },
+        isCellUnavailable (date) {
+            return props.isDateUnavailable && props.isDateUnavailable(date);
+        },
+        isPreviousVisibleRangeInvalid () {
+            return this.isInvalid(startDate.subtract({
+                days: 1
+            }), minValue, maxValue);
+        },
+        isNextVisibleRangeInvalid () {
+            return this.isInvalid(endDate.add({
+                days: 1
+            }), minValue, maxValue);
+        }
+    };
+}
 
-    selectDate(date) {
-      setValue(date);
-    },
 
-    isFocused,
-    setFocused,
+var $9a36b6ba2fb1a7c5$exports = {};
 
-    isInvalid(date) {
-      return $e9245e22e7d2e30e959129f8619bae$export$isInvalid(date, minValue, maxValue);
-    },
+$parcel$export($9a36b6ba2fb1a7c5$exports, "useRangeCalendarState", () => $9a36b6ba2fb1a7c5$export$9a987164d97ecc90);
 
-    isSelected(date) {
-      return calendarDateValue != null && isSameDay(date, calendarDateValue);
-    },
 
-    isCellFocused(date) {
-      return isFocused && focusedDate && isSameDay(date, focusedDate);
-    },
 
-    isCellDisabled(date) {
-      return props.isDisabled || date.compare(startDate) < 0 || date.compare(endDate) > 0 || $e9245e22e7d2e30e959129f8619bae$export$isInvalid(date, minValue, maxValue);
-    },
 
-    isPreviousVisibleRangeInvalid() {
-      return $e9245e22e7d2e30e959129f8619bae$export$isInvalid(startDate.subtract({
-        days: 1
-      }), minValue, maxValue);
-    },
 
-    isNextVisibleRangeInvalid() {
-      return $e9245e22e7d2e30e959129f8619bae$export$isInvalid(endDate.add({
-        days: 1
-      }), minValue, maxValue);
+function $9a36b6ba2fb1a7c5$export$9a987164d97ecc90(props) {
+    let { value: valueProp , defaultValue: defaultValue , onChange: onChange , createCalendar: createCalendar , locale: locale , visibleDuration: visibleDuration = {
+        months: 1
+    } , minValue: minValue , maxValue: maxValue , ...calendarProps } = props;
+    let [value, setValue] = $keQhS$useControlledState(valueProp, defaultValue || null, onChange);
+    let [anchorDate, setAnchorDateState] = $keQhS$useState(null);
+    let alignment = 'center';
+    if (value && value.start && value.end) {
+        let start = $f62d864046160412$export$f4a51ff076cc9a09($keQhS$toCalendarDate(value.start), visibleDuration, locale, minValue, maxValue);
+        let end = start.add(visibleDuration).subtract({
+            days: 1
+        });
+        if (value.end.compare(end) > 0) alignment = 'start';
     }
-
-  };
-}
-export function useRangeCalendarState(props) {
-  let {
-    value: valueProp,
-    defaultValue,
-    onChange,
-    createCalendar,
-    locale,
-    visibleDuration = {
-      months: 1
-    },
-    minValue,
-    maxValue
-  } = props,
-      calendarProps = _babelRuntimeHelpersEsmObjectWithoutPropertiesLoose(props, ["value", "defaultValue", "onChange", "createCalendar", "locale", "visibleDuration", "minValue", "maxValue"]);
-
-  let [value, setValue] = useControlledState(valueProp, defaultValue, onChange);
-  let [anchorDate, setAnchorDate] = useState(null);
-  let alignment = 'center';
-
-  if (value && value.start && value.end) {
-    let start = $e9245e22e7d2e30e959129f8619bae$export$alignCenter(toCalendarDate(value.start), visibleDuration, locale, minValue, maxValue);
-    let end = start.add(visibleDuration).subtract({
-      days: 1
+    // Available range must be stored in a ref so we have access to the updated version immediately in `isInvalid`.
+    let availableRangeRef = $keQhS$useRef(null);
+    let [availableRange, setAvailableRange] = $keQhS$useState(null);
+    let min = $keQhS$useMemo(()=>{
+        return $keQhS$maxDate(minValue, availableRange === null || availableRange === void 0 ? void 0 : availableRange.start);
+    }, [
+        minValue,
+        availableRange
+    ]);
+    let max = $keQhS$useMemo(()=>{
+        return $keQhS$minDate(maxValue, availableRange === null || availableRange === void 0 ? void 0 : availableRange.end);
+    }, [
+        maxValue,
+        availableRange
+    ]);
+    let calendar = $131cf43a05231e1e$export$6d095e787d2b5e1f({
+        ...calendarProps,
+        value: value && value.start,
+        createCalendar: createCalendar,
+        locale: locale,
+        visibleDuration: visibleDuration,
+        minValue: min,
+        maxValue: max,
+        selectionAlignment: alignment
     });
-
-    if (value.end.compare(end) > 0) {
-      alignment = 'start';
-    }
-  }
-
-  let calendar = useCalendarState(_babelRuntimeHelpersEsmExtends({}, calendarProps, {
-    value: value && value.start,
-    createCalendar,
-    locale,
-    visibleDuration,
-    minValue,
-    maxValue,
-    selectionAlignment: alignment
-  }));
-  let highlightedRange = anchorDate ? $b99e30b96646887f54a48af37fe3b03$var$makeRange(anchorDate, calendar.focusedDate) : value && $b99e30b96646887f54a48af37fe3b03$var$makeRange(value.start, value.end);
-
-  let selectDate = date => {
-    if (props.isReadOnly) {
-      return;
-    }
-
-    if (!anchorDate) {
-      setAnchorDate(date);
-    } else {
-      let range = $b99e30b96646887f54a48af37fe3b03$var$makeRange(anchorDate, date);
-      setValue({
-        start: $b99e30b96646887f54a48af37fe3b03$var$convertValue(range.start, value == null ? void 0 : value.start),
-        end: $b99e30b96646887f54a48af37fe3b03$var$convertValue(range.end, value == null ? void 0 : value.end)
-      });
-      setAnchorDate(null);
+    let updateAvailableRange = (date)=>{
+        if (date && props.isDateUnavailable && !props.allowsNonContiguousRanges) {
+            availableRangeRef.current = {
+                start: $9a36b6ba2fb1a7c5$var$nextUnavailableDate(date, calendar, -1),
+                end: $9a36b6ba2fb1a7c5$var$nextUnavailableDate(date, calendar, 1)
+            };
+            setAvailableRange(availableRangeRef.current);
+        } else {
+            availableRangeRef.current = null;
+            setAvailableRange(null);
+        }
+    };
+    // If the visible range changes, we need to update the available range.
+    let lastVisibleRange = $keQhS$useRef(calendar.visibleRange);
+    if (!$keQhS$isEqualDay(calendar.visibleRange.start, lastVisibleRange.current.start) || !$keQhS$isEqualDay(calendar.visibleRange.end, lastVisibleRange.current.end)) {
+        updateAvailableRange(anchorDate);
+        lastVisibleRange.current = calendar.visibleRange;
     }
-  };
-
-  let [isDragging, setDragging] = useState(false);
-  return _babelRuntimeHelpersEsmExtends({}, calendar, {
-    value,
-    setValue,
-    anchorDate,
-    setAnchorDate,
-    highlightedRange,
-
-    selectFocusedDate() {
-      selectDate(calendar.focusedDate);
-    },
-
-    selectDate,
-
-    highlightDate(date) {
-      if (anchorDate) {
-        calendar.setFocusedDate(date);
-      }
-    },
-
-    isSelected(date) {
-      return highlightedRange && date.compare(highlightedRange.start) >= 0 && date.compare(highlightedRange.end) <= 0;
-    },
-
-    isDragging,
-    setDragging
-  });
+    let setAnchorDate = (date)=>{
+        if (date) {
+            setAnchorDateState(date);
+            updateAvailableRange(date);
+        } else {
+            setAnchorDateState(null);
+            updateAvailableRange(null);
+        }
+    };
+    let highlightedRange = anchorDate ? $9a36b6ba2fb1a7c5$var$makeRange(anchorDate, calendar.focusedDate) : value && $9a36b6ba2fb1a7c5$var$makeRange(value.start, value.end);
+    let selectDate = (date)=>{
+        if (props.isReadOnly) return;
+        if (!anchorDate) setAnchorDate(date);
+        else {
+            let range = $9a36b6ba2fb1a7c5$var$makeRange(anchorDate, date);
+            setValue({
+                start: $9a36b6ba2fb1a7c5$var$convertValue(range.start, value === null || value === void 0 ? void 0 : value.start),
+                end: $9a36b6ba2fb1a7c5$var$convertValue(range.end, value === null || value === void 0 ? void 0 : value.end)
+            });
+            setAnchorDate(null);
+        }
+    };
+    let [isDragging, setDragging] = $keQhS$useState(false);
+    return {
+        ...calendar,
+        value: value,
+        setValue: setValue,
+        anchorDate: anchorDate,
+        setAnchorDate: setAnchorDate,
+        highlightedRange: highlightedRange,
+        selectFocusedDate () {
+            selectDate(calendar.focusedDate);
+        },
+        selectDate: selectDate,
+        highlightDate (date) {
+            if (anchorDate) calendar.setFocusedDate(date);
+        },
+        isSelected (date) {
+            return highlightedRange && date.compare(highlightedRange.start) >= 0 && date.compare(highlightedRange.end) <= 0 && !calendar.isCellDisabled(date) && !calendar.isCellUnavailable(date);
+        },
+        isInvalid (date) {
+            var ref, ref1;
+            return calendar.isInvalid(date) || $f62d864046160412$export$eac50920cf2fd59a(date, (ref = availableRangeRef.current) === null || ref === void 0 ? void 0 : ref.start, (ref1 = availableRangeRef.current) === null || ref1 === void 0 ? void 0 : ref1.end);
+        },
+        isDragging: isDragging,
+        setDragging: setDragging
+    };
 }
-
-function $b99e30b96646887f54a48af37fe3b03$var$makeRange(start, end) {
-  if (!start || !end) {
+function $9a36b6ba2fb1a7c5$var$makeRange(start, end) {
+    if (!start || !end) return null;
+    if (end.compare(start) < 0) [start, end] = [
+        end,
+        start
+    ];
+    return {
+        start: $keQhS$toCalendarDate(start),
+        end: $keQhS$toCalendarDate(end)
+    };
+}
+function $9a36b6ba2fb1a7c5$var$convertValue(newValue, oldValue) {
+    // The display calendar should not have any effect on the emitted value.
+    // Emit dates in the same calendar as the original value, if any, otherwise gregorian.
+    newValue = $keQhS$toCalendar(newValue, (oldValue === null || oldValue === void 0 ? void 0 : oldValue.calendar) || new $keQhS$GregorianCalendar());
+    // Preserve time if the input value had one.
+    if (oldValue && 'hour' in oldValue) return oldValue.set(newValue);
+    return newValue;
+}
+function $9a36b6ba2fb1a7c5$var$nextUnavailableDate(anchorDate, state, dir) {
+    let nextDate = anchorDate.add({
+        days: dir
+    });
+    while((dir < 0 ? nextDate.compare(state.visibleRange.start) >= 0 : nextDate.compare(state.visibleRange.end) <= 0) && !state.isCellUnavailable(nextDate))nextDate = nextDate.add({
+        days: dir
+    });
+    if (state.isCellUnavailable(nextDate)) return nextDate.add({
+        days: -dir
+    });
     return null;
-  }
-
-  if (end.compare(start) < 0) {
-    [start, end] = [end, start];
-  }
-
-  return {
-    start: toCalendarDate(start),
-    end: toCalendarDate(end)
-  };
 }
 
-function $b99e30b96646887f54a48af37fe3b03$var$convertValue(newValue, oldValue) {
-  // The display calendar should not have any effect on the emitted value.
-  // Emit dates in the same calendar as the original value, if any, otherwise gregorian.
-  newValue = toCalendar(newValue, (oldValue == null ? void 0 : oldValue.calendar) || new GregorianCalendar()); // Preserve time if the input value had one.
 
-  if (oldValue && 'hour' in oldValue) {
-    return oldValue.set(newValue);
-  }
 
-  return newValue;
-}
+
+export {$131cf43a05231e1e$export$6d095e787d2b5e1f as useCalendarState, $9a36b6ba2fb1a7c5$export$9a987164d97ecc90 as useRangeCalendarState};
 //# sourceMappingURL=module.js.map