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

package/legacy/internals/hooks/useViews.js

@@ -0,0 +1,55 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+import { useControlled } from '@mui/material/utils';
+import { arrayIncludes } from '../utils/utils';
+export function useViews(_ref) {
+  var _views, _views2;
+
+  var onChange = _ref.onChange,
+      onViewChange = _ref.onViewChange,
+      openTo = _ref.openTo,
+      view = _ref.view,
+      views = _ref.views;
+
+  var _useControlled = useControlled({
+    name: 'Picker',
+    state: 'view',
+    controlled: view,
+    default: openTo && arrayIncludes(views, openTo) ? openTo : views[0]
+  }),
+      _useControlled2 = _slicedToArray(_useControlled, 2),
+      openView = _useControlled2[0],
+      setOpenView = _useControlled2[1];
+
+  var previousView = (_views = views[views.indexOf(openView) - 1]) != null ? _views : null;
+  var nextView = (_views2 = views[views.indexOf(openView) + 1]) != null ? _views2 : null;
+  var changeView = React.useCallback(function (newView) {
+    setOpenView(newView);
+
+    if (onViewChange) {
+      onViewChange(newView);
+    }
+  }, [setOpenView, onViewChange]);
+  var openNext = React.useCallback(function () {
+    if (nextView) {
+      changeView(nextView);
+    }
+  }, [nextView, changeView]);
+  var handleChangeAndOpenNext = React.useCallback(function (date, currentViewSelectionState) {
+    var isSelectionFinishedOnCurrentView = currentViewSelectionState === 'finish';
+    var globalSelectionState = isSelectionFinishedOnCurrentView && Boolean(nextView) ? 'partial' : currentViewSelectionState;
+    onChange(date, globalSelectionState);
+
+    if (isSelectionFinishedOnCurrentView) {
+      openNext();
+    }
+  }, [nextView, onChange, openNext]);
+  return {
+    handleChangeAndOpenNext: handleChangeAndOpenNext,
+    nextView: nextView,
+    previousView: previousView,
+    openNext: openNext,
+    openView: openView,
+    setOpenView: changeView
+  };
+}

package/legacy/internals/hooks/validation/useDateTimeValidation.js

@@ -0,0 +1,35 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["minDate", "maxDate", "disableFuture", "shouldDisableDate", "disablePast"];
+import { useValidation } from './useValidation';
+import { validateDate } from './useDateValidation';
+import { validateTime } from './useTimeValidation';
+export var validateDateTime = function validateDateTime(utils, value, _ref) {
+  var minDate = _ref.minDate,
+      maxDate = _ref.maxDate,
+      disableFuture = _ref.disableFuture,
+      shouldDisableDate = _ref.shouldDisableDate,
+      disablePast = _ref.disablePast,
+      timeValidationProps = _objectWithoutProperties(_ref, _excluded);
+
+  var dateValidationResult = validateDate(utils, value, {
+    minDate: minDate,
+    maxDate: maxDate,
+    disableFuture: disableFuture,
+    shouldDisableDate: shouldDisableDate,
+    disablePast: disablePast
+  });
+
+  if (dateValidationResult !== null) {
+    return dateValidationResult;
+  }
+
+  return validateTime(utils, value, timeValidationProps);
+};
+
+var isSameDateTimeError = function isSameDateTimeError(a, b) {
+  return a === b;
+};
+
+export function useDateTimeValidation(props) {
+  return useValidation(props, validateDateTime, isSameDateTimeError);
+}

package/legacy/internals/hooks/validation/useDateValidation.js

