npm - @tenancy.nz/datepicker - Versions diffs - 1.3.4 - Mend

@tenancy.nz/datepicker 1.3.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (361) hide show

package/dist/cjs/node_modules/.pnpm/@mui_x-date-pickers@8.27.0_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@em_f7106fb7eba50d62f3c82acfcf63ee91/node_modules/@mui/x-date-pickers/esm/internals/hooks/useUtils.cjs ADDED Viewed

@@ -0,0 +1,36 @@
+'use strict';
+var React = require('react');
+var usePickerAdapter = require('../../hooks/usePickerAdapter.cjs');
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+const useDefaultDates = () => usePickerAdapter.useLocalizationContext().defaultDates;
+const useNow = timezone => {
+  const adapter = usePickerAdapter.usePickerAdapter();
+  const now = React__namespace.useRef(undefined);
+  if (now.current === undefined) {
+    now.current = adapter.date(undefined, timezone);
+  }
+  return now.current;
+};
+exports.useDefaultDates = useDefaultDates;
+exports.useNow = useNow;

@@ -0,0 +1,152 @@
+'use strict';
+var _extends = require('../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.cjs');
+var React = require('react');
+var createStepNavigation = require('../utils/createStepNavigation.cjs');
+var useControlled = require('../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useControlled/useControlled.cjs');
+var useEventCallback = require('../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useEventCallback/useEventCallback.cjs');
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+let warnedOnceNotValidView = false;
+function useViews({
+  onChange,
+  onViewChange,
+  openTo,
+  view: inView,
+  views,
+  autoFocus,
+  focusedView: inFocusedView,
+  onFocusedViewChange,
+  getStepNavigation
+}) {
+  if (process.env.NODE_ENV !== 'production') {
+    if (!warnedOnceNotValidView) {
+      if (inView != null && !views.includes(inView)) {
+        console.warn(`MUI X: \`view="${inView}"\` is not a valid prop.`, `It must be an element of \`views=["${views.join('", "')}"]\`.`);
+        warnedOnceNotValidView = true;
+      }
+      if (inView == null && openTo != null && !views.includes(openTo)) {
+        console.warn(`MUI X: \`openTo="${openTo}"\` is not a valid prop.`, `It must be an element of \`views=["${views.join('", "')}"]\`.`);
+        warnedOnceNotValidView = true;
+      }
+    }
+  }
+  const previousOpenTo = React__namespace.useRef(openTo);
+  const previousViews = React__namespace.useRef(views);
+  const defaultView = React__namespace.useRef(views.includes(openTo) ? openTo : views[0]);
+  const [view, setView] = useControlled.default({
+    name: 'useViews',
+    state: 'view',
+    controlled: inView,
+    default: defaultView.current
+  });
+  const defaultFocusedView = React__namespace.useRef(autoFocus ? view : null);
+  const [focusedView, setFocusedView] = useControlled.default({
+    name: 'useViews',
+    state: 'focusedView',
+    controlled: inFocusedView,
+    default: defaultFocusedView.current
+  });
+  const stepNavigation = getStepNavigation ? getStepNavigation({
+    setView,
+    view,
+    defaultView: defaultView.current,
+    views
+  }) : createStepNavigation.DEFAULT_STEP_NAVIGATION;
+  React__namespace.useEffect(() => {
+    // Update the current view when `openTo` or `views` props change
+    if (previousOpenTo.current && previousOpenTo.current !== openTo || previousViews.current && previousViews.current.some(previousView => !views.includes(previousView))) {
+      setView(views.includes(openTo) ? openTo : views[0]);
+      previousViews.current = views;
+      previousOpenTo.current = openTo;
+    }
+  }, [openTo, setView, view, views]);
+  const viewIndex = views.indexOf(view);
+  const previousView = views[viewIndex - 1] ?? null;
+  const nextView = views[viewIndex + 1] ?? null;
+  const handleFocusedViewChange = useEventCallback.default((viewToFocus, hasFocus) => {
+    if (hasFocus) {
+      // Focus event
+      setFocusedView(viewToFocus);
+    } else {
+      // Blur event
+      setFocusedView(prevFocusedView => viewToFocus === prevFocusedView ? null : prevFocusedView // If false the blur is due to view switching
+      );
+    }
+    onFocusedViewChange?.(viewToFocus, hasFocus);
+  });
+  const handleChangeView = useEventCallback.default(newView => {
+    // always keep the focused view in sync
+    handleFocusedViewChange(newView, true);
+    if (newView === view) {
+      return;
+    }
+    setView(newView);
+    if (onViewChange) {
+      onViewChange(newView);
+    }
+  });
+  const goToNextView = useEventCallback.default(() => {
+    if (nextView) {
+      handleChangeView(nextView);
+    }
+  });
+  const setValueAndGoToNextView = useEventCallback.default((value, currentViewSelectionState, selectedView) => {
+    const isSelectionFinishedOnCurrentView = currentViewSelectionState === 'finish';
+    const hasMoreViews = selectedView ?
+    // handles case like `DateTimePicker`, where a view might return a `finish` selection state
+    // but when it's not the final view given all `views` -> overall selection state should be `partial`.
+    views.indexOf(selectedView) < views.length - 1 : Boolean(nextView);
+    const globalSelectionState = isSelectionFinishedOnCurrentView && hasMoreViews ? 'partial' : currentViewSelectionState;
+    onChange(value, globalSelectionState, selectedView);
+    // The selected view can be different from the active view,
+    // This can happen if multiple views are displayed, like in `DesktopDateTimePicker` or `MultiSectionDigitalClock`.
+    let currentView = null;
+    if (selectedView != null && selectedView !== view) {
+      currentView = selectedView;
+    } else if (isSelectionFinishedOnCurrentView) {
+      currentView = view;
+    }
+    if (currentView == null) {
+      return;
+    }
+    const viewToNavigateTo = views[views.indexOf(currentView) + 1];
+    if (viewToNavigateTo == null || !stepNavigation.areViewsInSameStep(currentView, viewToNavigateTo)) {
+      return;
+    }
+    handleChangeView(viewToNavigateTo);
+  });
+  return _extends.default({}, stepNavigation, {
+    view,
+    setView: handleChangeView,
+    focusedView,
+    setFocusedView: handleFocusedViewChange,
+    nextView,
+    previousView,
+    // Always return up-to-date default view instead of the initial one (i.e. defaultView.current)
+    defaultView: views.includes(openTo) ? openTo : views[0],
+    goToNextView,
+    setValueAndGoToNextView
+  });
+}
+exports.useViews = useViews;

