Added Statistics calculation

Statistics now show calculated values

node_modules/@mui/x-date-pickers/esm/internals/utils/createNonRangePickerStepNavigation.d.ts

@@ -0,0 +1,13 @@
+import { DateOrTimeViewWithMeridiem } from "../models/common.js";
+export declare function createNonRangePickerStepNavigation(parameters: CreateNonRangePickerStepNavigationParameters): import("./createStepNavigation.js").CreateStepNavigationReturnValue;
+export interface PickerStep {
+  /**
+   * The views that are handled inside this step.
+   * If null, all views are handled by this step.
+   */
+  views: readonly DateOrTimeViewWithMeridiem[] | null;
+}
+interface CreateNonRangePickerStepNavigationParameters {
+  steps: PickerStep[] | null;
+}
+export {};

node_modules/@mui/x-date-pickers/esm/internals/utils/createNonRangePickerStepNavigation.js

@@ -0,0 +1,24 @@
+import { createStepNavigation } from "./createStepNavigation.js";
+export function createNonRangePickerStepNavigation(parameters) {
+  const {
+    steps
+  } = parameters;
+  return 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);
+      }
+    }
+  });
+}

node_modules/@mui/x-date-pickers/esm/internals/utils/createStepNavigation.d.ts

@@ -0,0 +1,49 @@
+import { DateOrTimeViewWithMeridiem } from "../models/index.js";
+export declare const DEFAULT_STEP_NAVIGATION: {
+  hasNextStep: boolean;
+  hasSeveralSteps: boolean;
+  goToNextStep: () => void;
+  areViewsInSameStep: () => boolean;
+};
+/**
+ * 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
+ */
+export declare function createStepNavigation<TStep extends {}>(parameters: CreateStepNavigationParameters<TStep>): CreateStepNavigationReturnValue;
+interface CreateStepNavigationParameters<TStep extends {}> {
+  steps: TStep[] | null;
+  isViewMatchingStep: (view: DateOrTimeViewWithMeridiem, step: TStep) => boolean;
+  onStepChange: (parameters: UseRangePickerStepNavigationOnStepChangeParameters<TStep>) => void;
+}
+export type CreateStepNavigationReturnValue = (parameters: CreateStepNavigationReturnValueParameters) => {
+  /**
+   * Whether there is a next step.
+   */
+  hasNextStep: boolean;
+  /**
+   * Whether there are several steps.
+   */
+  hasSeveralSteps: boolean;
+  /**
+   * Go to the next step if any.
+   */
+  goToNextStep: () => void;
+  /**
+   * Whether the two views are in the same step.
+   * @param {DateOrTimeViewWithMeridiem} viewA The first view to compare.
+   * @param {DateOrTimeViewWithMeridiem} viewB The second view to compare.
+   * @returns {boolean} Whether the two views are in the same step.
+   */
+  areViewsInSameStep: (viewA: DateOrTimeViewWithMeridiem, viewB: DateOrTimeViewWithMeridiem) => boolean;
+};
+export interface CreateStepNavigationReturnValueParameters {
+  defaultView: DateOrTimeViewWithMeridiem;
+  view: DateOrTimeViewWithMeridiem;
+  views: readonly DateOrTimeViewWithMeridiem[];
+  setView: (view: any) => void;
+}
+interface UseRangePickerStepNavigationOnStepChangeParameters<TStep extends {}> extends CreateStepNavigationReturnValueParameters {
+  step: TStep;
+}
+export {};

node_modules/@mui/x-date-pickers/esm/internals/utils/createStepNavigation.js

@@ -0,0 +1,44 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+export 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
+ */
+export 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({}, 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;
+      }
+    };
+  };
+}

node_modules/@mui/x-date-pickers/esm/internals/utils/date-time-utils.d.ts

