@mui/x-date-pickers-pro 5.0.0-alpha.0

package/node/DateRangePicker/DateRangePickerToolbar.js

@@ -0,0 +1,79 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DateRangePickerToolbar = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _Typography = _interopRequireDefault(require("@mui/material/Typography"));
+
+var _styles = require("@mui/material/styles");
+
+var _material = require("@mui/material");
+
+var _internals = require("@mui/x-date-pickers/internals");
+
+var _jsxRuntime = require("react/jsx-runtime");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const classes = (0, _material.generateUtilityClasses)('PrivateDateRangePickerToolbar', ['penIcon']);
+const DateRangePickerToolbarRoot = (0, _styles.styled)(_internals.PickersToolbar)({
+  [`& .${classes.penIcon}`]: {
+    position: 'relative',
+    top: 4
+  }
+});
+const DateRangePickerToolbarContainer = (0, _styles.styled)('div')({
+  display: 'flex'
+});
+/**
+ * @ignore - internal component.
+ */
+
+const DateRangePickerToolbar = ({
+  currentlySelectingRangeEnd,
+  date: [start, end],
+  endText,
+  isMobileKeyboardViewOpen,
+  setCurrentlySelectingRangeEnd,
+  startText,
+  toggleMobileKeyboardView,
+  toolbarFormat,
+  toolbarTitle = 'Select date range'
+}) => {
+  const utils = (0, _internals.useUtils)();
+  const startDateValue = start ? utils.formatByString(start, toolbarFormat || utils.formats.shortDate) : startText;
+  const endDateValue = end ? utils.formatByString(end, toolbarFormat || utils.formats.shortDate) : endText;
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(DateRangePickerToolbarRoot, {
+    toolbarTitle: toolbarTitle,
+    isMobileKeyboardViewOpen: isMobileKeyboardViewOpen,
+    toggleMobileKeyboardView: toggleMobileKeyboardView,
+    isLandscape: false,
+    penIconClassName: classes.penIcon,
+    children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(DateRangePickerToolbarContainer, {
+      children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_internals.PickersToolbarButton, {
+        variant: start !== null ? 'h5' : 'h6',
+        value: startDateValue,
+        selected: currentlySelectingRangeEnd === 'start',
+        onClick: () => setCurrentlySelectingRangeEnd('start')
+      }), /*#__PURE__*/(0, _jsxRuntime.jsxs)(_Typography.default, {
+        variant: "h5",
+        children: ["\xA0", '–', "\xA0"]
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_internals.PickersToolbarButton, {
+        variant: end !== null ? 'h5' : 'h6',
+        value: endDateValue,
+        selected: currentlySelectingRangeEnd === 'end',
+        onClick: () => setCurrentlySelectingRangeEnd('end')
+      })]
+    })
+  });
+};
+
+exports.DateRangePickerToolbar = DateRangePickerToolbar;

package/node/DateRangePicker/DateRangePickerView.js

