@mui/x-date-pickers 7.0.0-beta.2 → 7.0.0-beta.5

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

@@ -1,71 +0,0 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _extends from "@babel/runtime/helpers/esm/extends";
-import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
-var _excluded = ["views", "format"];
-import { resolveTimeFormat, isTimeView, isInternalTimeView } from './time-utils';
-import { resolveDateFormat } from './date-utils';
-export var resolveDateTimeFormat = function resolveDateTimeFormat(utils, _ref) {
-  var views = _ref.views,
-    format = _ref.format,
-    other = _objectWithoutProperties(_ref, _excluded);
-  if (format) {
-    return format;
-  }
-  var dateViews = [];
-  var timeViews = [];
-  views.forEach(function (view) {
-    if (isTimeView(view)) {
-      timeViews.push(view);
-    } else {
-      dateViews.push(view);
-    }
-  });
-  if (timeViews.length === 0) {
-    return resolveDateFormat(utils, _extends({
-      views: dateViews
-    }, other), false);
-  }
-  if (dateViews.length === 0) {
-    return resolveTimeFormat(utils, _extends({
-      views: timeViews
-    }, other));
-  }
-  var timeFormat = resolveTimeFormat(utils, _extends({
-    views: timeViews
-  }, other));
-  var dateFormat = resolveDateFormat(utils, _extends({
-    views: dateViews
-  }, other), false);
-  return "".concat(dateFormat, " ").concat(timeFormat);
-};
-var resolveViews = function resolveViews(ampm, views, shouldUseSingleColumn) {
-  if (shouldUseSingleColumn) {
-    return views.filter(function (view) {
-      return !isInternalTimeView(view) || view === 'hours';
-    });
-  }
-  return ampm ? [].concat(_toConsumableArray(views), ['meridiem']) : views;
-};
-var resolveShouldRenderTimeInASingleColumn = function resolveShouldRenderTimeInASingleColumn(timeSteps, threshold) {
-  var _timeSteps$hours, _timeSteps$minutes;
-  return 24 * 60 / (((_timeSteps$hours = timeSteps.hours) != null ? _timeSteps$hours : 1) * ((_timeSteps$minutes = timeSteps.minutes) != null ? _timeSteps$minutes : 5)) <= threshold;
-};
-export function resolveTimeViewsResponse(_ref2) {
-  var inThreshold = _ref2.thresholdToRenderTimeInASingleColumn,
-    ampm = _ref2.ampm,
-    inTimeSteps = _ref2.timeSteps,
-    views = _ref2.views;
-  var thresholdToRenderTimeInASingleColumn = inThreshold != null ? inThreshold : 24;
-  var timeSteps = _extends({
-    hours: 1,
-    minutes: 5,
-    seconds: 5
-  }, inTimeSteps);
-  var shouldRenderTimeInASingleColumn = resolveShouldRenderTimeInASingleColumn(timeSteps, thresholdToRenderTimeInASingleColumn);
-  return {
-    thresholdToRenderTimeInASingleColumn: thresholdToRenderTimeInASingleColumn,
-    timeSteps: timeSteps,
-    shouldRenderTimeInASingleColumn: shouldRenderTimeInASingleColumn,
-    views: resolveViews(ampm, views, shouldRenderTimeInASingleColumn)
-  };
-}

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