@@ -0,0 +1,26 @@
+import { DefaultizedProps } from '@mui/x-internals/types';
+import { DateOrTimeView, MuiPickersAdapter } from "../../models/index.js";
+import { DateOrTimeViewWithMeridiem } from "../models/index.js";
+import { DigitalTimePickerProps } from "../models/props/time.js";
+export declare const resolveDateTimeFormat: (adapter: MuiPickersAdapter, {
+  views,
+  format,
+  ...other
+}: {
+  format?: string;
+  views: readonly DateOrTimeViewWithMeridiem[];
+  ampm: boolean;
+}, ignoreDateResolving?: boolean) => string;
+interface DefaultizedTimeViewsProps<TView = DateOrTimeView> extends DefaultizedProps<DigitalTimePickerProps, 'ampm'> {
+  views: readonly TView[];
+}
+interface DefaultizedTimeViewsResponse<TView = DateOrTimeViewWithMeridiem> extends Required<Pick<DefaultizedTimeViewsProps<TView>, 'thresholdToRenderTimeInASingleColumn' | 'timeSteps' | 'views'>> {
+  shouldRenderTimeInASingleColumn: boolean;
+}
+export declare function resolveTimeViewsResponse<InTView extends DateOrTimeView = DateOrTimeView, OutTView extends DateOrTimeViewWithMeridiem = DateOrTimeViewWithMeridiem>({
+  thresholdToRenderTimeInASingleColumn: inThreshold,
+  ampm,
+  timeSteps: inTimeSteps,
+  views
+}: DefaultizedTimeViewsProps<InTView>): DefaultizedTimeViewsResponse<OutTView>;
+export {};

node_modules/@mui/x-date-pickers/esm/internals/utils/date-time-utils.js

@@ -0,0 +1,68 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["views", "format"];
+import { resolveTimeFormat, isTimeView, isInternalTimeView } from "./time-utils.js";
+import { isDatePickerView, resolveDateFormat } from "./date-utils.js";
+export const resolveDateTimeFormat = (adapter, _ref, ignoreDateResolving) => {
+  let {
+      views,
+      format
+    } = _ref,
+    other = _objectWithoutPropertiesLoose(_ref, _excluded);
+  if (format) {
+    return format;
+  }
+  const dateViews = [];
+  const timeViews = [];
+  views.forEach(view => {
+    if (isTimeView(view)) {
+      timeViews.push(view);
+    } else if (isDatePickerView(view)) {
+      dateViews.push(view);
+    }
+  });
+  if (timeViews.length === 0) {
+    return resolveDateFormat(adapter, _extends({
+      views: dateViews
+    }, other), false);
+  }
+  if (dateViews.length === 0) {
+    return resolveTimeFormat(adapter, _extends({
+      views: timeViews
+    }, other));
+  }
+  const timeFormat = resolveTimeFormat(adapter, _extends({
+    views: timeViews
+  }, other));
+  const dateFormat = ignoreDateResolving ? adapter.formats.keyboardDate : resolveDateFormat(adapter, _extends({
+    views: dateViews
+  }, other), false);
+  return `${dateFormat} ${timeFormat}`;
+};
+const resolveViews = (ampm, views, shouldUseSingleColumn) => {
+  if (shouldUseSingleColumn) {
+    return views.filter(view => !isInternalTimeView(view) || view === 'hours');
+  }
+  return ampm ? [...views, 'meridiem'] : views;
+};
+const resolveShouldRenderTimeInASingleColumn = (timeSteps, threshold) => 24 * 60 / ((timeSteps.hours ?? 1) * (timeSteps.minutes ?? 5)) <= threshold;
+export function resolveTimeViewsResponse({
+  thresholdToRenderTimeInASingleColumn: inThreshold,
+  ampm,
+  timeSteps: inTimeSteps,
+  views
+}) {
+  const thresholdToRenderTimeInASingleColumn = inThreshold ?? 24;
+  const timeSteps = _extends({
+    hours: 1,
+    minutes: 5,
+    seconds: 5
+  }, inTimeSteps);
+  const shouldRenderTimeInASingleColumn = resolveShouldRenderTimeInASingleColumn(timeSteps, thresholdToRenderTimeInASingleColumn);
+  return {
+    thresholdToRenderTimeInASingleColumn,
+    timeSteps,
+    shouldRenderTimeInASingleColumn,
+    views: resolveViews(ampm, views, shouldRenderTimeInASingleColumn)
+  };
+}

node_modules/@mui/x-date-pickers/esm/internals/utils/date-utils.d.ts