@@ -0,0 +1,45 @@
+import { useValidation } from './useValidation';
+export var validateDate = function validateDate(utils, value, _ref) {
+  var disablePast = _ref.disablePast,
+      disableFuture = _ref.disableFuture,
+      minDate = _ref.minDate,
+      maxDate = _ref.maxDate,
+      shouldDisableDate = _ref.shouldDisableDate;
+  var now = utils.date();
+  var date = utils.date(value);
+
+  if (date === null) {
+    return null;
+  }
+
+  switch (true) {
+    case !utils.isValid(value):
+      return 'invalidDate';
+
+    case Boolean(shouldDisableDate && shouldDisableDate(date)):
+      return 'shouldDisableDate';
+
+    case Boolean(disableFuture && utils.isAfterDay(date, now)):
+      return 'disableFuture';
+
+    case Boolean(disablePast && utils.isBeforeDay(date, now)):
+      return 'disablePast';
+
+    case Boolean(minDate && utils.isBeforeDay(date, minDate)):
+      return 'minDate';
+
+    case Boolean(maxDate && utils.isAfterDay(date, maxDate)):
+      return 'maxDate';
+
+    default:
+      return null;
+  }
+};
+
+var isSameDateError = function isSameDateError(a, b) {
+  return a === b;
+};
+
+export var useDateValidation = function useDateValidation(props) {
+  return useValidation(props, validateDate, isSameDateError);
+};

package/legacy/internals/hooks/validation/useTimeValidation.js

@@ -0,0 +1,45 @@
+import { createIsAfterIgnoreDatePart } from '../../utils/time-utils';
+import { useValidation } from './useValidation';
+export var validateTime = function validateTime(utils, value, _ref) {
+  var minTime = _ref.minTime,
+      maxTime = _ref.maxTime,
+      shouldDisableTime = _ref.shouldDisableTime,
+      disableIgnoringDatePartForTimeValidation = _ref.disableIgnoringDatePartForTimeValidation;
+  var date = utils.date(value);
+  var isAfterComparingFn = createIsAfterIgnoreDatePart(Boolean(disableIgnoringDatePartForTimeValidation), utils);
+
+  if (value === null) {
+    return null;
+  }
+
+  switch (true) {
+    case !utils.isValid(value):
+      return 'invalidDate';
+
+    case Boolean(minTime && isAfterComparingFn(minTime, date)):
+      return 'minTime';
+
+    case Boolean(maxTime && isAfterComparingFn(date, maxTime)):
+      return 'maxTime';
+
+    case Boolean(shouldDisableTime && shouldDisableTime(utils.getHours(date), 'hours')):
+      return 'shouldDisableTime-hours';
+
+    case Boolean(shouldDisableTime && shouldDisableTime(utils.getMinutes(date), 'minutes')):
+      return 'shouldDisableTime-minutes';
+
+    case Boolean(shouldDisableTime && shouldDisableTime(utils.getSeconds(date), 'seconds')):
+      return 'shouldDisableTime-seconds';
+
+    default:
+      return null;
+  }
+};
+
+var isSameTimeError = function isSameTimeError(a, b) {
+  return a === b;
+};
+
+export var useTimeValidation = function useTimeValidation(props) {
+  return useValidation(props, validateTime, isSameTimeError);
+};

package/legacy/internals/hooks/validation/useValidation.js

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { useUtils } from '../useUtils';
+export function useValidation(props, validate, isSameError) {
+  var value = props.value,
+      onError = props.onError;
+  var utils = useUtils();
+  var previousValidationErrorRef = React.useRef(null);
+  var validationError = validate(utils, value, props);
+  React.useEffect(function () {
+    if (onError && !isSameError(validationError, previousValidationErrorRef.current)) {
+      onError(validationError, value);
+    }
+
+    previousValidationErrorRef.current = validationError;
+  }, [isSameError, onError, previousValidationErrorRef, validationError, value]);
+  return validationError;
+}

package/legacy/internals/index.js