@@ -1,129 +0,0 @@
-import { areViewsEqual } from './views';
-export var findClosestEnabledDate = function findClosestEnabledDate(_ref) {
-  var date = _ref.date,
-    disableFuture = _ref.disableFuture,
-    disablePast = _ref.disablePast,
-    maxDate = _ref.maxDate,
-    minDate = _ref.minDate,
-    isDateDisabled = _ref.isDateDisabled,
-    utils = _ref.utils,
-    timezone = _ref.timezone;
-  var today = utils.startOfDay(utils.date(undefined, timezone));
-  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 = minDate;
-    backward = null;
-  }
-  if (utils.isAfter(date, maxDate)) {
-    if (backward) {
-      backward = 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 (!isDateDisabled(forward)) {
-        return forward;
-      }
-      forward = utils.addDays(forward, 1);
-    }
-    if (backward) {
-      if (!isDateDisabled(backward)) {
-        return backward;
-      }
-      backward = utils.addDays(backward, -1);
-    }
-  }
-  return null;
-};
-export var replaceInvalidDateByNull = function replaceInvalidDateByNull(utils, value) {
-  return value == null || !utils.isValid(value) ? null : value;
-};
-export var applyDefaultDate = function applyDefaultDate(utils, value, defaultValue) {
-  if (value == null || !utils.isValid(value)) {
-    return defaultValue;
-  }
-  return value;
-};
-export var areDatesEqual = function areDatesEqual(utils, a, b) {
-  if (!utils.isValid(a) && a != null && !utils.isValid(b) && b != null) {
-    return true;
-  }
-  return utils.isEqual(a, b);
-};
-export var getMonthsInYear = function getMonthsInYear(utils, year) {
-  var firstMonth = utils.startOfYear(year);
-  var months = [firstMonth];
-  while (months.length < 12) {
-    var prevMonth = months[months.length - 1];
-    months.push(utils.addMonths(prevMonth, 1));
-  }
-  return months;
-};
-export var mergeDateAndTime = function mergeDateAndTime(utils, dateParam, timeParam) {
-  var mergedDate = dateParam;
-  mergedDate = utils.setHours(mergedDate, utils.getHours(timeParam));
-  mergedDate = utils.setMinutes(mergedDate, utils.getMinutes(timeParam));
-  mergedDate = utils.setSeconds(mergedDate, utils.getSeconds(timeParam));
-  return mergedDate;
-};
-export var getTodayDate = function getTodayDate(utils, timezone, valueType) {
-  return valueType === 'date' ? utils.startOfDay(utils.date(undefined, timezone)) : utils.date(undefined, timezone);
-};
-export var formatMeridiem = function formatMeridiem(utils, meridiem) {
-  var date = utils.setHours(utils.date(), meridiem === 'am' ? 2 : 14);
-  return utils.format(date, 'meridiem');
-};
-var dateViews = ['year', 'month', 'day'];
-export var isDatePickerView = function isDatePickerView(view) {
-  return dateViews.includes(view);
-};
-export var resolveDateFormat = function resolveDateFormat(utils, _ref2, isInToolbar) {
-  var format = _ref2.format,
-    views = _ref2.views;
-  if (format != null) {
-    return format;
-  }
-  var formats = utils.formats;
-  if (areViewsEqual(views, ['year'])) {
-    return formats.year;
-  }
-  if (areViewsEqual(views, ['month'])) {
-    return formats.month;
-  }
-  if (areViewsEqual(views, ['day'])) {
-    return formats.dayOfMonth;
-  }
-  if (areViewsEqual(views, ['month', 'year'])) {
-    return "".concat(formats.month, " ").concat(formats.year);
-  }
-  if (areViewsEqual(views, ['day', 'month'])) {
-    return "".concat(formats.month, " ").concat(formats.dayOfMonth);
-  }
-  if (isInToolbar) {
-    // Little localization hack (Google is doing the same for android native pickers):
-    // For english localization it is convenient to include weekday into the date "Mon, Jun 1".
-    // For other locales using strings like "June 1", without weekday.
-    return /en/.test(utils.getCurrentLocaleCode()) ? formats.normalDateWithWeekday : formats.normalDate;
-  }
-  return formats.keyboardDate;
-};
-export var getWeekdays = function getWeekdays(utils, date) {
-  var start = utils.startOfWeek(date);
-  return [0, 1, 2, 3, 4, 5, 6].map(function (diff) {
-    return utils.addDays(start, diff);
-  });
-};

package/legacy/internals/utils/fields.js