@@ -0,0 +1,206 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DateRangePickerView = DateRangePickerView;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _xLicensePro = require("@mui/x-license-pro");
+
+var _internals = require("@mui/x-date-pickers/internals");
+
+var _dateUtils = require("../internal/utils/date-utils");
+
+var _dateRangeManager = require("./date-range-manager");
+
+var _DateRangePickerToolbar = require("./DateRangePickerToolbar");
+
+var _DateRangePickerViewMobile = require("./DateRangePickerViewMobile");
+
+var _DateRangePickerInput = require("./DateRangePickerInput");
+
+var _DateRangePickerViewDesktop = require("./DateRangePickerViewDesktop");
+
+var _releaseInfo = require("../internal/utils/releaseInfo");
+
+var _jsxRuntime = require("react/jsx-runtime");
+
+const _excluded = ["calendars", "className", "currentlySelectingRangeEnd", "date", "DateInputProps", "defaultCalendarMonth", "disableAutoMonthSwitching", "disableFuture", "disableHighlightToday", "disablePast", "endText", "isMobileKeyboardViewOpen", "maxDate", "minDate", "onDateChange", "onMonthChange", "open", "reduceAnimations", "setCurrentlySelectingRangeEnd", "shouldDisableDate", "showToolbar", "startText", "toggleMobileKeyboardView", "toolbarFormat", "toolbarTitle"];
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const releaseInfo = (0, _releaseInfo.getReleaseInfo)();
+
+/**
+ * @ignore - internal component.
+ */
+function DateRangePickerView(props) {
+  const {
+    calendars,
+    className,
+    currentlySelectingRangeEnd,
+    date,
+    DateInputProps,
+    defaultCalendarMonth,
+    disableAutoMonthSwitching = false,
+    disableFuture,
+    disableHighlightToday,
+    disablePast,
+    endText,
+    isMobileKeyboardViewOpen,
+    maxDate,
+    minDate,
+    onDateChange,
+    onMonthChange,
+    open,
+    reduceAnimations = _internals.defaultReduceAnimations,
+    setCurrentlySelectingRangeEnd,
+    shouldDisableDate,
+    showToolbar,
+    startText,
+    toggleMobileKeyboardView,
+    toolbarFormat,
+    toolbarTitle
+  } = props,
+        other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
+  const utils = (0, _internals.useUtils)();
+  const wrapperVariant = React.useContext(_internals.WrapperVariantContext);
+  const [start, end] = date;
+  const {
+    changeMonth,
+    calendarState,
+    isDateDisabled,
+    onMonthSwitchingAnimationEnd,
+    changeFocusedDay
+  } = (0, _internals.useCalendarState)({
+    date: start || end,
+    defaultCalendarMonth,
+    disableFuture,
+    disablePast,
+    disableSwitchToMonthOnDayFocus: true,
+    maxDate,
+    minDate,
+    onMonthChange,
+    reduceAnimations,
+    shouldDisableDate
+  });
+  const toShowToolbar = showToolbar != null ? showToolbar : wrapperVariant !== 'desktop';
+
+  const scrollToDayIfNeeded = day => {
+    if (!day || !utils.isValid(day) || isDateDisabled(day)) {
+      return;
+    }
+
+    const currentlySelectedDate = currentlySelectingRangeEnd === 'start' ? start : end;
+
+    if (currentlySelectedDate === null) {
+      // do not scroll if one of ages is not selected
+      return;
+    }
+
+    const displayingMonthRange = wrapperVariant === 'mobile' ? 0 : calendars - 1;
+    const currentMonthNumber = utils.getMonth(calendarState.currentMonth);
+    const requestedMonthNumber = utils.getMonth(day);
+
+    if (!utils.isSameYear(calendarState.currentMonth, day) || requestedMonthNumber < currentMonthNumber || requestedMonthNumber > currentMonthNumber + displayingMonthRange) {
+      const newMonth = currentlySelectingRangeEnd === 'start' ? currentlySelectedDate : // If need to focus end, scroll to the state when "end" is displaying in the last calendar
+      utils.addMonths(currentlySelectedDate, -displayingMonthRange);
+      changeMonth(newMonth);
+    }
+  };
+
+  React.useEffect(() => {
+    if (disableAutoMonthSwitching || !open) {
+      return;
+    }
+
+    scrollToDayIfNeeded(currentlySelectingRangeEnd === 'start' ? start : end);
+  }, [currentlySelectingRangeEnd, date]); // eslint-disable-line
+
+  const handleChange = React.useCallback(newDate => {
+    const {
+      nextSelection,
+      newRange
+    } = (0, _dateRangeManager.calculateRangeChange)({
+      newDate,
+      utils,
+      range: date,
+      currentlySelectingRangeEnd
+    });
+    setCurrentlySelectingRangeEnd(nextSelection);
+    const isFullRangeSelected = currentlySelectingRangeEnd === 'end' && (0, _dateUtils.isRangeValid)(utils, newRange);
+    onDateChange(newRange, wrapperVariant, isFullRangeSelected ? 'finish' : 'partial');
+  }, [currentlySelectingRangeEnd, date, onDateChange, setCurrentlySelectingRangeEnd, utils, wrapperVariant]);
+
+  const renderView = () => {
+    const sharedCalendarProps = (0, _extends2.default)({
+      date,
+      isDateDisabled,
+      changeFocusedDay,
+      onChange: handleChange,
+      reduceAnimations,
+      disableHighlightToday,
+      onMonthSwitchingAnimationEnd,
+      changeMonth,
+      currentlySelectingRangeEnd,
+      disableFuture,
+      disablePast,
+      minDate,
+      maxDate
+    }, calendarState, other);
+
+    switch (wrapperVariant) {
+      case 'desktop':
+        {
+          return /*#__PURE__*/(0, _jsxRuntime.jsx)(_DateRangePickerViewDesktop.DateRangePickerViewDesktop, (0, _extends2.default)({
+            calendars: calendars
+          }, sharedCalendarProps));
+        }
+
+      default:
+        {
+          return /*#__PURE__*/(0, _jsxRuntime.jsx)(_DateRangePickerViewMobile.DateRangePickerViewMobile, (0, _extends2.default)({}, sharedCalendarProps));
+        }
+    }
+  };
+
+  return /*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
+    className: className,
+    children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_xLicensePro.Watermark, {
+      packageName: "x-date-pickers-pro",
+      releaseInfo: releaseInfo
+    }), toShowToolbar && /*#__PURE__*/(0, _jsxRuntime.jsx)(_DateRangePickerToolbar.DateRangePickerToolbar, {
+      date: date,
+      isMobileKeyboardViewOpen: isMobileKeyboardViewOpen,
+      toggleMobileKeyboardView: toggleMobileKeyboardView,
+      currentlySelectingRangeEnd: currentlySelectingRangeEnd,
+      setCurrentlySelectingRangeEnd: setCurrentlySelectingRangeEnd,
+      startText: startText,
+      endText: endText,
+      toolbarTitle: toolbarTitle,
+      toolbarFormat: toolbarFormat
+    }), isMobileKeyboardViewOpen ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_internals.MobileKeyboardInputView, {
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_DateRangePickerInput.DateRangePickerInput, (0, _extends2.default)({
+        disableOpenPicker: true,
+        ignoreInvalidInputs: true
+      }, DateInputProps))
+    }) : renderView()]
+  });
+}
+
+process.env.NODE_ENV !== "production" ? DateRangePickerView.propTypes = {
+  calendars: _propTypes.default.oneOf([1, 2, 3]),
+  disableAutoMonthSwitching: _propTypes.default.bool
+} : void 0;