@@ -0,0 +1,22 @@
+export { DesktopTooltipWrapper } from './components/wrappers/DesktopTooltipWrapper';
+export { MobileWrapper } from './components/wrappers/MobileWrapper';
+export { MobileKeyboardInputView } from './components/CalendarOrClockPicker/CalendarOrClockPicker';
+export { PickersArrowSwitcher } from './components/PickersArrowSwitcher';
+export { PickerStaticWrapper } from './components/PickerStaticWrapper/PickerStaticWrapper';
+export { PickersToolbar } from './components/PickersToolbar';
+export { PickersToolbarButton } from './components/PickersToolbarButton';
+export { ResponsiveTooltipWrapper } from './components/wrappers/ResponsiveWrapper';
+export { WrapperVariantContext } from './components/wrappers/WrapperVariantContext';
+export { DAY_MARGIN } from './constants/dimensions';
+export { useMaskedInput } from './hooks/useMaskedInput';
+export { usePickerState } from './hooks/usePickerState';
+export { useDefaultDates, useUtils } from './hooks/useUtils';
+export { useValidation } from './hooks/validation/useValidation';
+export { validateDate } from './hooks/validation/useDateValidation';
+export { usePreviousMonthDisabled, useNextMonthDisabled } from './hooks/date-helpers-hooks';
+export { executeInTheNextEventLoopTick } from './utils/utils';
+export { defaultReduceAnimations } from './utils/defaultReduceAnimations';
+export { PickersCalendarHeader } from '../CalendarPicker/PickersCalendarHeader';
+export { DayPicker } from '../CalendarPicker/DayPicker';
+export { areDayPropsEqual } from '../PickersDay/PickersDay';
+export { useCalendarState } from '../CalendarPicker/useCalendarState';

package/legacy/internals/models/helpers.js

@@ -0,0 +1 @@
+export {};

package/legacy/internals/models/index.js

@@ -0,0 +1,2 @@
+export * from './views';
+export * from './muiPickersAdapter';

package/legacy/internals/models/muiPickersAdapter.js

@@ -0,0 +1 @@
+export {};

package/legacy/internals/models/parseableDate.js

@@ -0,0 +1 @@
+export {};

package/legacy/internals/models/props/basePickerProps.js

@@ -0,0 +1 @@
+export {};

package/legacy/internals/models/props/baseToolbarProps.js

@@ -0,0 +1 @@
+export {};

package/legacy/internals/models/views.js

@@ -0,0 +1 @@
+export {};

package/legacy/internals/utils/date-utils.js

@@ -0,0 +1,66 @@
+export var findClosestEnabledDate = function findClosestEnabledDate(_ref) {
+  var date = _ref.date,
+      disableFuture = _ref.disableFuture,
+      disablePast = _ref.disablePast,
+      maxDate = _ref.maxDate,
+      minDate = _ref.minDate,
+      shouldDisableDate = _ref.shouldDisableDate,
+      utils = _ref.utils;
+  var today = utils.startOfDay(utils.date());
+
+  if (disablePast && utils.isBefore(minDate, today)) {
+    minDate = today;
+  }
+
+  if (disableFuture && utils.isAfter(maxDate, today)) {
+    maxDate = today;
+  }
+
+  var forward = date;
+  var backward = date;
+
+  if (utils.isBefore(date, minDate)) {
+    forward = utils.date(minDate);
+    backward = null;
+  }
+
+  if (utils.isAfter(date, maxDate)) {
+    if (backward) {
+      backward = utils.date(maxDate);
+    }
+
+    forward = null;
+  }
+
+  while (forward || backward) {
+    if (forward && utils.isAfter(forward, maxDate)) {
+      forward = null;
+    }
+
+    if (backward && utils.isBefore(backward, minDate)) {
+      backward = null;
+    }
+
+    if (forward) {
+      if (!shouldDisableDate(forward)) {
+        return forward;
+      }
+
+      forward = utils.addDays(forward, 1);
+    }
+
+    if (backward) {
+      if (!shouldDisableDate(backward)) {
+        return backward;
+      }
+
+      backward = utils.addDays(backward, -1);
+    }
+  }
+
+  return today;
+};
+export var parsePickerInputValue = function parsePickerInputValue(utils, value) {
+  var parsedValue = utils.date(value);
+  return utils.isValid(parsedValue) ? parsedValue : null;
+};