@@ -0,0 +1,40 @@
+import { DateView, MuiPickersAdapter, PickersTimezone, PickerValidDate, PickerValueType } from "../../models/index.js";
+import { DateOrTimeViewWithMeridiem } from "../models/index.js";
+export declare const mergeDateAndTime: (adapter: MuiPickersAdapter, dateParam: PickerValidDate, timeParam: PickerValidDate) => PickerValidDate;
+interface FindClosestDateParams {
+  date: PickerValidDate;
+  disableFuture?: boolean;
+  disablePast?: boolean;
+  maxDate: PickerValidDate;
+  minDate: PickerValidDate;
+  isDateDisabled: (date: PickerValidDate) => boolean;
+  adapter: MuiPickersAdapter;
+  timezone: PickersTimezone;
+}
+export declare const findClosestEnabledDate: ({
+  date,
+  disableFuture,
+  disablePast,
+  maxDate,
+  minDate,
+  isDateDisabled,
+  adapter,
+  timezone
+}: FindClosestDateParams) => PickerValidDate | null;
+export declare const replaceInvalidDateByNull: (adapter: MuiPickersAdapter, value: PickerValidDate | null) => PickerValidDate | null;
+export declare const applyDefaultDate: (adapter: MuiPickersAdapter, value: PickerValidDate | null | undefined, defaultValue: PickerValidDate) => PickerValidDate;
+export declare const areDatesEqual: (adapter: MuiPickersAdapter, a: PickerValidDate | null, b: PickerValidDate | null) => boolean;
+export declare const getMonthsInYear: (adapter: MuiPickersAdapter, year: PickerValidDate) => PickerValidDate[];
+export declare const getTodayDate: (adapter: MuiPickersAdapter, timezone: PickersTimezone, valueType?: PickerValueType) => PickerValidDate;
+export declare const formatMeridiem: (adapter: MuiPickersAdapter, meridiem: "am" | "pm") => string;
+export declare const DATE_VIEWS: readonly ["year", "month", "day"];
+export declare const isDatePickerView: (view: DateOrTimeViewWithMeridiem) => view is DateView;
+export declare const resolveDateFormat: (adapter: MuiPickersAdapter, {
+  format,
+  views
+}: {
+  format?: string;
+  views: readonly DateView[];
+}, isInToolbar: boolean) => string;
+export declare const getWeekdays: (adapter: MuiPickersAdapter, date: PickerValidDate) => PickerValidDate[];
+export {};

node_modules/@mui/x-date-pickers/esm/internals/utils/date-utils.js