@@ -1,28 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import { DATE_TIME_VALIDATION_PROP_NAMES, DATE_VALIDATION_PROP_NAMES, TIME_VALIDATION_PROP_NAMES } from './validation/extractValidationProps';
-var SHARED_FIELD_INTERNAL_PROP_NAMES = ['value', 'defaultValue', 'referenceDate', 'format', 'formatDensity', 'onChange', 'timezone', 'readOnly', 'onError', 'shouldRespectLeadingZeros', 'selectedSections', 'onSelectedSectionsChange', 'unstableFieldRef'];
-export var splitFieldInternalAndForwardedProps = function splitFieldInternalAndForwardedProps(props, valueType) {
-  var forwardedProps = _extends({}, props);
-  var internalProps = {};
-  var extractProp = function extractProp(propName) {
-    if (forwardedProps.hasOwnProperty(propName)) {
-      // @ts-ignore
-      internalProps[propName] = forwardedProps[propName];
-      delete forwardedProps[propName];
-    }
-  };
-  SHARED_FIELD_INTERNAL_PROP_NAMES.forEach(extractProp);
-  if (valueType === 'date') {
-    DATE_VALIDATION_PROP_NAMES.forEach(extractProp);
-  } else if (valueType === 'time') {
-    TIME_VALIDATION_PROP_NAMES.forEach(extractProp);
-  } else if (valueType === 'date-time') {
-    DATE_VALIDATION_PROP_NAMES.forEach(extractProp);
-    TIME_VALIDATION_PROP_NAMES.forEach(extractProp);
-    DATE_TIME_VALIDATION_PROP_NAMES.forEach(extractProp);
-  }
-  return {
-    forwardedProps: forwardedProps,
-    internalProps: internalProps
-  };
-};

package/legacy/internals/utils/getDefaultReferenceDate.js

@@ -1,65 +0,0 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import { createIsAfterIgnoreDatePart } from './time-utils';
-import { mergeDateAndTime, getTodayDate } from './date-utils';
-export var SECTION_TYPE_GRANULARITY = {
-  year: 1,
-  month: 2,
-  day: 3,
-  hours: 4,
-  minutes: 5,
-  seconds: 6,
-  milliseconds: 7
-};
-export var getSectionTypeGranularity = function getSectionTypeGranularity(sections) {
-  return Math.max.apply(Math, _toConsumableArray(sections.map(function (section) {
-    var _SECTION_TYPE_GRANULA;
-    return (_SECTION_TYPE_GRANULA = SECTION_TYPE_GRANULARITY[section.type]) != null ? _SECTION_TYPE_GRANULA : 1;
-  })));
-};
-var roundDate = function roundDate(utils, granularity, date) {
-  if (granularity === SECTION_TYPE_GRANULARITY.year) {
-    return utils.startOfYear(date);
-  }
-  if (granularity === SECTION_TYPE_GRANULARITY.month) {
-    return utils.startOfMonth(date);
-  }
-  if (granularity === SECTION_TYPE_GRANULARITY.day) {
-    return utils.startOfDay(date);
-  }
-
-  // We don't have startOfHour / startOfMinute / startOfSecond
-  var roundedDate = date;
-  if (granularity < SECTION_TYPE_GRANULARITY.minutes) {
-    roundedDate = utils.setMinutes(roundedDate, 0);
-  }
-  if (granularity < SECTION_TYPE_GRANULARITY.seconds) {
-    roundedDate = utils.setSeconds(roundedDate, 0);
-  }
-  if (granularity < SECTION_TYPE_GRANULARITY.milliseconds) {
-    roundedDate = utils.setMilliseconds(roundedDate, 0);
-  }
-  return roundedDate;
-};
-export var getDefaultReferenceDate = function getDefaultReferenceDate(_ref) {
-  var _props$disableIgnorin;
-  var props = _ref.props,
-    utils = _ref.utils,
-    granularity = _ref.granularity,
-    timezone = _ref.timezone,
-    inGetTodayDate = _ref.getTodayDate;
-  var referenceDate = inGetTodayDate ? inGetTodayDate() : roundDate(utils, granularity, getTodayDate(utils, timezone));
-  if (props.minDate != null && utils.isAfterDay(props.minDate, referenceDate)) {
-    referenceDate = roundDate(utils, granularity, props.minDate);
-  }
-  if (props.maxDate != null && utils.isBeforeDay(props.maxDate, referenceDate)) {
-    referenceDate = roundDate(utils, granularity, props.maxDate);
-  }
-  var isAfter = createIsAfterIgnoreDatePart((_props$disableIgnorin = props.disableIgnoringDatePartForTimeValidation) != null ? _props$disableIgnorin : false, utils);
-  if (props.minTime != null && isAfter(props.minTime, referenceDate)) {
-    referenceDate = roundDate(utils, granularity, props.disableIgnoringDatePartForTimeValidation ? props.minTime : mergeDateAndTime(utils, referenceDate, props.minTime));
-  }
-  if (props.maxTime != null && isAfter(referenceDate, props.maxTime)) {
-    referenceDate = roundDate(utils, granularity, props.disableIgnoringDatePartForTimeValidation ? props.maxTime : mergeDateAndTime(utils, referenceDate, props.maxTime));
-  }
-  return referenceDate;
-};

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