package/node/DateRangePicker/DateRangePickerViewDesktop.js

@@ -0,0 +1,175 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DateRangePickerViewDesktop = DateRangePickerViewDesktop;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _styles = require("@mui/material/styles");
+
+var _internals = require("@mui/x-date-pickers/internals");
+
+var _dateRangeManager = require("./date-range-manager");
+
+var _DateRangePickerDay = require("../DateRangePickerDay");
+
+var _dateUtils = require("../internal/utils/date-utils");
+
+var _utils = require("../internal/utils/utils");
+
+var _jsxRuntime = require("react/jsx-runtime");
+
+const _excluded = ["calendars", "changeMonth", "components", "componentsProps", "currentlySelectingRangeEnd", "currentMonth", "date", "disableFuture", "disablePast", "leftArrowButtonText", "maxDate", "minDate", "onChange", "renderDay", "rightArrowButtonText"];
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const DateRangePickerViewDesktopRoot = (0, _styles.styled)('div')({
+  display: 'flex',
+  flexDirection: 'row'
+});
+const DateRangePickerViewDesktopContainer = (0, _styles.styled)('div')(({
+  theme
+}) => ({
+  '&:not(:last-of-type)': {
+    borderRight: `2px solid ${theme.palette.divider}`
+  }
+}));
+const DateRangePickerViewDesktopCalendar = (0, _styles.styled)(_internals.DayPicker)({
+  minWidth: 312,
+  minHeight: 288
+});
+const DateRangePickerViewDesktopArrowSwitcher = (0, _styles.styled)(_internals.PickersArrowSwitcher)({
+  padding: '16px 16px 8px 16px',
+  display: 'flex',
+  alignItems: 'center',
+  justifyContent: 'space-between'
+});
+
+function getCalendarsArray(calendars) {
+  switch (calendars) {
+    case 1:
+      return [0];
+
+    case 2:
+      return [0, 0];
+
+    case 3:
+      return [0, 0, 0];
+    // this will not work in IE11, but allows to support any amount of calendars
+
+    default:
+      return new Array(calendars).fill(0);
+  }
+}
+/**
+ * @ignore - internal component.
+ */
+
+
+function DateRangePickerViewDesktop(props) {
+  const {
+    calendars,
+    changeMonth,
+    components,
+    componentsProps,
+    currentlySelectingRangeEnd,
+    currentMonth,
+    date,
+    disableFuture,
+    disablePast,
+    leftArrowButtonText = 'Previous month',
+    maxDate: maxDateProp,
+    minDate: minDateProp,
+    onChange,
+    renderDay = (_, dateRangeProps) => /*#__PURE__*/(0, _jsxRuntime.jsx)(_DateRangePickerDay.DateRangePickerDay, (0, _extends2.default)({}, dateRangeProps)),
+    rightArrowButtonText = 'Next month'
+  } = props,
+        other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
+  const utils = (0, _internals.useUtils)();
+  const defaultDates = (0, _internals.useDefaultDates)();
+  const minDate = minDateProp != null ? minDateProp : defaultDates.minDate;
+  const maxDate = maxDateProp != null ? maxDateProp : defaultDates.maxDate;
+  const [rangePreviewDay, setRangePreviewDay] = React.useState(null);
+  const isNextMonthDisabled = (0, _internals.useNextMonthDisabled)(currentMonth, {
+    disableFuture,
+    maxDate
+  });
+  const isPreviousMonthDisabled = (0, _internals.usePreviousMonthDisabled)(currentMonth, {
+    disablePast,
+    minDate
+  });
+  const previewingRange = (0, _dateRangeManager.calculateRangePreview)({
+    utils,
+    range: date,
+    newDate: rangePreviewDay,
+    currentlySelectingRangeEnd
+  });
+  const handleDayChange = React.useCallback(day => {
+    setRangePreviewDay(null);
+    onChange(day);
+  }, [onChange]);
+
+  const handlePreviewDayChange = newPreviewRequest => {
+    if (!(0, _dateUtils.isWithinRange)(utils, newPreviewRequest, date)) {
+      setRangePreviewDay(newPreviewRequest);
+    } else {
+      setRangePreviewDay(null);
+    }
+  };
+
+  const CalendarTransitionProps = React.useMemo(() => ({
+    onMouseLeave: () => setRangePreviewDay(null)
+  }), []);
+  const selectNextMonth = React.useCallback(() => {
+    changeMonth(utils.getNextMonth(currentMonth));
+  }, [changeMonth, currentMonth, utils]);
+  const selectPreviousMonth = React.useCallback(() => {
+    changeMonth(utils.getPreviousMonth(currentMonth));
+  }, [changeMonth, currentMonth, utils]);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(DateRangePickerViewDesktopRoot, {
+    children: getCalendarsArray(calendars).map((_, index) => {
+      const monthOnIteration = utils.setMonth(currentMonth, utils.getMonth(currentMonth) + index);
+      return /*#__PURE__*/(0, _jsxRuntime.jsxs)(DateRangePickerViewDesktopContainer, {
+        children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(DateRangePickerViewDesktopArrowSwitcher, {
+          onLeftClick: selectPreviousMonth,
+          onRightClick: selectNextMonth,
+          isLeftHidden: index !== 0,
+          isRightHidden: index !== calendars - 1,
+          isLeftDisabled: isPreviousMonthDisabled,
+          isRightDisabled: isNextMonthDisabled,
+          leftArrowButtonText: leftArrowButtonText,
+          components: components,
+          componentsProps: componentsProps,
+          rightArrowButtonText: rightArrowButtonText,
+          children: utils.format(monthOnIteration, 'monthAndYear')
+        }), /*#__PURE__*/(0, React.createElement)(DateRangePickerViewDesktopCalendar, (0, _extends2.default)({}, other, {
+          key: index,
+          date: date,
+          onFocusedDayChange: _utils.doNothing,
+          onChange: handleDayChange,
+          currentMonth: monthOnIteration,
+          TransitionProps: CalendarTransitionProps,
+          renderDay: (day, __, DayProps) => renderDay(day, (0, _extends2.default)({
+            isPreviewing: (0, _dateUtils.isWithinRange)(utils, day, previewingRange),
+            isStartOfPreviewing: (0, _dateUtils.isStartOfRange)(utils, day, previewingRange),
+            isEndOfPreviewing: (0, _dateUtils.isEndOfRange)(utils, day, previewingRange),
+            isHighlighting: (0, _dateUtils.isWithinRange)(utils, day, date),
+            isStartOfHighlighting: (0, _dateUtils.isStartOfRange)(utils, day, date),
+            isEndOfHighlighting: (0, _dateUtils.isEndOfRange)(utils, day, date),
+            onMouseEnter: () => handlePreviewDayChange(day)
+          }, DayProps))
+        }))]
+      }, index);
+    })
+  });
+}