@@ -0,0 +1,29 @@
+'use strict';
+var createStepNavigation = require('./createStepNavigation.cjs');
+function createNonRangePickerStepNavigation(parameters) {
+  const {
+    steps
+  } = parameters;
+  return createStepNavigation.createStepNavigation({
+    steps,
+    isViewMatchingStep: (view, step) => {
+      return step.views == null || step.views.includes(view);
+    },
+    onStepChange: ({
+      step,
+      defaultView,
+      setView,
+      view,
+      views
+    }) => {
+      const targetView = step.views == null ? defaultView : step.views.find(viewBis => views.includes(viewBis));
+      if (targetView !== view) {
+        setView(targetView);
+      }
+    }
+  });
+}
+exports.createNonRangePickerStepNavigation = createNonRangePickerStepNavigation;

@@ -0,0 +1,50 @@
+'use strict';
+var _extends = require('../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.cjs');
+const DEFAULT_STEP_NAVIGATION = {
+  hasNextStep: false,
+  hasSeveralSteps: false,
+  goToNextStep: () => {},
+  areViewsInSameStep: () => true
+};
+/**
+ * Create an object that determines whether there is a next step and allows to go to the next step.
+ * @param {CreateStepNavigationParameters<TStep>} parameters The parameters of the createStepNavigation function
+ * @returns {CreateStepNavigationReturnValue} The return value of the createStepNavigation function
+ */
+function createStepNavigation(parameters) {
+  const {
+    steps,
+    isViewMatchingStep,
+    onStepChange
+  } = parameters;
+  return parametersBis => {
+    if (steps == null) {
+      return DEFAULT_STEP_NAVIGATION;
+    }
+    const currentStepIndex = steps.findIndex(step => isViewMatchingStep(parametersBis.view, step));
+    const nextStep = currentStepIndex === -1 || currentStepIndex === steps.length - 1 ? null : steps[currentStepIndex + 1];
+    return {
+      hasNextStep: nextStep != null,
+      hasSeveralSteps: steps.length > 1,
+      goToNextStep: () => {
+        if (nextStep == null) {
+          return;
+        }
+        onStepChange(_extends.default({}, parametersBis, {
+          step: nextStep
+        }));
+      },
+      areViewsInSameStep: (viewA, viewB) => {
+        const stepA = steps.find(step => isViewMatchingStep(viewA, step));
+        const stepB = steps.find(step => isViewMatchingStep(viewB, step));
+        return stepA === stepB;
+      }
+    };
+  };
+}
+exports.DEFAULT_STEP_NAVIGATION = DEFAULT_STEP_NAVIGATION;
+exports.createStepNavigation = createStepNavigation;