@@ -1,63 +0,0 @@
-import { areViewsEqual } from './views';
-var timeViews = ['hours', 'minutes', 'seconds'];
-export var isTimeView = function isTimeView(view) {
-  return timeViews.includes(view);
-};
-export var isInternalTimeView = function isInternalTimeView(view) {
-  return timeViews.includes(view) || view === 'meridiem';
-};
-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);
-  };
-};
-export var resolveTimeFormat = function resolveTimeFormat(utils, _ref) {
-  var format = _ref.format,
-    views = _ref.views,
-    ampm = _ref.ampm;
-  if (format != null) {
-    return format;
-  }
-  var formats = utils.formats;
-  if (areViewsEqual(views, ['hours'])) {
-    return ampm ? "".concat(formats.hours12h, " ").concat(formats.meridiem) : formats.hours24h;
-  }
-  if (areViewsEqual(views, ['minutes'])) {
-    return formats.minutes;
-  }
-  if (areViewsEqual(views, ['seconds'])) {
-    return formats.seconds;
-  }
-  if (areViewsEqual(views, ['minutes', 'seconds'])) {
-    return "".concat(formats.minutes, ":").concat(formats.seconds);
-  }
-  if (areViewsEqual(views, ['hours', 'minutes', 'seconds'])) {
-    return ampm ? "".concat(formats.hours12h, ":").concat(formats.minutes, ":").concat(formats.seconds, " ").concat(formats.meridiem) : "".concat(formats.hours24h, ":").concat(formats.minutes, ":").concat(formats.seconds);
-  }
-  return ampm ? "".concat(formats.hours12h, ":").concat(formats.minutes, " ").concat(formats.meridiem) : "".concat(formats.hours24h, ":").concat(formats.minutes);
-};

package/legacy/internals/utils/utils.js