@@ -0,0 +1,124 @@
+import { areViewsEqual } from "./views.js";
+export 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;
+};
+export 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;
+};
+export const replaceInvalidDateByNull = (adapter, value) => !adapter.isValid(value) ? null : value;
+export const applyDefaultDate = (adapter, value, defaultValue) => {
+  if (value == null || !adapter.isValid(value)) {
+    return defaultValue;
+  }
+  return value;
+};
+export const areDatesEqual = (adapter, a, b) => {
+  if (!adapter.isValid(a) && a != null && !adapter.isValid(b) && b != null) {
+    return true;
+  }
+  return adapter.isEqual(a, b);
+};
+export 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;
+};
+export const getTodayDate = (adapter, timezone, valueType) => valueType === 'date' ? adapter.startOfDay(adapter.date(undefined, timezone)) : adapter.date(undefined, timezone);
+export const formatMeridiem = (adapter, meridiem) => {
+  const date = adapter.setHours(adapter.date(), meridiem === 'am' ? 2 : 14);
+  return adapter.format(date, 'meridiem');
+};
+export const DATE_VIEWS = ['year', 'month', 'day'];
+export const isDatePickerView = view => DATE_VIEWS.includes(view);
+export const resolveDateFormat = (adapter, {
+  format,
+  views
+}, isInToolbar) => {
+  if (format != null) {
+    return format;
+  }
+  const formats = adapter.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 `${formats.month} ${formats.year}`;
+  }
+  if (areViewsEqual(views, ['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;
+};
+export const getWeekdays = (adapter, date) => {
+  const start = adapter.startOfWeek(date);
+  return [0, 1, 2, 3, 4, 5, 6].map(diff => adapter.addDays(start, diff));
+};

node_modules/@mui/x-date-pickers/esm/internals/utils/getDefaultReferenceDate.d.ts

@@ -0,0 +1,31 @@
+import { FieldSection, MuiPickersAdapter, PickersTimezone, PickerValidDate } from "../../models/index.js";
+export interface GetDefaultReferenceDateProps {
+  maxDate?: PickerValidDate;
+  minDate?: PickerValidDate;
+  minTime?: PickerValidDate;
+  maxTime?: PickerValidDate;
+  disableIgnoringDatePartForTimeValidation?: boolean;
+}
+export declare const SECTION_TYPE_GRANULARITY: {
+  year: number;
+  month: number;
+  day: number;
+  hours: number;
+  minutes: number;
+  seconds: number;
+  milliseconds: number;
+};
+export declare const getSectionTypeGranularity: (sections: FieldSection[]) => number;
+export declare const getDefaultReferenceDate: ({
+  props,
+  adapter,
+  granularity,
+  timezone,
+  getTodayDate: inGetTodayDate
+}: {
+  props: GetDefaultReferenceDateProps;
+  adapter: MuiPickersAdapter;
+  granularity: number;
+  timezone: PickersTimezone;
+  getTodayDate?: () => PickerValidDate;
+}) => PickerValidDate;

node_modules/@mui/x-date-pickers/esm/internals/utils/getDefaultReferenceDate.js

@@ -0,0 +1,59 @@
+import { createIsAfterIgnoreDatePart } from "./time-utils.js";
+import { mergeDateAndTime, getTodayDate } from "./date-utils.js";
+export const SECTION_TYPE_GRANULARITY = {
+  year: 1,
+  month: 2,
+  day: 3,
+  hours: 4,
+  minutes: 5,
+  seconds: 6,
+  milliseconds: 7
+};
+export 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;
+};
+export const getDefaultReferenceDate = ({
+  props,
+  adapter,
+  granularity,
+  timezone,
+  getTodayDate: inGetTodayDate
+}) => {
+  let referenceDate = inGetTodayDate ? inGetTodayDate() : roundDate(adapter, granularity, 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 = createIsAfterIgnoreDatePart(props.disableIgnoringDatePartForTimeValidation ?? false, adapter);
+  if (props.minTime != null && isAfter(props.minTime, referenceDate)) {
+    referenceDate = roundDate(adapter, granularity, props.disableIgnoringDatePartForTimeValidation ? props.minTime : mergeDateAndTime(adapter, referenceDate, props.minTime));
+  }
+  if (props.maxTime != null && isAfter(referenceDate, props.maxTime)) {
+    referenceDate = roundDate(adapter, granularity, props.disableIgnoringDatePartForTimeValidation ? props.maxTime : mergeDateAndTime(adapter, referenceDate, props.maxTime));
+  }
+  return referenceDate;
+};

node_modules/@mui/x-date-pickers/esm/internals/utils/time-utils.d.ts

@@ -0,0 +1,21 @@
+import { MuiPickersAdapter, PickerValidDate } from "../../models/index.js";
+import { DateOrTimeViewWithMeridiem, TimeViewWithMeridiem } from "../models/index.js";
+export declare const EXPORTED_TIME_VIEWS: readonly ["hours", "minutes", "seconds"];
+export declare const TIME_VIEWS: readonly ["hours", "minutes", "seconds", "meridiem"];
+export declare const isTimeView: (view: DateOrTimeViewWithMeridiem) => boolean;
+export declare const isInternalTimeView: (view: DateOrTimeViewWithMeridiem) => view is TimeViewWithMeridiem;
+export type Meridiem = 'am' | 'pm';
+export declare const getMeridiem: (date: PickerValidDate | null, adapter: MuiPickersAdapter) => Meridiem | null;
+export declare const convertValueToMeridiem: (value: number, meridiem: Meridiem | null, ampm: boolean) => number;
+export declare const convertToMeridiem: (time: PickerValidDate, meridiem: Meridiem, ampm: boolean, adapter: MuiPickersAdapter) => PickerValidDate;
+export declare const getSecondsInDay: (date: PickerValidDate, adapter: MuiPickersAdapter) => number;
+export declare const createIsAfterIgnoreDatePart: (disableIgnoringDatePartForTimeValidation: boolean, adapter: MuiPickersAdapter) => (dateLeft: PickerValidDate, dateRight: PickerValidDate) => boolean;
+export declare const resolveTimeFormat: (adapter: MuiPickersAdapter, {
+  format,
+  views,
+  ampm
+}: {
+  format?: string;
+  views: readonly TimeViewWithMeridiem[];
+  ampm: boolean;
+}) => string;

node_modules/@mui/x-date-pickers/esm/internals/utils/time-utils.js

@@ -0,0 +1,59 @@
+import { areViewsEqual } from "./views.js";
+export const EXPORTED_TIME_VIEWS = ['hours', 'minutes', 'seconds'];
+export const TIME_VIEWS = ['hours', 'minutes', 'seconds', 'meridiem'];
+export const isTimeView = view => EXPORTED_TIME_VIEWS.includes(view);
+export const isInternalTimeView = view => TIME_VIEWS.includes(view);
+export const getMeridiem = (date, adapter) => {
+  if (!date) {
+    return null;
+  }
+  return adapter.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, adapter) => {
+  const newHoursAmount = convertValueToMeridiem(adapter.getHours(time), meridiem, ampm);
+  return adapter.setHours(time, newHoursAmount);
+};
+export const getSecondsInDay = (date, adapter) => {
+  return adapter.getHours(date) * 3600 + adapter.getMinutes(date) * 60 + adapter.getSeconds(date);
+};
+export const createIsAfterIgnoreDatePart = (disableIgnoringDatePartForTimeValidation, adapter) => (dateLeft, dateRight) => {
+  if (disableIgnoringDatePartForTimeValidation) {
+    return adapter.isAfter(dateLeft, dateRight);
+  }
+  return getSecondsInDay(dateLeft, adapter) > getSecondsInDay(dateRight, adapter);
+};
+export const resolveTimeFormat = (adapter, {
+  format,
+  views,
+  ampm
+}) => {
+  if (format != null) {
+    return format;
+  }
+  const formats = adapter.formats;
+  if (areViewsEqual(views, ['hours'])) {
+    return ampm ? `${formats.hours12h} ${formats.meridiem}` : formats.hours24h;
+  }
+  if (areViewsEqual(views, ['minutes'])) {
+    return formats.minutes;
+  }
+  if (areViewsEqual(views, ['seconds'])) {
+    return formats.seconds;
+  }
+  if (areViewsEqual(views, ['minutes', 'seconds'])) {
+    return `${formats.minutes}:${formats.seconds}`;
+  }
+  if (areViewsEqual(views, ['hours', 'minutes', 'seconds'])) {
+    return ampm ? `${formats.hours12h}:${formats.minutes}:${formats.seconds} ${formats.meridiem}` : `${formats.hours24h}:${formats.minutes}:${formats.seconds}`;
+  }
+  return ampm ? `${formats.hours12h}:${formats.minutes} ${formats.meridiem}` : `${formats.hours24h}:${formats.minutes}`;
+};

node_modules/@mui/x-date-pickers/esm/internals/utils/utils.d.ts

@@ -0,0 +1,22 @@
+import { Theme } from '@mui/material/styles';
+import { SxProps, SystemStyleObject } from '@mui/system';
+import * as React from 'react';
+export declare function arrayIncludes<T>(array: T[] | readonly T[], itemOrItems: T | T[]): boolean;
+export declare const onSpaceOrEnter: (innerFn: (ev: React.MouseEvent<any> | React.KeyboardEvent<any>) => void, externalEvent?: (event: React.KeyboardEvent<any>) => void) => (event: React.KeyboardEvent) => void;
+export declare const executeInTheNextEventLoopTick: (fn: () => void) => void;
+/**
+ * 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.
+ */
+export declare const getActiveElement: (node: Node | null | undefined) => Element | null;
+/**
+ * Gets the index of the focused list item in a given ul list element.
+ *
+ * @param {HTMLUListElement} listElement - The list element to search within.
+ * @returns {number} The index of the focused list item, or -1 if none is focused.
+ */
+export declare const getFocusedListItemIndex: (listElement: HTMLUListElement) => number;
+export declare const DEFAULT_DESKTOP_MODE_MEDIA_QUERY = "@media (pointer: fine)";
+export declare function mergeSx(...sxProps: (SxProps<Theme> | undefined)[]): ReadonlyArray<boolean | SystemStyleObject<Theme> | ((theme: Theme) => SystemStyleObject<Theme>)>;

node_modules/@mui/x-date-pickers/esm/internals/utils/utils.js

@@ -0,0 +1,67 @@
+import ownerDocument from '@mui/utils/ownerDocument';
+/* 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, externalEvent) => event => {
+  if (event.key === 'Enter' || event.key === ' ') {
+    innerFn(event);
+
+    // prevent any side effects
+    event.preventDefault();
+    event.stopPropagation();
+  }
+  if (externalEvent) {
+    externalEvent(event);
+  }
+};
+export 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.
+ */
+export const getActiveElement = node => {
+  return getActiveElementInternal(ownerDocument(node));
+};
+
+/**
+ * Gets the index of the focused list item in a given ul list element.
+ *
+ * @param {HTMLUListElement} listElement - The list element to search within.
+ * @returns {number} The index of the focused list item, or -1 if none is focused.
+ */
+export const getFocusedListItemIndex = listElement => {
+  const children = Array.from(listElement.children);
+  return children.indexOf(getActiveElement(listElement));
+};
+export const DEFAULT_DESKTOP_MODE_MEDIA_QUERY = '@media (pointer: fine)';
+export function mergeSx(...sxProps) {
+  return sxProps.reduce((acc, sxProp) => {
+    if (Array.isArray(sxProp)) {
+      acc.push(...sxProp);
+    } else if (sxProp != null) {
+      acc.push(sxProp);
+    }
+    return acc;
+  }, []);
+}

node_modules/@mui/x-date-pickers/esm/internals/utils/valueManagers.d.ts

@@ -0,0 +1,7 @@
+import type { PickerValueManager } from "../models/index.js";
+import { DateValidationError, TimeValidationError, DateTimeValidationError } from "../../models/index.js";
+import type { FieldValueManager } from "../hooks/useField/index.js";
+import { PickerValue } from "../models/index.js";
+export type SingleItemPickerValueManager<TError extends DateValidationError | TimeValidationError | DateTimeValidationError = any> = PickerValueManager<PickerValue, TError>;
+export declare const singleItemValueManager: SingleItemPickerValueManager;
+export declare const singleItemFieldValueManager: FieldValueManager<PickerValue>;

node_modules/@mui/x-date-pickers/esm/internals/utils/valueManagers.js

@@ -0,0 +1,44 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["value", "referenceDate"];
+import { areDatesEqual, getTodayDate, replaceInvalidDateByNull } from "./date-utils.js";
+import { getDefaultReferenceDate } from "./getDefaultReferenceDate.js";
+import { createDateStrForV7HiddenInputFromSections, createDateStrForV6InputFromSections } from "../hooks/useField/useField.utils.js";
+export const singleItemValueManager = {
+  emptyValue: null,
+  getTodayValue: getTodayDate,
+  getInitialReferenceValue: _ref => {
+    let {
+        value,
+        referenceDate
+      } = _ref,
+      params = _objectWithoutPropertiesLoose(_ref, _excluded);
+    if (params.adapter.isValid(value)) {
+      return value;
+    }
+    if (referenceDate != null) {
+      return referenceDate;
+    }
+    return getDefaultReferenceDate(params);
+  },
+  cleanValue: replaceInvalidDateByNull,
+  areValuesEqual: 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)
+};
+export const singleItemFieldValueManager = {
+  updateReferenceValue: (adapter, value, prevReferenceValue) => adapter.isValid(value) ? value : prevReferenceValue,
+  getSectionsFromValue: (date, getSectionsFromDate) => getSectionsFromDate(date),
+  getV7HiddenInputValueFromSections: createDateStrForV7HiddenInputFromSections,
+  getV6InputValueFromSections: 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({}, section, {
+    value: ''
+  }))
+};

node_modules/@mui/x-date-pickers/esm/internals/utils/views.d.ts

@@ -0,0 +1,16 @@
+import { DateOrTimeViewWithMeridiem } from "../models/index.js";
+export declare const areViewsEqual: <TView extends DateOrTimeViewWithMeridiem>(views: ReadonlyArray<DateOrTimeViewWithMeridiem>, expectedViews: TView[]) => views is ReadonlyArray<TView>;
+export declare const applyDefaultViewProps: <TView extends DateOrTimeViewWithMeridiem>({
+  openTo,
+  defaultOpenTo,
+  views,
+  defaultViews
+}: {
+  openTo: TView | undefined;
+  defaultOpenTo: TView;
+  views: readonly TView[] | undefined;
+  defaultViews: readonly TView[];
+}) => {
+  views: readonly TView[];
+  openTo: TView;
+};

node_modules/@mui/x-date-pickers/esm/internals/utils/views.js

@@ -0,0 +1,28 @@
+export const areViewsEqual = (views, expectedViews) => {
+  if (views.length !== expectedViews.length) {
+    return false;
+  }
+  return expectedViews.every(expectedView => views.includes(expectedView));
+};
+export 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
+  };
+};