package/node/DateRangePicker/DateRangePickerViewMobile.js

@@ -0,0 +1,80 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DateRangePickerViewMobile = DateRangePickerViewMobile;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _internals = require("@mui/x-date-pickers/internals");
+
+var _utils = require("../internal/utils/utils");
+
+var _DateRangePickerDay = require("../DateRangePickerDay");
+
+var _dateUtils = require("../internal/utils/date-utils");
+
+var _jsxRuntime = require("react/jsx-runtime");
+
+const _excluded = ["changeMonth", "components", "componentsProps", "date", "leftArrowButtonText", "maxDate", "minDate", "onChange", "renderDay", "rightArrowButtonText"];
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const onlyDayView = ['day'];
+/**
+ * @ignore - internal component.
+ */
+
+function DateRangePickerViewMobile(props) {
+  const {
+    changeMonth,
+    components,
+    componentsProps,
+    date,
+    leftArrowButtonText,
+    maxDate: maxDateProp,
+    minDate: minDateProp,
+    onChange,
+    renderDay = (_, dayProps) => /*#__PURE__*/(0, _jsxRuntime.jsx)(_DateRangePickerDay.DateRangePickerDay, (0, _extends2.default)({}, dayProps)),
+    rightArrowButtonText
+  } = props,
+        other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
+  const utils = (0, _internals.useUtils)();
+  const defaultDates = (0, _internals.useDefaultDates)();
+  const minDate = minDateProp != null ? minDateProp : defaultDates.minDate;
+  const maxDate = maxDateProp != null ? maxDateProp : defaultDates.maxDate;
+  return /*#__PURE__*/(0, _jsxRuntime.jsxs)(React.Fragment, {
+    children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_internals.PickersCalendarHeader, (0, _extends2.default)({
+      components: components,
+      componentsProps: componentsProps,
+      leftArrowButtonText: leftArrowButtonText,
+      maxDate: maxDate,
+      minDate: minDate,
+      onMonthChange: changeMonth,
+      openView: "day",
+      rightArrowButtonText: rightArrowButtonText,
+      views: onlyDayView
+    }, other)), /*#__PURE__*/(0, _jsxRuntime.jsx)(_internals.DayPicker, (0, _extends2.default)({}, other, {
+      date: date,
+      onChange: onChange,
+      onFocusedDayChange: _utils.doNothing,
+      renderDay: (day, _, DayProps) => renderDay(day, (0, _extends2.default)({
+        isPreviewing: false,
+        isStartOfPreviewing: false,
+        isEndOfPreviewing: false,
+        isHighlighting: (0, _dateUtils.isWithinRange)(utils, day, date),
+        isStartOfHighlighting: (0, _dateUtils.isStartOfRange)(utils, day, date),
+        isEndOfHighlighting: (0, _dateUtils.isEndOfRange)(utils, day, date)
+      }, DayProps))
+    }))]
+  });
+}