@@ -1,40 +0,0 @@
-/* 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, externalEvent) {
-  return function (event) {
-    if (event.key === 'Enter' || event.key === ' ') {
-      innerFn(event);
-
-      // prevent any side effects
-      event.preventDefault();
-      event.stopPropagation();
-    }
-    if (externalEvent) {
-      externalEvent(event);
-    }
-  };
-};
-export var executeInTheNextEventLoopTick = function executeInTheNextEventLoopTick(fn) {
-  setTimeout(fn, 0);
-};
-
-// https://www.abeautifulsite.net/posts/finding-the-active-element-in-a-shadow-root/
-export var getActiveElement = function getActiveElement() {
-  var root = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document;
-  var activeEl = root.activeElement;
-  if (!activeEl) {
-    return null;
-  }
-  if (activeEl.shadowRoot) {
-    return getActiveElement(activeEl.shadowRoot);
-  }
-  return activeEl;
-};
-export var DEFAULT_DESKTOP_MODE_MEDIA_QUERY = '@media (pointer: fine)';

package/legacy/internals/utils/validation/extractValidationProps.js

@@ -1,16 +0,0 @@
-export var DATE_VALIDATION_PROP_NAMES = ['disablePast', 'disableFuture', 'minDate', 'maxDate', 'shouldDisableDate', 'shouldDisableMonth', 'shouldDisableYear'];
-export var TIME_VALIDATION_PROP_NAMES = ['disablePast', 'disableFuture', 'minTime', 'maxTime', 'shouldDisableTime', 'minutesStep', 'ampm', 'disableIgnoringDatePartForTimeValidation'];
-export var DATE_TIME_VALIDATION_PROP_NAMES = ['minDateTime', 'maxDateTime'];
-var VALIDATION_PROP_NAMES = [].concat(DATE_VALIDATION_PROP_NAMES, TIME_VALIDATION_PROP_NAMES, DATE_TIME_VALIDATION_PROP_NAMES);
-/**
- * Extract the validation props for the props received by a component.
- * Limit the risk of forgetting some of them and reduce the bundle size.
- */
-export var extractValidationProps = function extractValidationProps(props) {
-  return VALIDATION_PROP_NAMES.reduce(function (extractedProps, propName) {
-    if (props.hasOwnProperty(propName)) {
-      extractedProps[propName] = props[propName];
-    }
-    return extractedProps;
-  }, {});
-};

package/legacy/internals/utils/validation/validateDate.js

@@ -1,38 +0,0 @@
-import { applyDefaultDate } from '../date-utils';
-export var validateDate = function validateDate(_ref) {
-  var props = _ref.props,
-    value = _ref.value,
-    adapter = _ref.adapter;
-  if (value === null) {
-    return null;
-  }
-  var shouldDisableDate = props.shouldDisableDate,
-    shouldDisableMonth = props.shouldDisableMonth,
-    shouldDisableYear = props.shouldDisableYear,
-    disablePast = props.disablePast,
-    disableFuture = props.disableFuture,
-    timezone = props.timezone;
-  var now = adapter.utils.date(undefined, timezone);
-  var minDate = applyDefaultDate(adapter.utils, props.minDate, adapter.defaultDates.minDate);
-  var maxDate = applyDefaultDate(adapter.utils, props.maxDate, adapter.defaultDates.maxDate);
-  switch (true) {
-    case !adapter.utils.isValid(value):
-      return 'invalidDate';
-    case Boolean(shouldDisableDate && shouldDisableDate(value)):
-      return 'shouldDisableDate';
-    case Boolean(shouldDisableMonth && shouldDisableMonth(value)):
-      return 'shouldDisableMonth';
-    case Boolean(shouldDisableYear && shouldDisableYear(value)):
-      return 'shouldDisableYear';
-    case Boolean(disableFuture && adapter.utils.isAfterDay(value, now)):
-      return 'disableFuture';
-    case Boolean(disablePast && adapter.utils.isBeforeDay(value, now)):
-      return 'disablePast';
-    case Boolean(minDate && adapter.utils.isBeforeDay(value, minDate)):
-      return 'minDate';
-    case Boolean(maxDate && adapter.utils.isAfterDay(value, maxDate)):
-      return 'maxDate';
-    default:
-      return null;
-  }
-};

package/legacy/internals/utils/validation/validateDateTime.js

@@ -1,20 +0,0 @@
-import { validateDate } from './validateDate';
-import { validateTime } from './validateTime';
-export var validateDateTime = function validateDateTime(_ref) {
-  var props = _ref.props,
-    value = _ref.value,
-    adapter = _ref.adapter;
-  var dateValidationResult = validateDate({
-    adapter: adapter,
-    value: value,
-    props: props
-  });
-  if (dateValidationResult !== null) {
-    return dateValidationResult;
-  }
-  return validateTime({
-    adapter: adapter,
-    value: value,
-    props: props
-  });
-};

