@superdispatch/dates 0.25.2 → 0.26.1

package/dist-node/index.js

@@ -24,12 +24,10 @@ function setDefaultTimeZone(offset) {
     luxon.Settings.defaultZoneName = offset;
   } else {
     var zone = luxon.FixedOffsetZone.instance(offset);
-
     if (zone.isValid) {
       luxon.Settings.defaultZoneName = zone.name;
     }
   }
-
   return luxon.Settings.defaultZoneName;
 }
 function useDefaultTimeZone(offset) {
@@ -64,6 +62,7 @@ function DateConfigProvider(_ref) {
   });
 }
 
+//
 // Config
 //
 
@@ -93,7 +92,9 @@ var DATE_DISPLAY_VARIANTS = {
     hour: 'numeric',
     minute: 'numeric'
   }
-}; //
+};
+
+//
 // Date Utils
 //
 
@@ -101,72 +102,57 @@ function toPrimitiveDateInput(input) {
   if (typeof input == 'number' || typeof input == 'string') {
     return input;
   }
-
   if (input instanceof Date || input instanceof luxon.DateTime) {
     return input.valueOf();
   }
-
   return NaN;
 }
 function parseDate(input) {
   var {
     format
   } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultDateConfig;
-
   if (input instanceof luxon.DateTime) {
     var {
       defaultZone
     } = luxon.Settings;
-
     if (!defaultZone.equals(input.zone)) {
       return input.setZone(defaultZone);
     }
-
     return input;
   }
-
   if (input instanceof Date) {
     return luxon.DateTime.fromJSDate(input);
   }
-
   if (typeof input === 'number') {
     return luxon.DateTime.fromMillis(input);
   }
-
   if (typeof input == 'string') {
     switch (format) {
       case 'DateISO':
       case 'DateTimeISO':
         return luxon.DateTime.fromISO(input);
-
       default:
         return luxon.DateTime.fromFormat(input, DATE_FORMATS[format]);
     }
   }
-
   return luxon.DateTime.invalid('invalid input');
 }
 function stringifyDate(input) {
   var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultDateConfig;
   var date = parseDate(input, config);
-
   if (date.isValid) {
     var {
       format
     } = config;
-
     switch (format) {
       case 'DateISO':
         return date.toISODate();
-
       case 'DateTimeISO':
         return date.toISO();
-
       default:
         return date.toFormat(DATE_FORMATS[format]);
     }
   }
-
   return null;
 }
 function formatDate(input, _ref) {
@@ -176,24 +162,19 @@ function formatDate(input, _ref) {
   } = _ref;
   var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultDateConfig;
   var date = parseDate(input, config);
-
   if (!date.isValid) {
     return fallback;
   }
-
   return date.toLocaleString(DATE_DISPLAY_VARIANTS[variant]);
 }
-
 function formatUnit(unit) {
   switch (unit) {
     case 'months':
       return 'mo';
-
     default:
       return unit.charAt(0);
   }
 }