package/node/DateRangePicker/date-range-manager.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calculateRangeChange = calculateRangeChange;
+exports.calculateRangePreview = calculateRangePreview;
+
+function calculateRangeChange({
+  utils,
+  range,
+  newDate: selectedDate,
+  currentlySelectingRangeEnd
+}) {
+  const [start, end] = range;
+
+  if (currentlySelectingRangeEnd === 'start') {
+    return Boolean(end) && utils.isAfter(selectedDate, end) ? {
+      nextSelection: 'end',
+      newRange: [selectedDate, null]
+    } : {
+      nextSelection: 'end',
+      newRange: [selectedDate, end]
+    };
+  }
+
+  return Boolean(start) && utils.isBefore(selectedDate, start) ? {
+    nextSelection: 'end',
+    newRange: [selectedDate, null]
+  } : {
+    nextSelection: 'start',
+    newRange: [start, selectedDate]
+  };
+}
+
+function calculateRangePreview(options) {
+  if (!options.newDate) {
+    return [null, null];
+  }
+
+  const [start, end] = options.range;
+  const {
+    newRange
+  } = calculateRangeChange(options);
+
+  if (!start || !end) {
+    return newRange;
+  }
+
+  const [previewStart, previewEnd] = newRange;
+  return options.currentlySelectingRangeEnd === 'end' ? [end, previewEnd] : [previewStart, start];
+}

package/node/DateRangePicker/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "DateRangePicker", {
+  enumerable: true,
+  get: function () {
+    return _DateRangePicker.DateRangePicker;
+  }
+});
+
+var _DateRangePicker = require("./DateRangePicker");