@sparrowengg/integrations-templates-frontend 8.0.1 → 8.0.3

package/dist/cjs/node_modules/@sparrowengg/twigs-react/dist/es/node_modules/@react-stately/calendar/dist/useCalendarState.js

@@ -8,291 +8,310 @@ var DateFormatter = require('../../../@internationalized/date/dist/DateFormatter
 var useControlledState = require('../../utils/dist/useControlledState.js');
 var React = require('react');
 
-/*
- * Copyright 2020 Adobe. All rights reserved.
- * This file is licensed to you under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License. You may obtain a copy
- * of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under
- * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
- * OF ANY KIND, either express or implied. See the License for the specific language
- * governing permissions and limitations under the License.
- */ 
-
-
-
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
 function $131cf43a05231e1e$export$6d095e787d2b5e1f(props) {
-    let defaultFormatter = (React.useMemo)(()=>new (DateFormatter.DateFormatter)(props.locale), [
-        props.locale
-    ]);
-    let resolvedOptions = (React.useMemo)(()=>defaultFormatter.resolvedOptions(), [
-        defaultFormatter
-    ]);
-    let { locale: locale, createCalendar: createCalendar, visibleDuration: visibleDuration = {
-        months: 1
-    }, minValue: minValue, maxValue: maxValue, selectionAlignment: selectionAlignment, isDateUnavailable: isDateUnavailable, pageBehavior: pageBehavior = 'visible', firstDayOfWeek: firstDayOfWeek } = props;
-    let calendar = (React.useMemo)(()=>createCalendar(resolvedOptions.calendar), [
-        createCalendar,
-        resolvedOptions.calendar
-    ]);
-    var _props_defaultValue;
-    let [value, setControlledValue] = (useControlledState.useControlledState)(props.value, (_props_defaultValue = props.defaultValue) !== null && _props_defaultValue !== void 0 ? _props_defaultValue : null, props.onChange);
-    let calendarDateValue = (React.useMemo)(()=>value ? (conversion.toCalendar)((conversion.toCalendarDate)(value), calendar) : null, [
-        value,
-        calendar
-    ]);
-    let timeZone = (React.useMemo)(()=>value && 'timeZone' in value ? value.timeZone : resolvedOptions.timeZone, [
-        value,
-        resolvedOptions.timeZone
-    ]);
-    let focusedCalendarDate = (React.useMemo)(()=>props.focusedValue ? (utils.constrainValue)((conversion.toCalendar)((conversion.toCalendarDate)(props.focusedValue), calendar), minValue, maxValue) : undefined, [
-        props.focusedValue,
-        calendar,
-        minValue,
-        maxValue
-    ]);
-    let defaultFocusedCalendarDate = (React.useMemo)(()=>(utils.constrainValue)(props.defaultFocusedValue ? (conversion.toCalendar)((conversion.toCalendarDate)(props.defaultFocusedValue), calendar) : calendarDateValue || (conversion.toCalendar)((queries.today)(timeZone), calendar), minValue, maxValue), [
-        props.defaultFocusedValue,
-        calendarDateValue,
-        timeZone,
-        calendar,
-        minValue,
-        maxValue
-    ]);
-    let [focusedDate, setFocusedDate] = (useControlledState.useControlledState)(focusedCalendarDate, defaultFocusedCalendarDate, props.onFocusChange);
-    let [startDate, setStartDate] = (React.useState)(()=>{
-        switch(selectionAlignment){
-            case 'start':
-                return (utils.alignStart)(focusedDate, visibleDuration, locale, minValue, maxValue);
-            case 'end':
-                return (utils.alignEnd)(focusedDate, visibleDuration, locale, minValue, maxValue);
-            case 'center':
-            default:
-                return (utils.alignCenter)(focusedDate, visibleDuration, locale, minValue, maxValue);
-        }
-    });
-    let [isFocused, setFocused] = (React.useState)(props.autoFocus || false);
-    let endDate = (React.useMemo)(()=>{
-        let duration = {
-            ...visibleDuration
-        };
-        if (duration.days) duration.days--;
-        else duration.days = -1;
-        return startDate.add(duration);
-    }, [
-        startDate,
-        visibleDuration
-    ]);
-    // Reset focused date and visible range when calendar changes.
-    let [lastCalendar, setLastCalendar] = (React.useState)(calendar);
-    if (!(queries.isEqualCalendar)(calendar, lastCalendar)) {
-        let newFocusedDate = (conversion.toCalendar)(focusedDate, calendar);
-        setStartDate((utils.alignCenter)(newFocusedDate, visibleDuration, locale, minValue, maxValue));
-        setFocusedDate(newFocusedDate);
-        setLastCalendar(calendar);
+  let defaultFormatter = React.useMemo(() => new DateFormatter.DateFormatter(props.locale), [
+    props.locale
+  ]);
+  let resolvedOptions = React.useMemo(() => defaultFormatter.resolvedOptions(), [
+    defaultFormatter
+  ]);
+  let { locale, createCalendar, visibleDuration = {
+    months: 1
+  }, minValue, maxValue, selectionAlignment, isDateUnavailable, pageBehavior = "visible", firstDayOfWeek } = props;
+  let calendar = React.useMemo(() => createCalendar(resolvedOptions.calendar), [
+    createCalendar,
+    resolvedOptions.calendar
+  ]);
+  var _props_defaultValue;
+  let [value, setControlledValue] = useControlledState.useControlledState(props.value, (_props_defaultValue = props.defaultValue) !== null && _props_defaultValue !== void 0 ? _props_defaultValue : null, props.onChange);
+  let calendarDateValue = React.useMemo(() => value ? conversion.toCalendar(conversion.toCalendarDate(value), calendar) : null, [
+    value,
+    calendar
+  ]);
+  let timeZone = React.useMemo(() => value && "timeZone" in value ? value.timeZone : resolvedOptions.timeZone, [
+    value,
+    resolvedOptions.timeZone
+  ]);
+  let focusedCalendarDate = React.useMemo(() => props.focusedValue ? utils.constrainValue(conversion.toCalendar(conversion.toCalendarDate(props.focusedValue), calendar), minValue, maxValue) : void 0, [
+    props.focusedValue,
+    calendar,
+    minValue,
+    maxValue
+  ]);
+  let defaultFocusedCalendarDate = React.useMemo(() => utils.constrainValue(props.defaultFocusedValue ? conversion.toCalendar(conversion.toCalendarDate(props.defaultFocusedValue), calendar) : calendarDateValue || conversion.toCalendar(queries.today(timeZone), calendar), minValue, maxValue), [
+    props.defaultFocusedValue,
+    calendarDateValue,
+    timeZone,
+    calendar,
+    minValue,
+    maxValue
+  ]);
+  let [focusedDate, setFocusedDate] = useControlledState.useControlledState(focusedCalendarDate, defaultFocusedCalendarDate, props.onFocusChange);
+  let [startDate, setStartDate] = React.useState(() => {
+    switch (selectionAlignment) {
+      case "start":
+        return utils.alignStart(focusedDate, visibleDuration, locale, minValue, maxValue);
+      case "end":
+        return utils.alignEnd(focusedDate, visibleDuration, locale, minValue, maxValue);
+      case "center":
+      default:
+        return utils.alignCenter(focusedDate, visibleDuration, locale, minValue, maxValue);
     }
-    if ((utils.isInvalid)(focusedDate, minValue, maxValue)) // If the focused date was moved to an invalid value, it can't be focused, so constrain it.
-    setFocusedDate((utils.constrainValue)(focusedDate, minValue, maxValue));
-    else if (focusedDate.compare(startDate) < 0) setStartDate((utils.alignEnd)(focusedDate, visibleDuration, locale, minValue, maxValue));
-    else if (focusedDate.compare(endDate) > 0) setStartDate((utils.alignStart)(focusedDate, visibleDuration, locale, minValue, maxValue));
-    // Sets focus to a specific cell date
-    function focusCell(date) {
-        date = (utils.constrainValue)(date, minValue, maxValue);
-        setFocusedDate(date);
+  });
+  let [isFocused, setFocused] = React.useState(props.autoFocus || false);
+  let endDate = React.useMemo(() => {
+    let duration = __spreadValues({}, visibleDuration);
+    if (duration.days)
+      duration.days--;
+    else
+      duration.days = -1;
+    return startDate.add(duration);
+  }, [
+    startDate,
+    visibleDuration
+  ]);
+  let [lastCalendar, setLastCalendar] = React.useState(calendar);
+  if (!queries.isEqualCalendar(calendar, lastCalendar)) {
+    let newFocusedDate = conversion.toCalendar(focusedDate, calendar);
+    setStartDate(utils.alignCenter(newFocusedDate, visibleDuration, locale, minValue, maxValue));
+    setFocusedDate(newFocusedDate);
+    setLastCalendar(calendar);
+  }
+  if (utils.isInvalid(focusedDate, minValue, maxValue))
+    setFocusedDate(utils.constrainValue(focusedDate, minValue, maxValue));
+  else if (focusedDate.compare(startDate) < 0)
+    setStartDate(utils.alignEnd(focusedDate, visibleDuration, locale, minValue, maxValue));
+  else if (focusedDate.compare(endDate) > 0)
+    setStartDate(utils.alignStart(focusedDate, visibleDuration, locale, minValue, maxValue));
+  function focusCell(date) {
+    date = utils.constrainValue(date, minValue, maxValue);
+    setFocusedDate(date);
+  }
+  function setValue(newValue) {
+    if (!props.isDisabled && !props.isReadOnly) {
+      let localValue = newValue;
+      if (localValue === null) {
+        setControlledValue(null);
+        return;
+      }
+      localValue = utils.constrainValue(localValue, minValue, maxValue);
+      localValue = utils.previousAvailableDate(localValue, startDate, isDateUnavailable);
+      if (!localValue)
+        return;
+      localValue = conversion.toCalendar(localValue, (value === null || value === void 0 ? void 0 : value.calendar) || new GregorianCalendar.GregorianCalendar());
+      if (value && "hour" in value)
+        setControlledValue(value.set(localValue));
+      else
+        setControlledValue(localValue);
     }
-    function setValue(newValue) {
-        if (!props.isDisabled && !props.isReadOnly) {
-            let localValue = newValue;
-            if (localValue === null) {
-                setControlledValue(null);
-                return;
-            }
-            localValue = (utils.constrainValue)(localValue, minValue, maxValue);
-            localValue = (utils.previousAvailableDate)(localValue, startDate, isDateUnavailable);
-            if (!localValue) return;
-            // 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.
-            localValue = (conversion.toCalendar)(localValue, (value === null || value === void 0 ? void 0 : value.calendar) || new (GregorianCalendar.GregorianCalendar)());
-            // Preserve time if the input value had one.
-            if (value && 'hour' in value) setControlledValue(value.set(localValue));
-            else setControlledValue(localValue);
-        }
+  }
+  let isUnavailable = React.useMemo(() => {
+    if (!calendarDateValue)
+      return false;
+    if (isDateUnavailable && isDateUnavailable(calendarDateValue))
+      return true;
+    return utils.isInvalid(calendarDateValue, minValue, maxValue);
+  }, [
+    calendarDateValue,
+    isDateUnavailable,
+    minValue,
+    maxValue
+  ]);
+  let isValueInvalid = props.isInvalid || props.validationState === "invalid" || isUnavailable;
+  let validationState = isValueInvalid ? "invalid" : null;
+  let pageDuration = React.useMemo(() => {
+    if (pageBehavior === "visible")
+      return visibleDuration;
+    return $131cf43a05231e1e$var$unitDuration(visibleDuration);
+  }, [
+    pageBehavior,
+    visibleDuration
+  ]);
+  var _props_isDisabled, _props_isReadOnly;
+  return {
+    isDisabled: (_props_isDisabled = props.isDisabled) !== null && _props_isDisabled !== void 0 ? _props_isDisabled : false,
+    isReadOnly: (_props_isReadOnly = props.isReadOnly) !== null && _props_isReadOnly !== void 0 ? _props_isReadOnly : false,
+    value: calendarDateValue,
+    setValue,
+    visibleRange: {
+      start: startDate,
+      end: endDate
+    },
+    minValue,
+    maxValue,
+    focusedDate,
+    timeZone,
+    validationState,
+    isValueInvalid,
+    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(pageDuration);
+      setFocusedDate(utils.constrainValue(focusedDate.add(pageDuration), minValue, maxValue));
+      setStartDate(utils.alignStart(utils.constrainStart(focusedDate, start, pageDuration, locale, minValue, maxValue), pageDuration, locale));
+    },
+    focusPreviousPage() {
+      let start = startDate.subtract(pageDuration);
+      setFocusedDate(utils.constrainValue(focusedDate.subtract(pageDuration), minValue, maxValue));
+      setStartDate(utils.alignStart(utils.constrainStart(focusedDate, start, pageDuration, locale, minValue, maxValue), pageDuration, locale));
+    },
+    focusSectionStart() {
+      if (visibleDuration.days)
+        focusCell(startDate);
+      else if (visibleDuration.weeks)
+        focusCell(queries.startOfWeek(focusedDate, locale));
+      else if (visibleDuration.months || visibleDuration.years)
+        focusCell(queries.startOfMonth(focusedDate));
+    },
+    focusSectionEnd() {
+      if (visibleDuration.days)
+        focusCell(endDate);
+      else if (visibleDuration.weeks)
+        focusCell(queries.endOfWeek(focusedDate, locale));
+      else if (visibleDuration.months || visibleDuration.years)
+        focusCell(queries.endOfMonth(focusedDate));
+    },
+    focusNextSection(larger) {
+      if (!larger && !visibleDuration.days) {
+        focusCell(focusedDate.add($131cf43a05231e1e$var$unitDuration(visibleDuration)));
+        return;
+      }
+      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(larger) {
+      if (!larger && !visibleDuration.days) {
+        focusCell(focusedDate.subtract($131cf43a05231e1e$var$unitDuration(visibleDuration)));
+        return;
+      }
+      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() {
+      if (!(isDateUnavailable && isDateUnavailable(focusedDate)))
+        setValue(focusedDate);
+    },
+    selectDate(date) {
+      setValue(date);
+    },
+    isFocused,
+    setFocused,
+    isInvalid(date) {
+      return utils.isInvalid(date, minValue, maxValue);
+    },
+    isSelected(date) {
+      return calendarDateValue != null && queries.isSameDay(date, calendarDateValue) && !this.isCellDisabled(date) && !this.isCellUnavailable(date);
+    },
+    isCellFocused(date) {
+      return isFocused && focusedDate && queries.isSameDay(date, focusedDate);
+    },
+    isCellDisabled(date) {
+      return props.isDisabled || date.compare(startDate) < 0 || date.compare(endDate) > 0 || this.isInvalid(date);
+    },
+    isCellUnavailable(date) {
+      return props.isDateUnavailable ? props.isDateUnavailable(date) : false;
+    },
+    isPreviousVisibleRangeInvalid() {
+      let prev = startDate.subtract({
+        days: 1
+      });
+      return queries.isSameDay(prev, startDate) || this.isInvalid(prev);
+    },
+    isNextVisibleRangeInvalid() {
+      let next = endDate.add({
+        days: 1
+      });
+      return queries.isSameDay(next, endDate) || this.isInvalid(next);
+    },
+    getDatesInWeek(weekIndex, from = startDate) {
+      let date = from.add({
+        weeks: weekIndex
+      });
+      let dates = [];
+      date = queries.startOfWeek(date, locale, firstDayOfWeek);
+      let dayOfWeek = queries.getDayOfWeek(date, locale, firstDayOfWeek);
+      for (let i = 0; i < dayOfWeek; i++)
+        dates.push(null);
+      while (dates.length < 7) {
+        dates.push(date);
+        let nextDate = date.add({
+          days: 1
+        });
+        if (queries.isSameDay(date, nextDate))
+          break;
+        date = nextDate;
+      }
+      while (dates.length < 7)
+        dates.push(null);
+      return dates;
     }
-    let isUnavailable = (React.useMemo)(()=>{
-        if (!calendarDateValue) return false;
-        if (isDateUnavailable && isDateUnavailable(calendarDateValue)) return true;
-        return (utils.isInvalid)(calendarDateValue, minValue, maxValue);
-    }, [
-        calendarDateValue,
-        isDateUnavailable,
-        minValue,
-        maxValue
-    ]);
-    let isValueInvalid = props.isInvalid || props.validationState === 'invalid' || isUnavailable;
-    let validationState = isValueInvalid ? 'invalid' : null;
-    let pageDuration = (React.useMemo)(()=>{
-        if (pageBehavior === 'visible') return visibleDuration;
-        return $131cf43a05231e1e$var$unitDuration(visibleDuration);
-    }, [
-        pageBehavior,
-        visibleDuration
-    ]);
-    var _props_isDisabled, _props_isReadOnly;
-    return {
-        isDisabled: (_props_isDisabled = props.isDisabled) !== null && _props_isDisabled !== void 0 ? _props_isDisabled : false,
-        isReadOnly: (_props_isReadOnly = props.isReadOnly) !== null && _props_isReadOnly !== void 0 ? _props_isReadOnly : false,
-        value: calendarDateValue,
-        setValue: setValue,
-        visibleRange: {
-            start: startDate,
-            end: endDate
-        },
-        minValue: minValue,
-        maxValue: maxValue,
-        focusedDate: focusedDate,
-        timeZone: timeZone,
-        validationState: validationState,
-        isValueInvalid: isValueInvalid,
-        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(pageDuration);
-            setFocusedDate((utils.constrainValue)(focusedDate.add(pageDuration), minValue, maxValue));
-            setStartDate((utils.alignStart)((utils.constrainStart)(focusedDate, start, pageDuration, locale, minValue, maxValue), pageDuration, locale));
-        },
-        focusPreviousPage () {
-            let start = startDate.subtract(pageDuration);
-            setFocusedDate((utils.constrainValue)(focusedDate.subtract(pageDuration), minValue, maxValue));
-            setStartDate((utils.alignStart)((utils.constrainStart)(focusedDate, start, pageDuration, locale, minValue, maxValue), pageDuration, locale));
-        },
-        focusSectionStart () {
-            if (visibleDuration.days) focusCell(startDate);
-            else if (visibleDuration.weeks) focusCell((queries.startOfWeek)(focusedDate, locale));
-            else if (visibleDuration.months || visibleDuration.years) focusCell((queries.startOfMonth)(focusedDate));
-        },
-        focusSectionEnd () {
-            if (visibleDuration.days) focusCell(endDate);
-            else if (visibleDuration.weeks) focusCell((queries.endOfWeek)(focusedDate, locale));
-            else if (visibleDuration.months || visibleDuration.years) focusCell((queries.endOfMonth)(focusedDate));
-        },
-        focusNextSection (larger) {
-            if (!larger && !visibleDuration.days) {
-                focusCell(focusedDate.add($131cf43a05231e1e$var$unitDuration(visibleDuration)));
-                return;
-            }
-            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 (larger) {
-            if (!larger && !visibleDuration.days) {
-                focusCell(focusedDate.subtract($131cf43a05231e1e$var$unitDuration(visibleDuration)));
-                return;
-            }
-            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 () {
-            if (!(isDateUnavailable && isDateUnavailable(focusedDate))) setValue(focusedDate);
-        },
-        selectDate (date) {
-            setValue(date);
-        },
-        isFocused: isFocused,
-        setFocused: setFocused,
-        isInvalid (date) {
-            return (utils.isInvalid)(date, minValue, maxValue);
-        },
-        isSelected (date) {
-            return calendarDateValue != null && (queries.isSameDay)(date, calendarDateValue) && !this.isCellDisabled(date) && !this.isCellUnavailable(date);
-        },
-        isCellFocused (date) {
-            return isFocused && focusedDate && (queries.isSameDay)(date, focusedDate);
-        },
-        isCellDisabled (date) {
-            return props.isDisabled || date.compare(startDate) < 0 || date.compare(endDate) > 0 || this.isInvalid(date);
-        },
-        isCellUnavailable (date) {
-            return props.isDateUnavailable ? props.isDateUnavailable(date) : false;
-        },
-        isPreviousVisibleRangeInvalid () {
-            let prev = startDate.subtract({
-                days: 1
-            });
-            return (queries.isSameDay)(prev, startDate) || this.isInvalid(prev);
-        },
-        isNextVisibleRangeInvalid () {
-            // Adding may return the same date if we reached the end of time
-            // according to the calendar system (e.g. 9999-12-31).
-            let next = endDate.add({
-                days: 1
-            });
-            return (queries.isSameDay)(next, endDate) || this.isInvalid(next);
-        },
-        getDatesInWeek (weekIndex, from = startDate) {
-            let date = from.add({
-                weeks: weekIndex
-            });
-            let dates = [];
-            date = (queries.startOfWeek)(date, locale, firstDayOfWeek);
-            // startOfWeek will clamp dates within the calendar system's valid range, which may
-            // start in the middle of a week. In this case, add null placeholders.
-            let dayOfWeek = (queries.getDayOfWeek)(date, locale, firstDayOfWeek);
-            for(let i = 0; i < dayOfWeek; i++)dates.push(null);
-            while(dates.length < 7){
-                dates.push(date);
-                let nextDate = date.add({
-                    days: 1
-                });
-                if ((queries.isSameDay)(date, nextDate)) break;
-                date = nextDate;
-            }
-            // Add null placeholders if at the end of the calendar system.
-            while(dates.length < 7)dates.push(null);
-            return dates;
-        }
-    };
+  };
 }
 function $131cf43a05231e1e$var$unitDuration(duration) {
-    let unit = {
-        ...duration
-    };
-    for(let key in duration)unit[key] = 1;
-    return unit;
+  let unit = __spreadValues({}, duration);
+  for (let key in duration)
+    unit[key] = 1;
+  return unit;
 }
 
 exports.useCalendarState = $131cf43a05231e1e$export$6d095e787d2b5e1f;