package/legacy/internals/utils/defaultReduceAnimations.js

@@ -0,0 +1 @@
+export var defaultReduceAnimations = typeof navigator !== 'undefined' && /(android)/i.test(navigator.userAgent);

package/legacy/internals/utils/text-field-helper.js

@@ -0,0 +1,68 @@
+export function getTextFieldAriaText(rawValue, utils) {
+  // TODO: should `isValid` narrow `TDate | null` to `NonNullable<TDate>`?
+  // Either we allow `TDate | null` to be valid and guard against calling `formatByString` with `null`.
+  // Or we ensure `formatByString` is callable with `null`.
+  return rawValue && utils.isValid(utils.date(rawValue)) ? "Choose date, selected date is ".concat(utils.format(utils.date(rawValue), 'fullDate')) : 'Choose date';
+}
+export var getDisplayDate = function getDisplayDate(utils, value, inputFormat) {
+  var date = utils.date(value);
+  var isEmpty = value === null;
+
+  if (isEmpty) {
+    return '';
+  }
+
+  return utils.isValid(date) ? utils.formatByString( // TODO: should `isValid` narrow `TDate | null` to `NonNullable<TDate>`?
+  // Either we allow `TDate | null` to be valid and guard against calling `formatByString` with `null`.
+  // Or we ensure `formatByString` is callable with `null`.
+  date, inputFormat) : '';
+};
+export function pick12hOr24hFormat(userFormat, ampm, formats) {
+  if (userFormat) {
+    return userFormat;
+  }
+
+  if (typeof ampm === 'undefined') {
+    return formats.localized;
+  }
+
+  return ampm ? formats['12h'] : formats['24h'];
+}
+var MASK_USER_INPUT_SYMBOL = '_';
+var staticDateWith2DigitTokens = '2019-11-21T22:30:00.000';
+var staticDateWith1DigitTokens = '2019-01-01T09:00:00.000';
+export function checkMaskIsValidForCurrentFormat(mask, format, acceptRegex, utils) {
+  var formattedDateWith1Digit = utils.formatByString(utils.date(staticDateWith1DigitTokens), format);
+  var inferredFormatPatternWith1Digits = formattedDateWith1Digit.replace(acceptRegex, MASK_USER_INPUT_SYMBOL);
+  var inferredFormatPatternWith2Digits = utils.formatByString(utils.date(staticDateWith2DigitTokens), format).replace(acceptRegex, '_');
+  var isMaskValid = inferredFormatPatternWith2Digits === mask && inferredFormatPatternWith1Digits === mask;
+
+  if (!isMaskValid && utils.lib !== 'luxon' && process.env.NODE_ENV !== 'production') {
+    console.warn("The mask \"".concat(mask, "\" you passed is not valid for the format used ").concat(format, ". Falling down to uncontrolled not-masked input."));
+  }
+
+  return isMaskValid;
+}
+export var maskedDateFormatter = function maskedDateFormatter(mask, acceptRegexp) {
+  return function (value) {
+    return value.split('').map(function (char, i) {
+      acceptRegexp.lastIndex = 0;
+
+      if (i > mask.length - 1) {
+        return '';
+      }
+
+      var maskChar = mask[i];
+      var nextMaskChar = mask[i + 1];
+      var acceptedChar = acceptRegexp.test(char) ? char : '';
+      var formattedChar = maskChar === MASK_USER_INPUT_SYMBOL ? acceptedChar : maskChar + acceptedChar;
+
+      if (i === value.length - 1 && nextMaskChar && nextMaskChar !== MASK_USER_INPUT_SYMBOL) {
+        // when cursor at the end of mask part (e.g. month) prerender next symbol "21" -> "21/"
+        return formattedChar ? formattedChar + nextMaskChar : '';
+      }
+
+      return formattedChar;
+    }).join('');
+  };
+};

