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

package/dist/main.js

@@ -1,444 +1,429 @@
-var _babelRuntimeHelpersObjectWithoutPropertiesLoose = $parcel$interopDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+var $hEzMm$internationalizeddate = require("@internationalized/date");
+var $hEzMm$reactstatelyutils = require("@react-stately/utils");
+var $hEzMm$react = require("react");
 
-var {
-  useEffect,
-  useMemo,
-  useRef,
-  useState
-} = require("react");
-
-var {
-  useDateFormatter
-} = require("@react-aria/i18n");
-
-var {
-  useControlledState
-} = require("@react-stately/utils");
-
-var {
-  maxDate,
-  minDate,
-  startOfMonth,
-  startOfWeek,
-  startOfYear,
-  toCalendarDate,
-  GregorianCalendar,
-  isSameDay,
-  toCalendar,
-  today
-} = require("@internationalized/date");
+function $parcel$exportWildcard(dest, source) {
+  Object.keys(source).forEach(function(key) {
+    if (key === 'default' || key === '__esModule' || dest.hasOwnProperty(key)) {
+      return;
+    }
 
-var _babelRuntimeHelpersExtends = $parcel$interopDefault(require("@babel/runtime/helpers/extends"));
+    Object.defineProperty(dest, key, {
+      enumerable: true,
+      get: function get() {
+        return source[key];
+      }
+    });
+  });
 
-function $parcel$interopDefault(a) {
-  return a && a.__esModule ? a.default : a;
+  return dest;
 }
-
-function $cb3c71934523b9f11dab70388c912b98$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 $7a549489c00e7fe0$exports = {};
 
-function $cb3c71934523b9f11dab70388c912b98$export$alignCenter(date, duration, locale, minValue, maxValue) {
-  let halfDuration = {};
 
-  for (let key in duration) {
-    halfDuration[key] = Math.floor(duration[key] / 2);
+var $6adad0c8536fc209$exports = {};
 
-    if (halfDuration[key] > 0 && duration[key] % 2 === 0) {
-      halfDuration[key]--;
-    }
-  }
+$parcel$export($6adad0c8536fc209$exports, "useCalendarState", () => $6adad0c8536fc209$export$6d095e787d2b5e1f);
 
-  let aligned = $cb3c71934523b9f11dab70388c912b98$export$alignStart(date, duration, locale).subtract(halfDuration);
-  return $cb3c71934523b9f11dab70388c912b98$export$constrainStart(date, aligned, duration, locale, minValue, maxValue);
+function $4301262d71f567b9$export$eac50920cf2fd59a(date, minValue, maxValue) {
+    return minValue != null && date.compare(minValue) < 0 || maxValue != null && date.compare(maxValue) > 0;
 }
-
-function $cb3c71934523b9f11dab70388c912b98$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 $cb3c71934523b9f11dab70388c912b98$export$constrainStart(date, aligned, duration, locale, minValue, maxValue);
+function $4301262d71f567b9$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 = $4301262d71f567b9$export$144a00ba6044eb9(date, duration, locale).subtract(halfDuration);
+    return $4301262d71f567b9$export$5bb865b12696a77d(date, aligned, duration, locale, minValue, maxValue);
 }
-
-function $cb3c71934523b9f11dab70388c912b98$export$alignEnd(date, duration, locale, minValue, maxValue) {
-  let d = _babelRuntimeHelpersExtends({}, 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 = $cb3c71934523b9f11dab70388c912b98$export$alignStart(date, duration, locale).subtract(d);
-  return $cb3c71934523b9f11dab70388c912b98$export$constrainStart(date, aligned, duration, locale, minValue, maxValue);
+function $4301262d71f567b9$export$144a00ba6044eb9(date, duration, locale, minValue, maxValue) {
+    // align to the start of the largest unit
+    let aligned = date;
+    if (duration.years) aligned = $hEzMm$internationalizeddate.startOfYear(date);
+    else if (duration.months) aligned = $hEzMm$internationalizeddate.startOfMonth(date);
+    else if (duration.weeks) aligned = $hEzMm$internationalizeddate.startOfWeek(date, locale);
+    return $4301262d71f567b9$export$5bb865b12696a77d(date, aligned, duration, locale, minValue, maxValue);
 }
-
-function $cb3c71934523b9f11dab70388c912b98$export$constrainStart(date, aligned, duration, locale, minValue, maxValue) {
-  if (minValue && date.compare(minValue) >= 0) {
-    aligned = maxDate(aligned, $cb3c71934523b9f11dab70388c912b98$export$alignStart(toCalendarDate(minValue), duration, locale));
-  }
-
-  if (maxValue && date.compare(maxValue) <= 0) {
-    aligned = minDate(aligned, $cb3c71934523b9f11dab70388c912b98$export$alignEnd(toCalendarDate(maxValue), duration, locale));
-  }
-
-  return aligned;
+function $4301262d71f567b9$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 = $4301262d71f567b9$export$144a00ba6044eb9(date, duration, locale).subtract(d);
+    return $4301262d71f567b9$export$5bb865b12696a77d(date, aligned, duration, locale, minValue, maxValue);
 }
-
-function $cb3c71934523b9f11dab70388c912b98$export$constrainValue(date, minValue, maxValue) {
-  if (minValue) {
-    date = maxDate(date, toCalendarDate(minValue));
-  }
-
-  if (maxValue) {
-    date = minDate(date, toCalendarDate(maxValue));
-  }
-
-  return date;
+function $4301262d71f567b9$export$5bb865b12696a77d(date, aligned, duration, locale, minValue, maxValue) {
+    if (minValue && date.compare(minValue) >= 0) aligned = $hEzMm$internationalizeddate.maxDate(aligned, $4301262d71f567b9$export$144a00ba6044eb9($hEzMm$internationalizeddate.toCalendarDate(minValue), duration, locale));
+    if (maxValue && date.compare(maxValue) <= 0) aligned = $hEzMm$internationalizeddate.minDate(aligned, $4301262d71f567b9$export$530edbfc915b2b04($hEzMm$internationalizeddate.toCalendarDate(maxValue), duration, locale));
+    return aligned;
+}
+function $4301262d71f567b9$export$4f5203c0d889109e(date, minValue, maxValue) {
+    if (minValue) date = $hEzMm$internationalizeddate.maxDate(date, $hEzMm$internationalizeddate.toCalendarDate(minValue));
+    if (maxValue) date = $hEzMm$internationalizeddate.minDate(date, $hEzMm$internationalizeddate.toCalendarDate(maxValue));
+    return date;
 }
 
-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 || $cb3c71934523b9f11dab70388c912b98$export$constrainValue(toCalendar(today(timeZone), calendar), minValue, maxValue), [calendarDateValue, timeZone, calendar, minValue, maxValue]);
-  let [startDate, setStartDate] = useState(() => {
-    switch (selectionAlignment) {
-      case 'start':
-        return $cb3c71934523b9f11dab70388c912b98$export$alignStart(defaultDate, visibleDuration, locale, minValue, maxValue);
 
-      case 'end':
-        return $cb3c71934523b9f11dab70388c912b98$export$alignEnd(defaultDate, visibleDuration, locale, minValue, maxValue);
 
-      case 'center':
-      default:
-        return $cb3c71934523b9f11dab70388c912b98$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 $6adad0c8536fc209$export$6d095e787d2b5e1f(props) {
+    let defaultFormatter = $hEzMm$react.useMemo(()=>new $hEzMm$internationalizeddate.DateFormatter(props.locale)
+    , [
+        props.locale
+    ]);
+    let resolvedOptions = $hEzMm$react.useMemo(()=>defaultFormatter.resolvedOptions()
+    , [
+        defaultFormatter
+    ]);
+    let { locale: locale , createCalendar: createCalendar , visibleDuration: visibleDuration = {
+        months: 1
+    } , minValue: minValue , maxValue: maxValue , selectionAlignment: selectionAlignment  } = props;
+    let calendar = $hEzMm$react.useMemo(()=>createCalendar(resolvedOptions.calendar)
+    , [
+        createCalendar,
+        resolvedOptions.calendar
+    ]);
+    let [value, setControlledValue] = $hEzMm$reactstatelyutils.useControlledState(props.value, props.defaultValue, props.onChange);
+    let calendarDateValue = $hEzMm$react.useMemo(()=>value ? $hEzMm$internationalizeddate.toCalendar($hEzMm$internationalizeddate.toCalendarDate(value), calendar) : null
+    , [
+        value,
+        calendar
+    ]);
+    let timeZone = $hEzMm$react.useMemo(()=>value && 'timeZone' in value ? value.timeZone : resolvedOptions.timeZone
+    , [
+        value,
+        resolvedOptions.timeZone
+    ]);
+    let focusedCalendarDate = $hEzMm$react.useMemo(()=>props.focusedValue ? $4301262d71f567b9$export$4f5203c0d889109e($hEzMm$internationalizeddate.toCalendar($hEzMm$internationalizeddate.toCalendarDate(props.focusedValue), calendar), minValue, maxValue) : undefined
+    , [
+        props.focusedValue,
+        calendar,
+        minValue,
+        maxValue
+    ]);
+    let defaultFocusedCalendarDate = $hEzMm$react.useMemo(()=>$4301262d71f567b9$export$4f5203c0d889109e(props.defaultFocusedValue ? $hEzMm$internationalizeddate.toCalendar($hEzMm$internationalizeddate.toCalendarDate(props.defaultFocusedValue), calendar) : calendarDateValue || $hEzMm$internationalizeddate.toCalendar($hEzMm$internationalizeddate.today(timeZone), calendar), minValue, maxValue)
+    , [
+        props.defaultFocusedValue,
+        calendarDateValue,
+        timeZone,
+        calendar,
+        minValue,
+        maxValue
+    ]);
+    let [focusedDate, setFocusedDate] = $hEzMm$reactstatelyutils.useControlledState(focusedCalendarDate, defaultFocusedCalendarDate, props.onFocusChange);
+    let [startDate, setStartDate] = $hEzMm$react.useState(()=>{
+        switch(selectionAlignment){
+            case 'start':
+                return $4301262d71f567b9$export$144a00ba6044eb9(focusedDate, visibleDuration, locale, minValue, maxValue);
+            case 'end':
+                return $4301262d71f567b9$export$530edbfc915b2b04(focusedDate, visibleDuration, locale, minValue, maxValue);
+            case 'center':
+            default:
+                return $4301262d71f567b9$export$f4a51ff076cc9a09(focusedDate, visibleDuration, locale, minValue, maxValue);
+        }
+    });
+    let [isFocused, setFocused] = $hEzMm$react.useState(props.autoFocus || false);
+    let endDate = $hEzMm$react.useMemo(()=>startDate.add(visibleDuration).subtract({
+            days: 1
+        })
+    , [
+        startDate,
+        visibleDuration
+    ]);
+    // Reset focused date and visible range when calendar changes.
+    let lastCalendarIdentifier = $hEzMm$react.useRef(calendar.identifier);
     if (calendar.identifier !== lastCalendarIdentifier.current) {
-      let newFocusedDate = toCalendar(focusedDate, calendar);
-      setStartDate($cb3c71934523b9f11dab70388c912b98$export$alignCenter(newFocusedDate, visibleDuration, locale, minValue, maxValue));
-      setFocusedDate(newFocusedDate);
-      lastCalendarIdentifier.current = calendar.identifier;
+        let newFocusedDate = $hEzMm$internationalizeddate.toCalendar(focusedDate, calendar);
+        setStartDate($4301262d71f567b9$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 = $cb3c71934523b9f11dab70388c912b98$export$constrainValue(date, minValue, maxValue);
-    let next = startDate.add(visibleDuration);
-
-    if (date.compare(startDate) < 0) {
-      setStartDate($cb3c71934523b9f11dab70388c912b98$export$alignEnd(date, visibleDuration, locale, minValue, maxValue));
-    } else if (date.compare(next) >= 0) {
-      setStartDate($cb3c71934523b9f11dab70388c912b98$export$alignStart(date, visibleDuration, locale, minValue, maxValue));
+    if ($4301262d71f567b9$export$eac50920cf2fd59a(focusedDate, minValue, maxValue)) // If the focused date was moved to an invalid value, it can't be focused, so constrain it.
+    setFocusedDate($4301262d71f567b9$export$4f5203c0d889109e(focusedDate, minValue, maxValue));
+    else if (focusedDate.compare(startDate) < 0) setStartDate($4301262d71f567b9$export$530edbfc915b2b04(focusedDate, visibleDuration, locale, minValue, maxValue));
+    else if (focusedDate.compare(startDate.add(visibleDuration)) >= 0) setStartDate($4301262d71f567b9$export$144a00ba6044eb9(focusedDate, visibleDuration, locale, minValue, maxValue));
+    // Sets focus to a specific cell date
+    function focusCell(date) {
+        date = $4301262d71f567b9$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 = $hEzMm$internationalizeddate.toCalendar(newValue, (value === null || value === void 0 ? void 0 : value.calendar) || new $hEzMm$internationalizeddate.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($cb3c71934523b9f11dab70388c912b98$export$constrainStart(focusedDate, start, visibleDuration, locale, minValue, maxValue));
-      setFocusedDate($cb3c71934523b9f11dab70388c912b98$export$constrainValue(focusedDate.add(visibleDuration), minValue, maxValue));
-    },
-
-    focusPreviousPage() {
-      let start = startDate.subtract(visibleDuration);
-      setStartDate($cb3c71934523b9f11dab70388c912b98$export$constrainStart(focusedDate, start, visibleDuration, locale, minValue, maxValue));
-      setFocusedDate($cb3c71934523b9f11dab70388c912b98$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($4301262d71f567b9$export$4f5203c0d889109e(focusedDate.add(visibleDuration), minValue, maxValue));
+            setStartDate($4301262d71f567b9$export$5bb865b12696a77d(focusedDate, start, visibleDuration, locale, minValue, maxValue));
+        },
+        focusPreviousPage () {
+            let start = startDate.subtract(visibleDuration);
+            setFocusedDate($4301262d71f567b9$export$4f5203c0d889109e(focusedDate.subtract(visibleDuration), minValue, maxValue));
+            setStartDate($4301262d71f567b9$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 $4301262d71f567b9$export$eac50920cf2fd59a(date, minValue, maxValue);
+        },
+        isSelected (date) {
+            return calendarDateValue != null && $hEzMm$internationalizeddate.isSameDay(date, calendarDateValue) && !this.isCellDisabled(date) && !this.isCellUnavailable(date);
+        },
+        isCellFocused (date) {
+            return isFocused && focusedDate && $hEzMm$internationalizeddate.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 $e49f7b861e5e8049$exports = {};
 
-    isInvalid(date) {
-      return $cb3c71934523b9f11dab70388c912b98$export$isInvalid(date, minValue, maxValue);
-    },
+$parcel$export($e49f7b861e5e8049$exports, "useRangeCalendarState", () => $e49f7b861e5e8049$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 || $cb3c71934523b9f11dab70388c912b98$export$isInvalid(date, minValue, maxValue);
-    },
 
-    isPreviousVisibleRangeInvalid() {
-      return $cb3c71934523b9f11dab70388c912b98$export$isInvalid(startDate.subtract({
-        days: 1
-      }), minValue, maxValue);
-    },
 
-    isNextVisibleRangeInvalid() {
-      return $cb3c71934523b9f11dab70388c912b98$export$isInvalid(endDate.add({
-        days: 1
-      }), minValue, maxValue);
+function $e49f7b861e5e8049$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] = $hEzMm$reactstatelyutils.useControlledState(valueProp, defaultValue || null, onChange);
+    let [anchorDate, setAnchorDateState] = $hEzMm$react.useState(null);
+    let alignment = 'center';
+    if (value && value.start && value.end) {
+        let start = $4301262d71f567b9$export$f4a51ff076cc9a09($hEzMm$internationalizeddate.toCalendarDate(value.start), visibleDuration, locale, minValue, maxValue);
+        let end = start.add(visibleDuration).subtract({
+            days: 1
+        });
+        if (value.end.compare(end) > 0) alignment = 'start';
     }
-
-  };
-}
-
-exports.useCalendarState = useCalendarState;
-
-function useRangeCalendarState(props) {
-  let {
-    value: valueProp,
-    defaultValue,
-    onChange,
-    createCalendar,
-    locale,
-    visibleDuration = {
-      months: 1
-    },
-    minValue,
-    maxValue
-  } = props,
-      calendarProps = _babelRuntimeHelpersObjectWithoutPropertiesLoose(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 = $cb3c71934523b9f11dab70388c912b98$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 = $hEzMm$react.useRef(null);
+    let [availableRange, setAvailableRange] = $hEzMm$react.useState(null);
+    let min = $hEzMm$react.useMemo(()=>{
+        return $hEzMm$internationalizeddate.maxDate(minValue, availableRange === null || availableRange === void 0 ? void 0 : availableRange.start);
+    }, [
+        minValue,
+        availableRange
+    ]);
+    let max = $hEzMm$react.useMemo(()=>{
+        return $hEzMm$internationalizeddate.minDate(maxValue, availableRange === null || availableRange === void 0 ? void 0 : availableRange.end);
+    }, [
+        maxValue,
+        availableRange
+    ]);
+    let calendar = $6adad0c8536fc209$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(_babelRuntimeHelpersExtends({}, calendarProps, {
-    value: value && value.start,
-    createCalendar,
-    locale,
-    visibleDuration,
-    minValue,
-    maxValue,
-    selectionAlignment: alignment
-  }));
-  let highlightedRange = anchorDate ? $baa4c168da5893215a2941ab7b17cc3d$var$makeRange(anchorDate, calendar.focusedDate) : value && $baa4c168da5893215a2941ab7b17cc3d$var$makeRange(value.start, value.end);
-
-  let selectDate = date => {
-    if (props.isReadOnly) {
-      return;
+    let updateAvailableRange = (date)=>{
+        if (date && props.isDateUnavailable && !props.allowsNonContiguousRanges) {
+            availableRangeRef.current = {
+                start: $e49f7b861e5e8049$var$nextUnavailableDate(date, calendar, -1),
+                end: $e49f7b861e5e8049$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 = $hEzMm$react.useRef(calendar.visibleRange);
+    if (!$hEzMm$internationalizeddate.isEqualDay(calendar.visibleRange.start, lastVisibleRange.current.start) || !$hEzMm$internationalizeddate.isEqualDay(calendar.visibleRange.end, lastVisibleRange.current.end)) {
+        updateAvailableRange(anchorDate);
+        lastVisibleRange.current = calendar.visibleRange;
     }
-
-    if (!anchorDate) {
-      setAnchorDate(date);
-    } else {
-      let range = $baa4c168da5893215a2941ab7b17cc3d$var$makeRange(anchorDate, date);
-      setValue({
-        start: $baa4c168da5893215a2941ab7b17cc3d$var$convertValue(range.start, value == null ? void 0 : value.start),
-        end: $baa4c168da5893215a2941ab7b17cc3d$var$convertValue(range.end, value == null ? void 0 : value.end)
-      });
-      setAnchorDate(null);
-    }
-  };
-
-  let [isDragging, setDragging] = useState(false);
-  return _babelRuntimeHelpersExtends({}, 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 ? $e49f7b861e5e8049$var$makeRange(anchorDate, calendar.focusedDate) : value && $e49f7b861e5e8049$var$makeRange(value.start, value.end);
+    let selectDate = (date)=>{
+        if (props.isReadOnly) return;
+        if (!anchorDate) setAnchorDate(date);
+        else {
+            let range = $e49f7b861e5e8049$var$makeRange(anchorDate, date);
+            setValue({
+                start: $e49f7b861e5e8049$var$convertValue(range.start, value === null || value === void 0 ? void 0 : value.start),
+                end: $e49f7b861e5e8049$var$convertValue(range.end, value === null || value === void 0 ? void 0 : value.end)
+            });
+            setAnchorDate(null);
+        }
+    };
+    let [isDragging, setDragging] = $hEzMm$react.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) || $4301262d71f567b9$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
+    };
 }
-
-exports.useRangeCalendarState = useRangeCalendarState;
-
-function $baa4c168da5893215a2941ab7b17cc3d$var$makeRange(start, end) {
-  if (!start || !end) {
+function $e49f7b861e5e8049$var$makeRange(start, end) {
+    if (!start || !end) return null;
+    if (end.compare(start) < 0) [start, end] = [
+        end,
+        start
+    ];
+    return {
+        start: $hEzMm$internationalizeddate.toCalendarDate(start),
+        end: $hEzMm$internationalizeddate.toCalendarDate(end)
+    };
+}
+function $e49f7b861e5e8049$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 = $hEzMm$internationalizeddate.toCalendar(newValue, (oldValue === null || oldValue === void 0 ? void 0 : oldValue.calendar) || new $hEzMm$internationalizeddate.GregorianCalendar());
+    // Preserve time if the input value had one.
+    if (oldValue && 'hour' in oldValue) return oldValue.set(newValue);
+    return newValue;
+}
+function $e49f7b861e5e8049$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 $baa4c168da5893215a2941ab7b17cc3d$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);
-  }
+$parcel$exportWildcard(module.exports, $7a549489c00e7fe0$exports);
+$parcel$exportWildcard(module.exports, $6adad0c8536fc209$exports);
+$parcel$exportWildcard(module.exports, $e49f7b861e5e8049$exports);
+
 
-  return newValue;
-}
 //# sourceMappingURL=main.js.map