@@ -0,0 +1,135 @@
+'use strict';
+var views = require('./views.cjs');
+const mergeDateAndTime = (adapter, dateParam, timeParam) => {
+  let mergedDate = dateParam;
+  mergedDate = adapter.setHours(mergedDate, adapter.getHours(timeParam));
+  mergedDate = adapter.setMinutes(mergedDate, adapter.getMinutes(timeParam));
+  mergedDate = adapter.setSeconds(mergedDate, adapter.getSeconds(timeParam));
+  mergedDate = adapter.setMilliseconds(mergedDate, adapter.getMilliseconds(timeParam));
+  return mergedDate;
+};
+const findClosestEnabledDate = ({
+  date,
+  disableFuture,
+  disablePast,
+  maxDate,
+  minDate,
+  isDateDisabled,
+  adapter,
+  timezone
+}) => {
+  const today = mergeDateAndTime(adapter, adapter.date(undefined, timezone), date);
+  if (disablePast && adapter.isBefore(minDate, today)) {
+    minDate = today;
+  }
+  if (disableFuture && adapter.isAfter(maxDate, today)) {
+    maxDate = today;
+  }
+  let forward = date;
+  let backward = date;
+  if (adapter.isBefore(date, minDate)) {
+    forward = minDate;
+    backward = null;
+  }
+  if (adapter.isAfter(date, maxDate)) {
+    if (backward) {
+      backward = maxDate;
+    }
+    forward = null;
+  }
+  while (forward || backward) {
+    if (forward && adapter.isAfter(forward, maxDate)) {
+      forward = null;
+    }
+    if (backward && adapter.isBefore(backward, minDate)) {
+      backward = null;
+    }
+    if (forward) {
+      if (!isDateDisabled(forward)) {
+        return forward;
+      }
+      forward = adapter.addDays(forward, 1);
+    }
+    if (backward) {
+      if (!isDateDisabled(backward)) {
+        return backward;
+      }
+      backward = adapter.addDays(backward, -1);
+    }
+  }
+  return null;
+};
+const replaceInvalidDateByNull = (adapter, value) => !adapter.isValid(value) ? null : value;
+const applyDefaultDate = (adapter, value, defaultValue) => {
+  if (value == null || !adapter.isValid(value)) {
+    return defaultValue;
+  }
+  return value;
+};
+const areDatesEqual = (adapter, a, b) => {
+  if (!adapter.isValid(a) && a != null && !adapter.isValid(b) && b != null) {
+    return true;
+  }
+  return adapter.isEqual(a, b);
+};
+const getMonthsInYear = (adapter, year) => {
+  const firstMonth = adapter.startOfYear(year);
+  const months = [firstMonth];
+  while (months.length < 12) {
+    const prevMonth = months[months.length - 1];
+    months.push(adapter.addMonths(prevMonth, 1));
+  }
+  return months;
+};
+const getTodayDate = (adapter, timezone, valueType) => valueType === 'date' ? adapter.startOfDay(adapter.date(undefined, timezone)) : adapter.date(undefined, timezone);
+const DATE_VIEWS = ['year', 'month', 'day'];
+const isDatePickerView = view => DATE_VIEWS.includes(view);
+const resolveDateFormat = (adapter, {
+  format,
+  views: views$1
+}, isInToolbar) => {
+  if (format != null) {
+    return format;
+  }
+  const formats = adapter.formats;
+  if (views.areViewsEqual(views$1, ['year'])) {
+    return formats.year;
+  }
+  if (views.areViewsEqual(views$1, ['month'])) {
+    return formats.month;
+  }
+  if (views.areViewsEqual(views$1, ['day'])) {
+    return formats.dayOfMonth;
+  }
+  if (views.areViewsEqual(views$1, ['month', 'year'])) {
+    return `${formats.month} ${formats.year}`;
+  }
+  if (views.areViewsEqual(views$1, ['day', 'month'])) {
+    return `${formats.month} ${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(adapter.getCurrentLocaleCode()) ? formats.normalDateWithWeekday : formats.normalDate;
+  }
+  return formats.keyboardDate;
+};
+const getWeekdays = (adapter, date) => {
+  const start = adapter.startOfWeek(date);
+  return [0, 1, 2, 3, 4, 5, 6].map(diff => adapter.addDays(start, diff));
+};
+exports.DATE_VIEWS = DATE_VIEWS;
+exports.applyDefaultDate = applyDefaultDate;
+exports.areDatesEqual = areDatesEqual;
+exports.findClosestEnabledDate = findClosestEnabledDate;
+exports.getMonthsInYear = getMonthsInYear;
+exports.getTodayDate = getTodayDate;
+exports.getWeekdays = getWeekdays;
+exports.isDatePickerView = isDatePickerView;
+exports.mergeDateAndTime = mergeDateAndTime;
+exports.replaceInvalidDateByNull = replaceInvalidDateByNull;
+exports.resolveDateFormat = resolveDateFormat;

@@ -0,0 +1,66 @@
+'use strict';
+var timeUtils = require('./time-utils.cjs');
+var dateUtils = require('./date-utils.cjs');
+const SECTION_TYPE_GRANULARITY = {
+  year: 1,
+  month: 2,
+  day: 3,
+  hours: 4,
+  minutes: 5,
+  seconds: 6,
+  milliseconds: 7
+};
+const getSectionTypeGranularity = sections => Math.max(...sections.map(section => SECTION_TYPE_GRANULARITY[section.type] ?? 1));
+const roundDate = (adapter, granularity, date) => {
+  if (granularity === SECTION_TYPE_GRANULARITY.year) {
+    return adapter.startOfYear(date);
+  }
+  if (granularity === SECTION_TYPE_GRANULARITY.month) {
+    return adapter.startOfMonth(date);
+  }
+  if (granularity === SECTION_TYPE_GRANULARITY.day) {
+    return adapter.startOfDay(date);
+  }
+  // We don't have startOfHour / startOfMinute / startOfSecond
+  let roundedDate = date;
+  if (granularity < SECTION_TYPE_GRANULARITY.minutes) {
+    roundedDate = adapter.setMinutes(roundedDate, 0);
+  }
+  if (granularity < SECTION_TYPE_GRANULARITY.seconds) {
+    roundedDate = adapter.setSeconds(roundedDate, 0);
+  }
+  if (granularity < SECTION_TYPE_GRANULARITY.milliseconds) {
+    roundedDate = adapter.setMilliseconds(roundedDate, 0);
+  }
+  return roundedDate;
+};
+const getDefaultReferenceDate = ({
+  props,
+  adapter,
+  granularity,
+  timezone,
+  getTodayDate: inGetTodayDate
+}) => {
+  let referenceDate = inGetTodayDate ? inGetTodayDate() : roundDate(adapter, granularity, dateUtils.getTodayDate(adapter, timezone));
+  if (props.minDate != null && adapter.isAfterDay(props.minDate, referenceDate)) {
+    referenceDate = roundDate(adapter, granularity, props.minDate);
+  }
+  if (props.maxDate != null && adapter.isBeforeDay(props.maxDate, referenceDate)) {
+    referenceDate = roundDate(adapter, granularity, props.maxDate);
+  }
+  const isAfter = timeUtils.createIsAfterIgnoreDatePart(props.disableIgnoringDatePartForTimeValidation ?? false, adapter);
+  if (props.minTime != null && isAfter(props.minTime, referenceDate)) {
+    referenceDate = roundDate(adapter, granularity, props.disableIgnoringDatePartForTimeValidation ? props.minTime : dateUtils.mergeDateAndTime(adapter, referenceDate, props.minTime));
+  }
+  if (props.maxTime != null && isAfter(referenceDate, props.maxTime)) {
+    referenceDate = roundDate(adapter, granularity, props.disableIgnoringDatePartForTimeValidation ? props.maxTime : dateUtils.mergeDateAndTime(adapter, referenceDate, props.maxTime));
+  }
+  return referenceDate;
+};
+exports.SECTION_TYPE_GRANULARITY = SECTION_TYPE_GRANULARITY;
+exports.getDefaultReferenceDate = getDefaultReferenceDate;
+exports.getSectionTypeGranularity = getSectionTypeGranularity;

@@ -0,0 +1,18 @@
+'use strict';
+const EXPORTED_TIME_VIEWS = ['hours', 'minutes', 'seconds'];
+const isTimeView = view => EXPORTED_TIME_VIEWS.includes(view);
+const getSecondsInDay = (date, adapter) => {
+  return adapter.getHours(date) * 3600 + adapter.getMinutes(date) * 60 + adapter.getSeconds(date);
+};
+const createIsAfterIgnoreDatePart = (disableIgnoringDatePartForTimeValidation, adapter) => (dateLeft, dateRight) => {
+  if (disableIgnoringDatePartForTimeValidation) {
+    return adapter.isAfter(dateLeft, dateRight);
+  }
+  return getSecondsInDay(dateLeft, adapter) > getSecondsInDay(dateRight, adapter);
+};
+exports.EXPORTED_TIME_VIEWS = EXPORTED_TIME_VIEWS;
+exports.createIsAfterIgnoreDatePart = createIsAfterIgnoreDatePart;
+exports.getSecondsInDay = getSecondsInDay;
+exports.isTimeView = isTimeView;

@@ -0,0 +1,42 @@
+'use strict';
+var ownerDocument = require('../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/ownerDocument/ownerDocument.cjs');
+/* Use it instead of .includes method for IE support */
+function arrayIncludes(array, itemOrItems) {
+  if (Array.isArray(itemOrItems)) {
+    return itemOrItems.every(item => array.indexOf(item) !== -1);
+  }
+  return array.indexOf(itemOrItems) !== -1;
+}
+const executeInTheNextEventLoopTick = fn => {
+  setTimeout(fn, 0);
+};
+// https://www.abeautifulsite.net/posts/finding-the-active-element-in-a-shadow-root/
+const getActiveElementInternal = (root = document) => {
+  const activeEl = root.activeElement;
+  if (!activeEl) {
+    return null;
+  }
+  if (activeEl.shadowRoot) {
+    return getActiveElementInternal(activeEl.shadowRoot);
+  }
+  return activeEl;
+};
+/**
+ * Gets the currently active element within a given node's document.
+ * This function traverses shadow DOM if necessary.
+ * @param node - The node from which to get the active element.
+ * @returns The currently active element, or null if none is found.
+ */
+const getActiveElement = node => {
+  return getActiveElementInternal(ownerDocument.default(node));
+};
+const DEFAULT_DESKTOP_MODE_MEDIA_QUERY = '@media (pointer: fine)';
+exports.DEFAULT_DESKTOP_MODE_MEDIA_QUERY = DEFAULT_DESKTOP_MODE_MEDIA_QUERY;
+exports.arrayIncludes = arrayIncludes;
+exports.executeInTheNextEventLoopTick = executeInTheNextEventLoopTick;
+exports.getActiveElement = getActiveElement;

@@ -0,0 +1,50 @@
+'use strict';
+var _extends = require('../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.cjs');
+var objectWithoutPropertiesLoose = require('../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.cjs');
+var dateUtils = require('./date-utils.cjs');
+var getDefaultReferenceDate = require('./getDefaultReferenceDate.cjs');
+var useField_utils = require('../hooks/useField/useField.utils.cjs');
+const _excluded = ["value", "referenceDate"];
+const singleItemValueManager = {
+  emptyValue: null,
+  getTodayValue: dateUtils.getTodayDate,
+  getInitialReferenceValue: _ref => {
+    let {
+        value,
+        referenceDate
+      } = _ref,
+      params = objectWithoutPropertiesLoose.default(_ref, _excluded);
+    if (params.adapter.isValid(value)) {
+      return value;
+    }
+    if (referenceDate != null) {
+      return referenceDate;
+    }
+    return getDefaultReferenceDate.getDefaultReferenceDate(params);
+  },
+  cleanValue: dateUtils.replaceInvalidDateByNull,
+  areValuesEqual: dateUtils.areDatesEqual,
+  isSameError: (a, b) => a === b,
+  hasError: error => error != null,
+  defaultErrorState: null,
+  getTimezone: (adapter, value) => adapter.isValid(value) ? adapter.getTimezone(value) : null,
+  setTimezone: (adapter, timezone, value) => value == null ? null : adapter.setTimezone(value, timezone)
+};
+const singleItemFieldValueManager = {
+  updateReferenceValue: (adapter, value, prevReferenceValue) => adapter.isValid(value) ? value : prevReferenceValue,
+  getSectionsFromValue: (date, getSectionsFromDate) => getSectionsFromDate(date),
+  getV7HiddenInputValueFromSections: useField_utils.createDateStrForV7HiddenInputFromSections,
+  getV6InputValueFromSections: useField_utils.createDateStrForV6InputFromSections,
+  parseValueStr: (valueStr, referenceValue, parseDate) => parseDate(valueStr.trim(), referenceValue),
+  getDateFromSection: value => value,
+  getDateSectionsFromValue: sections => sections,
+  updateDateInValue: (value, activeSection, activeDate) => activeDate,
+  clearDateSections: sections => sections.map(section => _extends.default({}, section, {
+    value: ''
+  }))
+};
+exports.singleItemFieldValueManager = singleItemFieldValueManager;
+exports.singleItemValueManager = singleItemValueManager;

@@ -0,0 +1,33 @@
+'use strict';
+const areViewsEqual = (views, expectedViews) => {
+  if (views.length !== expectedViews.length) {
+    return false;
+  }
+  return expectedViews.every(expectedView => views.includes(expectedView));
+};
+const applyDefaultViewProps = ({
+  openTo,
+  defaultOpenTo,
+  views,
+  defaultViews
+}) => {
+  const viewsWithDefault = views ?? defaultViews;
+  let 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
+  };
+};
+exports.applyDefaultViewProps = applyDefaultViewProps;
+exports.areViewsEqual = areViewsEqual;