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

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

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

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

@@ -0,0 +1,42 @@
+import { useValidation } from './useValidation';
+export const validateDate = (utils, value, {
+  disablePast,
+  disableFuture,
+  minDate,
+  maxDate,
+  shouldDisableDate
+}) => {
+  const now = utils.date();
+  const 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;
+  }
+};
+
+const isSameDateError = (a, b) => a === b;
+
+export const useDateValidation = props => useValidation(props, validateDate, isSameDateError);

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

@@ -0,0 +1,42 @@
+import { createIsAfterIgnoreDatePart } from '../../utils/time-utils';
+import { useValidation } from './useValidation';
+export const validateTime = (utils, value, {
+  minTime,
+  maxTime,
+  shouldDisableTime,
+  disableIgnoringDatePartForTimeValidation
+}) => {
+  const date = utils.date(value);
+  const 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;
+  }
+};
+
+const isSameTimeError = (a, b) => a === b;
+
+export const useTimeValidation = props => useValidation(props, validateTime, isSameTimeError);

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

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

package/modern/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/modern/internals/models/helpers.js

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

package/modern/internals/models/index.js

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

package/modern/internals/models/muiPickersAdapter.js

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

package/modern/internals/models/parseableDate.js

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

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

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

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

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

package/modern/internals/models/views.js

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

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

@@ -0,0 +1,67 @@
+export const findClosestEnabledDate = ({
+  date,
+  disableFuture,
+  disablePast,
+  maxDate,
+  minDate,
+  shouldDisableDate,
+  utils
+}) => {
+  const today = utils.startOfDay(utils.date());
+
+  if (disablePast && utils.isBefore(minDate, today)) {
+    minDate = today;
+  }
+
+  if (disableFuture && utils.isAfter(maxDate, today)) {
+    maxDate = today;
+  }
+
+  let forward = date;
+  let 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 const parsePickerInputValue = (utils, value) => {
+  const parsedValue = utils.date(value);
+  return utils.isValid(parsedValue) ? parsedValue : null;
+};

package/modern/internals/utils/defaultReduceAnimations.js

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

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

@@ -0,0 +1,66 @@
+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 ${utils.format(utils.date(rawValue), 'fullDate')}` : 'Choose date';
+}
+export const getDisplayDate = (utils, value, inputFormat) => {
+  const date = utils.date(value);
+  const 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'];
+}
+const MASK_USER_INPUT_SYMBOL = '_';
+const staticDateWith2DigitTokens = '2019-11-21T22:30:00.000';
+const staticDateWith1DigitTokens = '2019-01-01T09:00:00.000';
+export function checkMaskIsValidForCurrentFormat(mask, format, acceptRegex, utils) {
+  const formattedDateWith1Digit = utils.formatByString(utils.date(staticDateWith1DigitTokens), format);
+  const inferredFormatPatternWith1Digits = formattedDateWith1Digit.replace(acceptRegex, MASK_USER_INPUT_SYMBOL);
+  const inferredFormatPatternWith2Digits = utils.formatByString(utils.date(staticDateWith2DigitTokens), format).replace(acceptRegex, '_');
+  const isMaskValid = inferredFormatPatternWith2Digits === mask && inferredFormatPatternWith1Digits === mask;
+
+  if (!isMaskValid && utils.lib !== 'luxon' && process.env.NODE_ENV !== 'production') {
+    console.warn(`The mask "${mask}" you passed is not valid for the format used ${format}. Falling down to uncontrolled not-masked input.`);
+  }
+
+  return isMaskValid;
+}
+export const maskedDateFormatter = (mask, acceptRegexp) => value => {
+  return value.split('').map((char, i) => {
+    acceptRegexp.lastIndex = 0;
+
+    if (i > mask.length - 1) {
+      return '';
+    }
+
+    const maskChar = mask[i];
+    const nextMaskChar = mask[i + 1];
+    const acceptedChar = acceptRegexp.test(char) ? char : '';
+    const 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/modern/internals/utils/time-utils.js

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

package/modern/internals/utils/utils.js

@@ -0,0 +1,36 @@
+/* Use it instead of .includes method for IE support */
+export function arrayIncludes(array, itemOrItems) {
+  if (Array.isArray(itemOrItems)) {
+    return itemOrItems.every(item => array.indexOf(item) !== -1);
+  }
+
+  return array.indexOf(itemOrItems) !== -1;
+}
+export const onSpaceOrEnter = (innerFn, onFocus) => 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 const pipe = (...fns) => fns.reduceRight((prevFn, nextFn) => (...args) => nextFn(prevFn(...args)), value => value);
+export const executeInTheNextEventLoopTick = fn => {
+  setTimeout(fn, 0);
+};
+export function createDelegatedEventHandler(fn, onEvent) {
+  return event => {
+    fn(event);
+
+    if (onEvent) {
+      onEvent(event);
+    }
+  };
+}
+export const doNothing = () => {};

package/modern/themeAugmentation/index.js

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

package/node/AdapterDateFns/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AdapterDateFns", {
+  enumerable: true,
+  get: function () {
+    return _dateFns.default;
+  }
+});
+
+var _dateFns = _interopRequireDefault(require("@date-io/date-fns"));

package/node/AdapterDayjs/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AdapterDayjs", {
+  enumerable: true,
+  get: function () {
+    return _dayjs.default;
+  }
+});
+
+var _dayjs = _interopRequireDefault(require("@date-io/dayjs"));

package/node/AdapterLuxon/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AdapterLuxon", {
+  enumerable: true,
+  get: function () {
+    return _luxon.default;
+  }
+});
+
+var _luxon = _interopRequireDefault(require("@date-io/luxon"));

package/node/AdapterMoment/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AdapterMoment", {
+  enumerable: true,
+  get: function () {
+    return _moment.default;
+  }
+});
+
+var _moment = _interopRequireDefault(require("@date-io/moment"));