package/legacy/internals/utils/time-utils.js

@@ -0,0 +1,34 @@
+export var getMeridiem = function getMeridiem(date, utils) {
+  if (!date) {
+    return null;
+  }
+
+  return utils.getHours(date) >= 12 ? 'pm' : 'am';
+};
+export var convertValueToMeridiem = function convertValueToMeridiem(value, meridiem, ampm) {
+  if (ampm) {
+    var currentMeridiem = value >= 12 ? 'pm' : 'am';
+
+    if (currentMeridiem !== meridiem) {
+      return meridiem === 'am' ? value - 12 : value + 12;
+    }
+  }
+
+  return value;
+};
+export var convertToMeridiem = function convertToMeridiem(time, meridiem, ampm, utils) {
+  var newHoursAmount = convertValueToMeridiem(utils.getHours(time), meridiem, ampm);
+  return utils.setHours(time, newHoursAmount);
+};
+export var getSecondsInDay = function getSecondsInDay(date, utils) {
+  return utils.getHours(date) * 3600 + utils.getMinutes(date) * 60 + utils.getSeconds(date);
+};
+export var createIsAfterIgnoreDatePart = function createIsAfterIgnoreDatePart(disableIgnoringDatePartForTimeValidation, utils) {
+  return function (dateLeft, dateRight) {
+    if (disableIgnoringDatePartForTimeValidation) {
+      return utils.isAfter(dateLeft, dateRight);
+    }
+
+    return getSecondsInDay(dateLeft, utils) > getSecondsInDay(dateRight, utils);
+  };
+};

package/legacy/internals/utils/utils.js

@@ -0,0 +1,52 @@
+/* Use it instead of .includes method for IE support */
+export function arrayIncludes(array, itemOrItems) {
+  if (Array.isArray(itemOrItems)) {
+    return itemOrItems.every(function (item) {
+      return array.indexOf(item) !== -1;
+    });
+  }
+
+  return array.indexOf(itemOrItems) !== -1;
+}
+export var onSpaceOrEnter = function onSpaceOrEnter(innerFn, onFocus) {
+  return function (event) {
+    if (event.key === 'Enter' || event.key === ' ') {
+      innerFn(); // prevent any side effects
+
+      event.preventDefault();
+      event.stopPropagation();
+    }
+
+    if (onFocus) {
+      onFocus(event);
+    }
+  };
+};
+/* Quick untyped helper to improve function composition readability */
+
+export var pipe = function pipe() {
+  for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {
+    fns[_key] = arguments[_key];
+  }
+
+  return fns.reduceRight(function (prevFn, nextFn) {
+    return function () {
+      return nextFn(prevFn.apply(void 0, arguments));
+    };
+  }, function (value) {
+    return value;
+  });
+};
+export var executeInTheNextEventLoopTick = function executeInTheNextEventLoopTick(fn) {
+  setTimeout(fn, 0);
+};
+export function createDelegatedEventHandler(fn, onEvent) {
+  return function (event) {
+    fn(event);
+
+    if (onEvent) {
+      onEvent(event);
+    }
+  };
+}
+export var doNothing = function doNothing() {};

package/legacy/themeAugmentation/index.js

@@ -0,0 +1,3 @@
+export * from './overrides';
+export * from './props';
+export * from './components';

package/modern/AdapterDateFns/index.js

@@ -0,0 +1 @@
+export { default as AdapterDateFns } from '@date-io/date-fns';

package/modern/AdapterDayjs/index.js

@@ -0,0 +1 @@
+export { default as AdapterDayjs } from '@date-io/dayjs';

package/modern/AdapterLuxon/index.js

@@ -0,0 +1 @@
+export { default as AdapterLuxon } from '@date-io/luxon';

package/modern/AdapterMoment/index.js

@@ -0,0 +1 @@
+export { default as AdapterMoment } from '@date-io/moment';