package/legacy/internals/utils/validation/validateTime.js

@@ -1,42 +0,0 @@
-import { createIsAfterIgnoreDatePart } from '../time-utils';
-export var validateTime = function validateTime(_ref) {
-  var adapter = _ref.adapter,
-    value = _ref.value,
-    props = _ref.props;
-  if (value === null) {
-    return null;
-  }
-  var minTime = props.minTime,
-    maxTime = props.maxTime,
-    minutesStep = props.minutesStep,
-    shouldDisableTime = props.shouldDisableTime,
-    _props$disableIgnorin = props.disableIgnoringDatePartForTimeValidation,
-    disableIgnoringDatePartForTimeValidation = _props$disableIgnorin === void 0 ? false : _props$disableIgnorin,
-    disablePast = props.disablePast,
-    disableFuture = props.disableFuture,
-    timezone = props.timezone;
-  var now = adapter.utils.date(undefined, timezone);
-  var isAfter = createIsAfterIgnoreDatePart(disableIgnoringDatePartForTimeValidation, adapter.utils);
-  switch (true) {
-    case !adapter.utils.isValid(value):
-      return 'invalidDate';
-    case Boolean(minTime && isAfter(minTime, value)):
-      return 'minTime';
-    case Boolean(maxTime && isAfter(value, maxTime)):
-      return 'maxTime';
-    case Boolean(disableFuture && adapter.utils.isAfter(value, now)):
-      return 'disableFuture';
-    case Boolean(disablePast && adapter.utils.isBefore(value, now)):
-      return 'disablePast';
-    case Boolean(shouldDisableTime && shouldDisableTime(value, 'hours')):
-      return 'shouldDisableTime-hours';
-    case Boolean(shouldDisableTime && shouldDisableTime(value, 'minutes')):
-      return 'shouldDisableTime-minutes';
-    case Boolean(shouldDisableTime && shouldDisableTime(value, 'seconds')):
-      return 'shouldDisableTime-seconds';
-    case Boolean(minutesStep && adapter.utils.getMinutes(value) % minutesStep !== 0):
-      return 'minutesStep';
-    default:
-      return null;
-  }
-};

package/legacy/internals/utils/valueManagers.js

@@ -1,67 +0,0 @@
-import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
-var _excluded = ["value", "referenceDate"];
-import { areDatesEqual, getTodayDate, replaceInvalidDateByNull } from './date-utils';
-import { getDefaultReferenceDate } from './getDefaultReferenceDate';
-import { addPositionPropertiesToSections, createDateStrForInputFromSections } from '../hooks/useField/useField.utils';
-export var singleItemValueManager = {
-  emptyValue: null,
-  getTodayValue: getTodayDate,
-  getInitialReferenceValue: function getInitialReferenceValue(_ref) {
-    var value = _ref.value,
-      referenceDate = _ref.referenceDate,
-      params = _objectWithoutProperties(_ref, _excluded);
-    if (value != null && params.utils.isValid(value)) {
-      return value;
-    }
-    if (referenceDate != null) {
-      return referenceDate;
-    }
-    return getDefaultReferenceDate(params);
-  },
-  cleanValue: replaceInvalidDateByNull,
-  areValuesEqual: areDatesEqual,
-  isSameError: function isSameError(a, b) {
-    return a === b;
-  },
-  hasError: function hasError(error) {
-    return error != null;
-  },
-  defaultErrorState: null,
-  getTimezone: function getTimezone(utils, value) {
-    return value == null || !utils.isValid(value) ? null : utils.getTimezone(value);
-  },
-  setTimezone: function setTimezone(utils, timezone, value) {
-    return value == null ? null : utils.setTimezone(value, timezone);
-  }
-};
-export var singleItemFieldValueManager = {
-  updateReferenceValue: function updateReferenceValue(utils, value, prevReferenceValue) {
-    return value == null || !utils.isValid(value) ? prevReferenceValue : value;
-  },
-  getSectionsFromValue: function getSectionsFromValue(utils, date, prevSections, localizedDigits, isRTL, getSectionsFromDate) {
-    var shouldReUsePrevDateSections = !utils.isValid(date) && !!prevSections;
-    if (shouldReUsePrevDateSections) {
-      return prevSections;
-    }
-    return addPositionPropertiesToSections(getSectionsFromDate(date), localizedDigits, isRTL);
-  },
-  getValueStrFromSections: createDateStrForInputFromSections,
-  getActiveDateManager: function getActiveDateManager(utils, state) {
-    return {
-      date: state.value,
-      referenceDate: state.referenceValue,
-      getSections: function getSections(sections) {
-        return sections;
-      },
-      getNewValuesFromNewActiveDate: function getNewValuesFromNewActiveDate(newActiveDate) {
-        return {
-          value: newActiveDate,
-          referenceValue: newActiveDate == null || !utils.isValid(newActiveDate) ? state.referenceValue : newActiveDate
-        };
-      }
-    };
-  },
-  parseValueStr: function parseValueStr(valueStr, referenceValue, parseDate) {
-    return parseDate(valueStr.trim(), referenceValue);
-  }
-};