-
 function formatRelativeTime(input) {
   var {
     round = true,
@@ -206,36 +187,28 @@ function formatRelativeTime(input) {
   var base = baseOption == null ? luxon.DateTime.now() : parseDate(baseOption, config);
   var date = parseDate(input, config);
   var padding = paddingOption ? date < base ? -paddingOption : paddingOption : 0;
-
   function format(value, unit) {
     var isPast = Object.is(value, -0) || value < 0;
     var diff = Math.abs(!round ? value : Math.trunc(value));
     var formattedUnit = formatUnit(unit);
     return isPast ? "".concat(diff).concat(formattedUnit, " ago") : "in ".concat(diff).concat(formattedUnit);
   }
-
   function differ(unit) {
     return date.plus(padding).diff(base, unit).get(unit);
   }
-
   if (date.isValid && base.isValid) {
     var units = ['years', 'months', 'days', 'hours', 'minutes', 'seconds'];
-
     if (unitOption) {
       return format(differ(unitOption), unitOption);
     }
-
     for (var unit of units) {
       var diff = differ(unit);
-
       if (Math.abs(diff) >= 1) {
         return format(diff, unit);
       }
     }
-
     return format(0, 'seconds');
   }
-
   return fallback;
 }
 function toDatePayload(input) {
@@ -246,7 +219,9 @@ function toDatePayload(input) {
     dateValue,
     stringValue: stringifyDate(dateValue, config)
   };
-} //
+}
+
+//
 // Date Range Utils
 //
 
@@ -254,17 +229,14 @@ function toPrimitiveDateRangeInput(input) {
   if (!Array.isArray(input)) {
     return [undefined, undefined];
   }
-
   return [toPrimitiveDateInput(input[0]), toPrimitiveDateInput(input[1])];
 }
 function parseDateRange(input, config) {
   var start = null;
   var finish = null;
-
   if (Array.isArray(input)) {
     [start = null, finish = null] = input.map(value => parseDate(value, config)).filter(date => date.isValid).sort((a, b) => a.valueOf() - b.valueOf());
   }
-
   return [start, finish];
 }
 function stringifyDateRange(input, config) {
@@ -277,11 +249,9 @@ function formatDateRange(input, _ref2) {
   } = _ref2;
   var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultDateConfig;
   var [start, finish] = parseDateRange(input, config);
-
   if (!start) {
     return fallback;
   }
-
   var startVariant = !(finish !== null && finish !== void 0 && finish.hasSame(start, 'year')) ? 'Date' : 'ShortDate';
   var startText = formatDate(start, {
     variant: startVariant
@@ -306,14 +276,12 @@ function useDateTime(input, options) {
   var primitiveInput = toPrimitiveDateInput(input);
   return react.useMemo(() => {
     var date = parseDate(primitiveInput, config);
-
     if (process.env.NODE_ENV !== 'production') {
       if (!date.isValid && typeof primitiveInput === 'string') {
         // eslint-disable-next-line no-console
         console.error("[useDateTime] Failed to parse \"".concat(primitiveInput, "\" string with \"").concat(config.format, "\" format."));
       }
     }
-
     return date;
   }, [config, primitiveInput]);
 }
@@ -592,9 +560,12 @@ var useStyles = /*#__PURE__*/styles.makeStyles(theme => ({
   todayButton: {}
 }), {
   name: 'SD-Calendar'
-}); //
+});
+
+//
 // Utility Types
 //
+
 //
 // Internal Utils
 //
@@ -603,7 +574,6 @@ function toDayPickerModifier(config, modifier) {
   if (!modifier) {
     return undefined;
   }
-
   return localDate => {
     var dateValue = luxon.DateTime.fromObject({
       year: localDate.getFullYear(),
@@ -621,12 +591,10 @@ function toDayPickerModifier(config, modifier) {
     });
   };
 }
-
 function toDayPickerHandler(config, classes, initialTime, handler) {
   if (!handler) {
     return undefined;
   }
-
   return (localDate, modifiers) => {
     var dateValue = luxon.DateTime.fromObject({
       year: localDate.getFullYear(),
@@ -645,35 +613,35 @@ function toDayPickerHandler(config, classes, initialTime, handler) {
       stringValue: stringifyDate(dateValue, config)
     });
   };
-} //
+}
+
+//
 // Calendar
 //
 
-
 var Calendar = /*#__PURE__*/react.forwardRef((_ref, ref) => {
   var {
-    footer,
-    classes,
-    direction,
-    quickSelection,
-    selectedDays,
-    disabledDays,
-    onDayClick,
-    onDayKeyDown,
-    onDayMouseEnter,
-    onDayMouseLeave,
-    onDayMouseDown,
-    onDayMouseUp,
-    onDayTouchEnd,
-    onDayTouchStart,
-    modifiers,
-    highlightedDays,
-    format: formatProp,
-    initialTime: initialTimeInputProp,
-    initialMonth: initialMonthInputProp
-  } = _ref,
-      dayPickerProps = _objectWithoutProperties(_ref, _excluded);
-
+      footer,
+      classes,
+      direction,
+      quickSelection,
+      selectedDays,
+      disabledDays,
+      onDayClick,
+      onDayKeyDown,
+      onDayMouseEnter,
+      onDayMouseLeave,
+      onDayMouseDown,
+      onDayMouseUp,
+      onDayTouchEnd,
+      onDayTouchStart,
+      modifiers,
+      highlightedDays,
+      format: formatProp,
+      initialTime: initialTimeInputProp,
+      initialMonth: initialMonthInputProp
+    } = _ref,
+    dayPickerProps = _objectWithoutProperties(_ref, _excluded);
   var styles = useStyles({
     classes
   });
@@ -685,15 +653,12 @@ var Calendar = /*#__PURE__*/react.forwardRef((_ref, ref) => {
   var [initialTime, initialMonth] = react.useMemo(() => {
     var time = initialTimeInput;
     var month = initialMonthInput;
-
     if (!month.isValid) {
       month = luxon.DateTime.local().startOf('month');
     }
-
     if (!time.isValid) {
       time = month;
     }
-
     return [time, new Date(month.year, month.month - 1, month.day, month.hour, month.minute, month.second, month.millisecond)];
   }, [initialTimeInput, initialMonthInput]);
   var wrapModifier = toDayPickerModifier.bind(null, config);
@@ -712,19 +677,16 @@ var Calendar = /*#__PURE__*/react.forwardRef((_ref, ref) => {
       return dateValue.day === dateValue.daysInMonth;
     })
   };
-
   if (modifiers) {
     for (var [key, modifier] of Object.entries(modifiers)) {
       dayPickerModifiers[key] = wrapModifier(modifier);
     }
   }
-
   if (highlightedDays) {
     for (var [_key, _modifier] of Object.entries(highlightedDays)) {
       dayPickerModifiers[styles[_key]] = wrapModifier(_modifier);
     }
   }
-
   return /*#__PURE__*/jsxRuntime.jsxs(core.Grid, {
     ref: ref,
     container: true,
@@ -822,41 +784,38 @@ var Popover = /*#__PURE__*/styled(core.Popover).withConfig({
 })([".MuiPaper-rounded{border:1px solid ", ";box-shadow:0px 0px 4px 0px rgba(0,0,0,0.05),0px 4px 8px 0px rgba(0,0,0,0.12);}"], ui.Color.Silver400);
 var BaseDatePicker = /*#__PURE__*/react.forwardRef((_ref, ref) => {
   var {
-    id,
-    api,
-    onClear,
-    onClick: _onClick,
-    onClose,
-    onKeyDown: _onKeyDown,
-    disabled,
-    children,
-    enableClearable,
-    inputRef: inputRefProp,
-    InputProps: inputProps
-  } = _ref,
-      textFieldProps = _objectWithoutProperties(_ref, _excluded$1);
-
+      id,
+      api,
+      onClear,
+      onClick: _onClick,
+      onClose,
+      onKeyDown: _onKeyDown,
+      disabled,
+      children,
+      enableClearable,
+      inputRef: inputRefProp,
+      InputProps: inputProps
+    } = _ref,
+    textFieldProps = _objectWithoutProperties(_ref, _excluded$1);
   var uid = ui.useUID(id);
   var labelID = "".concat(uid, "-label");
   var clearIconID = "".concat(uid, "-clear-icon");
   var inputRef = react.useRef(null);
   var textFieldRef = react.useRef(null);
   var [popoverAnchor, setPopoverAnchor] = react.useState(null);
-
   function handleOpen() {
     if (!disabled && textFieldRef.current) {
       setPopoverAnchor(textFieldRef.current);
     }
   }
-
   function handleClose() {
     setPopoverAnchor(null);
   }
-
   react.useImperativeHandle(api, () => ({
     close: handleClose
-  })); // We want to trigger close event only when UI will be ready after updates.
+  }));
 
+  // We want to trigger close event only when UI will be ready after updates.
   hooks.useValueObserver(popoverAnchor, () => {
     if (!popoverAnchor) {
       onClose === null || onClose === void 0 ? void 0 : onClose();
@@ -883,14 +842,12 @@ var BaseDatePicker = /*#__PURE__*/react.forwardRef((_ref, ref) => {
       inputRef: ui.mergeRefs(inputRef, inputRefProp),
       onClick: event => {
         _onClick === null || _onClick === void 0 ? void 0 : _onClick(event);
-
         if (!event.defaultPrevented) {
           handleOpen();
         }
       },
       onKeyDown: event => {
         _onKeyDown === null || _onKeyDown === void 0 ? void 0 : _onKeyDown(event);
-
         if (!event.defaultPrevented && (event.key === ' ' || event.key === 'Enter')) {
           handleOpen();
         }
@@ -929,14 +886,13 @@ var BaseDatePicker = /*#__PURE__*/react.forwardRef((_ref, ref) => {
 if (process.env.NODE_ENV !== "production") BaseDatePicker.displayName = "BaseDatePicker";
 
 var _excluded$2 = ["variant", "fallback"],
-    _excluded2 = ["date", "fallback"];
+  _excluded2 = ["date", "fallback"];
 function useFormattedDate(input, _ref) {
   var {
-    variant,
-    fallback
-  } = _ref,
-      dateConfig = _objectWithoutProperties(_ref, _excluded$2);
-
+      variant,
+      fallback
+    } = _ref,
+    dateConfig = _objectWithoutProperties(_ref, _excluded$2);
   var config = useDateConfig(dateConfig);
   var date = useDateTime(input, config);
   return react.useMemo(() => formatDate(date, {
@@ -946,11 +902,10 @@ function useFormattedDate(input, _ref) {
 }
 function FormattedDate(_ref2) {
   var {
-    date,
-    fallback = 'Invalid Date'
-  } = _ref2,
-      options = _objectWithoutProperties(_ref2, _excluded2);
-
+      date,
+      fallback = 'Invalid Date'
+    } = _ref2,
+    options = _objectWithoutProperties(_ref2, _excluded2);
   var formatted = useFormattedDate(date, _objectSpread(_objectSpread({}, options), {}, {
     fallback: ''
   }));
@@ -958,27 +913,26 @@ function FormattedDate(_ref2) {
 }
 
 var _excluded$3 = ["onDayClick"],
-    _excluded2$1 = ["onBlur", "onFocus", "onChange", "renderFooter", "renderQuickSelection", "value", "format", "fallback", "variant", "enableClearable", "disableCloseOnSelect", "CalendarProps"];
+  _excluded2$1 = ["onBlur", "onFocus", "onChange", "renderFooter", "renderQuickSelection", "value", "format", "fallback", "variant", "enableClearable", "disableCloseOnSelect", "CalendarProps"];
 var DateField = /*#__PURE__*/react.forwardRef((_ref, ref) => {
   var {
-    onBlur,
-    onFocus,
-    onChange,
-    renderFooter,
-    renderQuickSelection,
-    value: valueProp,
-    format: formatProp,
-    fallback = '',
-    variant = 'Date',
-    enableClearable,
-    disableCloseOnSelect,
-    CalendarProps: {
-      onDayClick: _onDayClick
-    } = {}
-  } = _ref,
-      calendarProps = _objectWithoutProperties(_ref.CalendarProps, _excluded$3),
-      textFieldProps = _objectWithoutProperties(_ref, _excluded2$1);
-
+      onBlur,
+      onFocus,
+      onChange,
+      renderFooter,
+      renderQuickSelection,
+      value: valueProp,
+      format: formatProp,
+      fallback = '',
+      variant = 'Date',
+      enableClearable,
+      disableCloseOnSelect,
+      CalendarProps: {
+        onDayClick: _onDayClick
+      } = {}
+    } = _ref,
+    calendarProps = _objectWithoutProperties(_ref.CalendarProps, _excluded$3),
+    textFieldProps = _objectWithoutProperties(_ref, _excluded2$1);
   var config = useDateConfig({
     format: formatProp
   });
@@ -989,23 +943,18 @@ var DateField = /*#__PURE__*/react.forwardRef((_ref, ref) => {
     fallback
   }, config));
   var dateString = react.useMemo(() => stringifyDate(date, config), [date, config]);
-
   function handleClose() {
     var _apiRef$current;
-
     (_apiRef$current = apiRef.current) === null || _apiRef$current === void 0 ? void 0 : _apiRef$current.close();
   }
-
   function handleChange(nextInput) {
     if (onChange) {
       onChange(toDatePayload(nextInput, config));
     }
-
     if (!disableCloseOnSelect) {
       handleClose();
     }
   }
-
   var api = {
     config,
     dateValue: date,
@@ -1034,7 +983,6 @@ var DateField = /*#__PURE__*/react.forwardRef((_ref, ref) => {
       },
       onDayClick: event => {
         _onDayClick === null || _onDayClick === void 0 ? void 0 : _onDayClick(event);
-
         if (!event.disabled) {
           handleChange(event.dateValue);
         }
@@ -1053,8 +1001,8 @@ function useDateTimeRange(input, options) {
 }
 
 var _excluded$4 = ["modifiers", "onDayClick", "onDayMouseEnter"],
-    _excluded2$2 = ["onBlur", "onFocus", "onChange", "renderFooter", "renderQuickSelection", "value", "format", "fallback", "enableClearable", "disableCloseOnSelect", "CalendarProps"],
-    _excluded3 = ["rangeStart", "rangeFinish"];
+  _excluded2$2 = ["onBlur", "onFocus", "onChange", "renderFooter", "renderQuickSelection", "value", "format", "fallback", "enableClearable", "disableCloseOnSelect", "CalendarProps"],
+  _excluded3 = ["rangeStart", "rangeFinish"];
 var useStyles$1 = /*#__PURE__*/styles.makeStyles(theme => ({
   rangeStart: {},
   rangeFinish: {},
@@ -1092,34 +1040,31 @@ var useStyles$1 = /*#__PURE__*/styles.makeStyles(theme => ({
 });
 var DateRangeField = /*#__PURE__*/react.forwardRef((_ref, ref) => {
   var {
-    onBlur,
-    onFocus,
-    onChange,
-    renderFooter,
-    renderQuickSelection,
-    value: valueProp,
-    format: formatProp,
-    fallback = '',
-    enableClearable,
-    disableCloseOnSelect,
-    CalendarProps: {
-      modifiers,
-      onDayClick: _onDayClick,
-      onDayMouseEnter: _onDayMouseEnter
-    } = {}
-  } = _ref,
-      calendarProps = _objectWithoutProperties(_ref.CalendarProps, _excluded$4),
-      textFieldProps = _objectWithoutProperties(_ref, _excluded2$2);
-
+      onBlur,
+      onFocus,
+      onChange,
+      renderFooter,
+      renderQuickSelection,
+      value: valueProp,
+      format: formatProp,
+      fallback = '',
+      enableClearable,
+      disableCloseOnSelect,
+      CalendarProps: {
+        modifiers,
+        onDayClick: _onDayClick,
+        onDayMouseEnter: _onDayMouseEnter
+      } = {}
+    } = _ref,
+    calendarProps = _objectWithoutProperties(_ref.CalendarProps, _excluded$4),
+    textFieldProps = _objectWithoutProperties(_ref, _excluded2$2);
   var apiRef = react.useRef(null);
-
   var _useStyles = useStyles$1({}),
-      {
-    rangeStart,
-    rangeFinish
-  } = _useStyles,
-      styles = _objectWithoutProperties(_useStyles, _excluded3);
-
+    {
+      rangeStart,
+      rangeFinish
+    } = _useStyles,
+    styles = _objectWithoutProperties(_useStyles, _excluded3);
   var config = useDateConfig({
     format: formatProp
   });
@@ -1133,18 +1078,13 @@ var DateRangeField = /*#__PURE__*/react.forwardRef((_ref, ref) => {
     var [nextCalendarStartDate, nextCalendarFinishDate] = parseDateRange([startDate, finishDate || hoveredDate], config);
     return [nextCalendarStartDate === null || nextCalendarStartDate === void 0 ? void 0 : nextCalendarStartDate.startOf('day'), nextCalendarFinishDate === null || nextCalendarFinishDate === void 0 ? void 0 : nextCalendarFinishDate.endOf('day')];
   }, [config, startDate, finishDate, hoveredDate]);
-
   function handleClose() {
     var _apiRef$current;
-
     (_apiRef$current = apiRef.current) === null || _apiRef$current === void 0 ? void 0 : _apiRef$current.close();
   }
-
   function handleChange(nextValue) {
     var _nextFinishDate;
-
     var [nextStartDate, nextFinishDate] = parseDateRange(nextValue, config);
-
     if (onChange) {
       if (nextStartDate) {
         if (startDate) {
@@ -1158,19 +1098,15 @@ var DateRangeField = /*#__PURE__*/react.forwardRef((_ref, ref) => {
           nextStartDate = nextStartDate.startOf('day');
         }
       }
-
       if (nextFinishDate) {
         nextFinishDate = nextFinishDate.endOf('day');
       }
-
       onChange(toDateRangePayload([nextStartDate, nextFinishDate], config));
     }
-
     if (!disableCloseOnSelect && (_nextFinishDate = nextFinishDate) !== null && _nextFinishDate !== void 0 && _nextFinishDate.isValid) {
       handleClose();
     }
   }
-
   var api = {
     config,
     close: handleClose,
@@ -1213,15 +1149,12 @@ var DateRangeField = /*#__PURE__*/react.forwardRef((_ref, ref) => {
         var {
           dateValue
         } = _ref4;
-
         if (calendarStartDate) {
           if (!calendarFinishDate) {
             return calendarStartDate.hasSame(dateValue, 'day');
           }
-
           return calendarStartDate <= dateValue && dateValue <= calendarFinishDate;
         }
-
         return false;
       },
       footer: renderFooter === null || renderFooter === void 0 ? void 0 : renderFooter(api),
@@ -1232,7 +1165,6 @@ var DateRangeField = /*#__PURE__*/react.forwardRef((_ref, ref) => {
       },
       onDayClick: event => {
         _onDayClick === null || _onDayClick === void 0 ? void 0 : _onDayClick(event);
-
         if (!event.disabled) {
           if (startDate && !finishDate) {
             handleChange([startDateString, event.stringValue]);
@@ -1250,69 +1182,88 @@ if (process.env.NODE_ENV !== "production") DateRangeField.displayName = "DateRan
 
 /** @deprecated */
 
+/** @deprecated */
+
+/** @deprecated */
+
+/** @deprecated */
+
+/** @deprecated */
+
+/** @deprecated */
+
+/** @deprecated */
+
+/** @deprecated */
+
+/** @deprecated */
+
+/** @deprecated */
 function toDateTime(value) {
   return typeof value === 'number' ? luxon.DateTime.fromMillis(value) : luxon.DateTime.fromJSDate(value);
 }
-/** @deprecated */
-
 
+/** @deprecated */
 function isDate(value) {
   return value != null && value instanceof Date;
 }
-/** @deprecated */
 
+/** @deprecated */
 function isDateLike(value) {
   return isDate(value) || typeof value === 'number' && Number.isInteger(value);
 }
-/** @deprecated */
 
+/** @deprecated */
 function isValidDate(value) {
   return isDate(value) && Number.isFinite(value.getTime());
 }
-/** @deprecated */
 
+/** @deprecated */
 function checkRange(range, validator) {
   if (!Array.isArray(range) || range.length > 2) {
     return false;
   }
-
   var [start, finish] = range;
   return (start == null || validator(start)) && (finish == null || validator(finish));
 }
-/** @deprecated */
-
 
+/** @deprecated */
 function isDateRange(range) {
   return checkRange(range, isDate);
 }
-/** @deprecated */
 
+/** @deprecated */
 function isDateRangeLike(range) {
   return checkRange(range, isDateLike);
 }
-/** @deprecated */
 
+/** @deprecated */
 function isValidDateRange(range) {
   return checkRange(range, isValidDate);
 }
-/** @deprecated */
 
+/** @deprecated */
 function toDate(value) {
   return !isDateLike(value) ? new Date(NaN) : new Date(value);
 }
-/** @deprecated */
 
+/** @deprecated */
 function toDateRange(range) {
   if (range == null || !isDateRangeLike(range)) {
     return [];
   }
-
   return range.filter(x => x != null).map(x => x == null ? undefined : toDate(x)).sort((a, b) => !isValidDate(a) ? -1 : !isValidDate(b) ? 1 : a.valueOf() - b.valueOf());
 }
+
+/** @deprecated */
+
 /** @deprecated */
 
 /** @deprecated */
 
+/** @deprecated */
+
+/** @deprecated */
 class DateUtils {
   /** @deprecated */
   toObject(value) {
@@ -1337,9 +1288,8 @@ class DateUtils {
       millisecond
     };
   }
-  /** @deprecated */
-
 
+  /** @deprecated */
   fromObject(_ref) {
     var {
       year = 0,
@@ -1350,11 +1300,9 @@ class DateUtils {
       second = 0,
       millisecond = 0
     } = _ref;
-
     if (Number.isNaN(year) || Number.isNaN(month) || Number.isNaN(day) || Number.isNaN(hour) || Number.isNaN(minute) || Number.isNaN(second) || Number.isNaN(millisecond)) {
       return new Date(NaN);
     }
-
     return luxon.DateTime.fromObject({
       year,
       month,
@@ -1365,15 +1313,13 @@ class DateUtils {
       millisecond
     }).toJSDate();
   }
-  /** @deprecated */
-
 
+  /** @deprecated */
   update(value, values) {
     return toDateTime(value).set(values).toJSDate();
   }
-  /** @deprecated */
-
 
+  /** @deprecated */
   mergeDateAndTime(date, time) {
     var {
       hour,
@@ -1381,11 +1327,9 @@ class DateUtils {
       second,
       millisecond
     } = this.toObject(time);
-
     if (Number.isNaN(hour) || Number.isNaN(minute) || Number.isNaN(second) || Number.isNaN(millisecond)) {
       return new Date(NaN);
     }
-
     return this.update(date, {
       hour,
       minute,
@@ -1393,73 +1337,61 @@ class DateUtils {
       millisecond
     });
   }
-  /** @deprecated */
-
 
+  /** @deprecated */
   startOf(value, unit) {
     return toDateTime(value).startOf(unit).toJSDate();
   }
-  /** @deprecated */
-
 
+  /** @deprecated */
   endOf(value, unit) {
     return toDateTime(value).endOf(unit).toJSDate();
   }
-  /** @deprecated */
-
 
+  /** @deprecated */
   plus(value, values) {
     return toDateTime(value).plus(values).toJSDate();
   }
-  /** @deprecated */
-
 
+  /** @deprecated */
   minus(value, values) {
     return toDateTime(value).minus(values).toJSDate();
   }
-  /** @deprecated */
-
 
+  /** @deprecated */
   isSameDate(value, compare) {
     var unit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'millisecond';
-
     if (value == null && compare == null) {
       return true;
     }
-
     if (value == null || compare == null) {
       return false;
     }
-
     var dateTimeValue = toDateTime(value);
     var dateTimeCompare = toDateTime(compare);
     return dateTimeValue.isValid && dateTimeCompare.isValid && dateTimeValue.startOf(unit).equals(dateTimeCompare.startOf(unit));
   }
-  /** @deprecated */
-
 
+  /** @deprecated */
   isSameDateRange(value, compare, unit) {
     var range1 = toDateRange(value);
     var range2 = toDateRange(compare);
     return !range1.some((date, idx) => !this.isSameDate(date, range2[idx], unit));
   }
-  /** @deprecated */
-
 
+  /** @deprecated */
   diff(value, compare, unit) {
     var valueDateTime = toDateTime(value);
     var compareDateTime = toDateTime(compare);
     return valueDateTime.diff(compareDateTime, unit).as(unit);
   }
-  /** @deprecated */
-
 
+  /** @deprecated */
   toLocaleString(value, options) {
     return toDateTime(value).toLocaleString(options);
   }
-  /** @deprecated */
-
 
+  /** @deprecated */
   format(value, variant) {
     return this.toLocaleString(value, variant === 'date' ? {
       day: '2-digit',
@@ -1479,30 +1411,24 @@ class DateUtils {
       minute: 'numeric'
     });
   }
-  /** @deprecated */
-
 
+  /** @deprecated */
   formatRange(value) {
     var emptyText = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
     var range = toDateRange(value);
-
     if (!isValidDateRange(range)) {
       return 'Invalid Date Range';
     }
-
     var [start, finish] = range;
-
     if (!start) {
       return emptyText;
     }
-
     var startText = this.format(start, !this.isSameDate(start, finish, 'year') ? 'date' : 'shortDate');
     var finishText = !finish ? '…' : this.format(finish, 'date');
     return "".concat(startText, " - ").concat(finishText);
   }
-  /** @deprecated */
-
 
+  /** @deprecated */
   formatRelativeTime(value) {
     var {
       style = 'long',
@@ -1515,25 +1441,23 @@ class DateUtils {
       base: compareDateTime
     });
   }
-
 }
 function useDateUtils() {
   return react.useMemo(() => new DateUtils(), []);
 }
 
 var _excluded$5 = ["unit", "round", "padding", "fallback", "base"],
-    _excluded2$3 = ["date", "fallback"];
+  _excluded2$3 = ["date", "fallback"];
 function useFormattedRelativeTime(input) {
   var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-      {
-    unit,
-    round,
-    padding,
-    fallback,
-    base: baseOption
-  } = _ref,
-      dateConfig = _objectWithoutProperties(_ref, _excluded$5);
-
+    {
+      unit,
+      round,
+      padding,
+      fallback,
+      base: baseOption
+    } = _ref,
+    dateConfig = _objectWithoutProperties(_ref, _excluded$5);
   var config = useDateConfig(dateConfig);
   var date = useDateTime(input, config);
   var baseOptionDate = useDateTime(baseOption, config);
@@ -1548,11 +1472,10 @@ function useFormattedRelativeTime(input) {
 }
 function FormattedRelativeTime(_ref2) {
   var {
-    date,
-    fallback = 'Invalid Date'
-  } = _ref2,
-      options = _objectWithoutProperties(_ref2, _excluded2$3);
-
+      date,
+      fallback = 'Invalid Date'
+    } = _ref2,
+    options = _objectWithoutProperties(_ref2, _excluded2$3);
   var formatted = useFormattedRelativeTime(date, _objectSpread(_objectSpread({}, options), {}, {
     fallback: ''
   }));
@@ -1561,7 +1484,6 @@ function FormattedRelativeTime(_ref2) {
 
 var _excluded$6 = ["disabled", "onChange", "value", "format"];
 var TIME_MATCH_FORMATS = ['h:mm a', 'h:mma', 'H:mm', 'h:mm', 'hmm', 'Hmm', 'h', 'H'];
-
 function toTimeFieldOption(date, config) {
   return {
     value: date.valueOf(),
@@ -1571,52 +1493,42 @@ function toTimeFieldOption(date, config) {
     pattern: new RegExp("^(".concat(TIME_MATCH_FORMATS.map(format => date.toFormat(format)).join('|'), ")"), 'i')
   };
 }
-
 function normalizeInputValue(inputValue) {
   return inputValue.replace(/[\s]/g, '').toLowerCase();
 }
-
 function makeOptions(config) {
   var options = [];
   var now = luxon.DateTime.local().startOf('day');
-
   for (var i = 0; i < 96; i++) {
     options.push(toTimeFieldOption(now.set({
       minute: i * 15
     }), config));
   }
-
   var cache = new Map();
   return [options, (_, _ref) => {
     var {
       inputValue
     } = _ref;
     var query = normalizeInputValue(inputValue);
-
     if (!query) {
       return options;
     }
-
     var filtered = cache.get(query);
-
     if (!filtered) {
       filtered = options.filter(option => option.pattern.test(query));
       cache.set(query, filtered);
     }
-
     return filtered;
   }];
 }
-
 var TimeField = /*#__PURE__*/react.forwardRef((_ref2, ref) => {
   var {
-    disabled,
-    onChange,
-    value: valueProp,
-    format: formatProp
-  } = _ref2,
-      props = _objectWithoutProperties(_ref2, _excluded$6);
-
+      disabled,
+      onChange,
+      value: valueProp,
+      format: formatProp
+    } = _ref2,
+    props = _objectWithoutProperties(_ref2, _excluded$6);
   var config = useDateConfig({
     format: formatProp
   });
@@ -1624,19 +1536,15 @@ var TimeField = /*#__PURE__*/react.forwardRef((_ref2, ref) => {
   var selectedOption = react.useMemo(() => !date.isValid ? undefined : toTimeFieldOption(date, config), [date, config]);
   var [options, filterOptions] = react.useMemo(() => makeOptions(config), [config]);
   var [inputValue, setInputValue] = react.useState('');
-
   function handleChange(nextValue) {
     if (onChange) {
       onChange(toDatePayload(nextValue, config));
     }
   }
-
   function handleType(text) {
     text = normalizeInputValue(text);
-
     for (var timeFormat of TIME_MATCH_FORMATS) {
       var nextDate = luxon.DateTime.fromFormat(text, timeFormat);
-
       if (nextDate.isValid) {
         if (onChange) {
           if (date.isValid) {
@@ -1646,17 +1554,13 @@ var TimeField = /*#__PURE__*/react.forwardRef((_ref2, ref) => {
               day: date.day
             });
           }
-
           onChange(toDatePayload(nextDate, config));
         }
-
         return;
       }
     }
-
     setInputValue((selectedOption === null || selectedOption === void 0 ? void 0 : selectedOption.label) || '');
   }
-
   react.useEffect(() => {
     if (!date.isValid) {
       setInputValue('');