package/legacy/internals/utils/views.js

@@ -1,29 +0,0 @@
-export var areViewsEqual = function areViewsEqual(views, expectedViews) {
-  if (views.length !== expectedViews.length) {
-    return false;
-  }
-  return expectedViews.every(function (expectedView) {
-    return views.includes(expectedView);
-  });
-};
-export var applyDefaultViewProps = function applyDefaultViewProps(_ref) {
-  var openTo = _ref.openTo,
-    defaultOpenTo = _ref.defaultOpenTo,
-    views = _ref.views,
-    defaultViews = _ref.defaultViews;
-  var viewsWithDefault = views != null ? views : defaultViews;
-  var openToWithDefault;
-  if (openTo != null) {
-    openToWithDefault = openTo;
-  } else if (viewsWithDefault.includes(defaultOpenTo)) {
-    openToWithDefault = defaultOpenTo;
-  } else if (viewsWithDefault.length > 0) {
-    openToWithDefault = viewsWithDefault[0];
-  } else {
-    throw new Error('MUI X: The `views` prop must contain at least one view.');
-  }
-  return {
-    views: viewsWithDefault,
-    openTo: openToWithDefault
-  };
-};

package/legacy/internals/utils/warning.js

@@ -1,39 +0,0 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-export var buildDeprecatedPropsWarning = function buildDeprecatedPropsWarning(message) {
-  var alreadyWarned = false;
-  if (process.env.NODE_ENV === 'production') {
-    return function () {};
-  }
-  var cleanMessage = Array.isArray(message) ? message.join('\n') : message;
-  return function (deprecatedProps) {
-    var deprecatedKeys = Object.entries(deprecatedProps).filter(function (_ref) {
-      var _ref2 = _slicedToArray(_ref, 2),
-        value = _ref2[1];
-      return value !== undefined;
-    }).map(function (_ref3) {
-      var _ref4 = _slicedToArray(_ref3, 1),
-        key = _ref4[0];
-      return "- ".concat(key);
-    });
-    if (!alreadyWarned && deprecatedKeys.length > 0) {
-      alreadyWarned = true;
-      console.warn([cleanMessage, 'deprecated props observed:'].concat(_toConsumableArray(deprecatedKeys)).join('\n'));
-    }
-  };
-};
-export var buildWarning = function buildWarning(message) {
-  var gravity = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'warning';
-  var alreadyWarned = false;
-  var cleanMessage = Array.isArray(message) ? message.join('\n') : message;
-  return function () {
-    if (!alreadyWarned) {
-      alreadyWarned = true;
-      if (gravity === 'error') {
-        console.error(cleanMessage);
-      } else {
-        console.warn(cleanMessage);
-      }
-    }
-  };
-};