@mui/x-date-pickers 8.0.0-alpha.9 → 8.0.0-beta.0

package/modern/internals/models/manager.d.ts

@@ -0,0 +1,119 @@
+import type { MuiPickersAdapter, PickerManager, PickersTimezone, PickerValidDate, PickerValueType } from '../../models';
+import type { GetDefaultReferenceDateProps } from '../utils/getDefaultReferenceDate';
+import { InferNonNullablePickerValue, PickerValidValue } from "./value.js";
+import type { UseFieldInternalProps } from '../hooks/useField';
+export type PickerAnyManager = PickerManager<any, any, any, any, any>;
+type PickerManagerProperties<TManager extends PickerAnyManager> = TManager extends PickerManager<infer TValue, infer TEnableAccessibleFieldDOMStructure, infer TError, infer TValidationProps, infer TFieldInternalProps> ? {
+  value: TValue;
+  enableAccessibleFieldDOMStructure: TEnableAccessibleFieldDOMStructure;
+  error: TError;
+  validationProps: TValidationProps;
+  fieldInternalProps: TFieldInternalProps;
+} : never;
+export type PickerManagerValue<TManager extends PickerAnyManager> = PickerManagerProperties<TManager>['value'];
+export type PickerManagerError<TManager extends PickerAnyManager> = PickerManagerProperties<TManager>['error'];
+export type PickerManagerFieldInternalProps<TManager extends PickerAnyManager> = PickerManagerProperties<TManager>['fieldInternalProps'];
+export type PickerManagerValidationProps<TManager extends PickerAnyManager> = PickerManagerProperties<TManager>['validationProps'];
+export type PickerManagerFieldInternalPropsWithDefaults<TManager extends PickerAnyManager> = UseFieldInternalProps<PickerManagerValue<TManager>, PickerManagerEnableAccessibleFieldDOMStructure<TManager>, PickerManagerError<TManager>> & PickerManagerValidationProps<TManager>;
+export type PickerManagerEnableAccessibleFieldDOMStructure<TManager extends PickerAnyManager> = PickerManagerProperties<TManager>['enableAccessibleFieldDOMStructure'];
+export interface PickerValueManager<TValue extends PickerValidValue, TError> {
+  /**
+   * Determines if two values are equal.
+   * @template TValue The value type. It will be the same type as `value` or `null`. It can be in `[start, end]` format in case of range value.
+   * @param {MuiPickersAdapter} utils The adapter.
+   * @param {TValue} valueLeft The first value to compare.
+   * @param {TValue} valueRight The second value to compare.
+   * @returns {boolean} A boolean indicating if the two values are equal.
+   */
+  areValuesEqual: (utils: MuiPickersAdapter, valueLeft: TValue, valueRight: TValue) => boolean;
+  /**
+   * Value to set when clicking the "Clear" button.
+   */
+  emptyValue: TValue;
+  /**
+   * Method returning the value to set when clicking the "Today" button.
+   * @template TValue The value type. It will be the same type as `value` or `null`. It can be in `[start, end]` format in case of range value.
+   * @param {MuiPickersAdapter} utils The adapter.
+   * @param {PickersTimezone} timezone The current timezone.
+   * @param {PickerValueType} valueType The type of the value being edited.
+   * @returns {TValue} The value to set when clicking the "Today" button.
+   */
+  getTodayValue: (utils: MuiPickersAdapter, timezone: PickersTimezone, valueType: PickerValueType) => TValue;
+  /**
+   * @template TValue The value type. It will be the same type as `value` or `null`. It can be in `[start, end]` format in case of range value.
+   * Method returning the reference value to use when mounting the component.
+   * @param {object} params The params of the method.
+   * @param {PickerValidDate | undefined} params.referenceDate The referenceDate provided by the user.
+   * @param {TValue} params.value The value provided by the user.
+   * @param {GetDefaultReferenceDateProps} params.props The validation props needed to compute the reference value.
+   * @param {MuiPickersAdapter} params.utils The adapter.
+   * @param {number} params.granularity The granularity of the selection possible on this component.
+   * @param {PickersTimezone} params.timezone The current timezone.
+   * @param {() => PickerValidDate} params.getTodayDate The reference date to use if no reference date is passed to the component.
+   * @returns {TValue} The reference value to use for non-provided dates.
+   */
+  getInitialReferenceValue: (params: {
+    referenceDate: PickerValidDate | undefined;
+    value: TValue;
+    props: GetDefaultReferenceDateProps;
+    utils: MuiPickersAdapter;
+    granularity: number;
+    timezone: PickersTimezone;
+    getTodayDate?: () => PickerValidDate;
+  }) => InferNonNullablePickerValue<TValue>;
+  /**
+   * Method parsing the input value to replace all invalid dates by `null`.
+   * @template TValue The value type. It will be the same type as `value` or `null`. It can be in `[start, end]` format in case of range value.
+   * @param {MuiPickersAdapter} utils The adapter.
+   * @param {TValue} value The value to parse.
+   * @returns {TValue} The value without invalid date.
+   */
+  cleanValue: (utils: MuiPickersAdapter, value: TValue) => TValue;
+  /**
+   * Generates the new value, given the previous value and the new proposed value.
+   * @template TValue The value type. It will be the same type as `value` or `null`. It can be in `[start, end]` format in case of range value.
+   * @param {MuiPickersAdapter} utils The adapter.
+   * @param {TValue} lastValidDateValue The last valid value.
+   * @param {TValue} value The proposed value.
+   * @returns {TValue} The new value.
+   */
+  valueReducer?: (utils: MuiPickersAdapter, lastValidDateValue: TValue, value: TValue) => TValue;
+  /**
+   * Compare two errors to know if they are equal.
+   * @template TError
+   * @param {TError} error The new error
+   * @param {TError | null} prevError The previous error
+   * @returns {boolean} `true` if the new error is different from the previous one.
+   */
+  isSameError: (error: TError, prevError: TError | null) => boolean;
+  /**
+   * Checks if the current error is empty or not.
+   * @template TError
+   * @param {TError} error The current error.
+   * @returns {boolean} `true` if the current error is not empty.
+   */
+  hasError: (error: TError) => boolean;
+  /**
+   * The value identifying no error, used to initialize the error state.
+   */
+  defaultErrorState: TError;
+  /**
+     * Return the timezone of the date inside a value.
+     * When used on a range Picker, throw an error if both values don't have the same timezone.
+     * @template TValue The value type. It will be the same type as `value` or `null`. It can be in `[start, end]` format in case of range value.
+     @param {MuiPickersAdapter} utils The utils to manipulate the date.
+     @param {TValue} value The current value.
+     @returns {string | null} The timezone of the current value.
+     */
+  getTimezone: (utils: MuiPickersAdapter, value: TValue) => string | null;
+  /**
+     * Change the timezone of the dates inside a value.
+     * @template TValue The value type. It will be the same type as `value` or `null`. It can be in `[start, end]` format in case of range value.
+     @param {MuiPickersAdapter} utils The utils to manipulate the date.
+     @param {PickersTimezone} timezone The current timezone.
+     @param {TValue} value The value to convert.
+     @returns {TValue} The value with the new dates in the new timezone.
+     */
+  setTimezone: (utils: MuiPickersAdapter, timezone: PickersTimezone, value: TValue) => TValue;
+}
+export {};

package/modern/internals/models/pickers.d.ts

@@ -0,0 +1 @@
+export type RangePosition = 'start' | 'end';

package/modern/internals/models/props/basePickerProps.d.ts

@@ -0,0 +1,27 @@
+import { Theme } from '@mui/material/styles';
+import { SxProps } from '@mui/system';
+import { MakeOptional } from '@mui/x-internals/types';
+import { UsePickerBaseProps } from "../../hooks/usePicker/index.js";
+import { PickersInputComponentLocaleText } from "../../../locales/utils/pickersLocaleTextApi.js";
+import type { UsePickerProps } from '../../hooks/usePicker';
+import { DateOrTimeViewWithMeridiem } from "../common.js";
+import { PickerValidValue } from "../value.js";
+/**
+ * Props common to all pickers after applying the default props on each Picker.
+ */
+export interface BasePickerProps<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem, TError, TExternalProps extends UsePickerProps<TValue, TView, TError, any>> extends UsePickerBaseProps<TValue, TView, TError, TExternalProps> {
+  className?: string;
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx?: SxProps<Theme>;
+  /**
+   * Locale for components texts.
+   * Allows overriding texts coming from `LocalizationProvider` and `theme`.
+   */
+  localeText?: PickersInputComponentLocaleText;
+}
+/**
+ * Props common to all pickers before applying the default props on each Picker.
+ */
+export interface BasePickerInputProps<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem, TError> extends Omit<MakeOptional<BasePickerProps<TValue, TView, TError, any>, 'openTo' | 'views'>, 'viewRenderers'> {}

package/modern/internals/models/props/tabs.d.ts

@@ -0,0 +1,9 @@
+import { SxProps } from '@mui/system';
+import { Theme } from '@mui/material/styles';
+export interface ExportedBaseTabsProps {
+  className?: string;
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx?: SxProps<Theme>;
+}

package/modern/internals/models/props/time.d.ts

@@ -0,0 +1,77 @@
+import { SxProps, Theme } from '@mui/material/styles';
+import { PickerValidDate, TimeStepOptions, TimezoneProps } from "../../../models/index.js";
+import type { ExportedDigitalClockProps } from '../../../DigitalClock/DigitalClock.types';
+import type { ExportedMultiSectionDigitalClockProps } from '../../../MultiSectionDigitalClock/MultiSectionDigitalClock.types';
+import type { ExportedUseViewsOptions } from '../../hooks/useViews';
+import { TimeViewWithMeridiem } from "../common.js";
+import { ExportedValidateTimeProps } from "../../../validation/validateTime.js";
+import { FormProps } from "../formProps.js";
+import { PickerValue } from "../value.js";
+export interface AmPmProps {
+  /**
+   * 12h/24h view for hour selection clock.
+   * @default utils.is12HourCycleInCurrentLocale()
+   */
+  ampm?: boolean;
+}
+export interface ExportedBaseClockProps extends ExportedValidateTimeProps, TimezoneProps, AmPmProps {}
+export interface BaseClockProps<TView extends TimeViewWithMeridiem> extends ExportedUseViewsOptions<PickerValue, TView>, ExportedBaseClockProps, FormProps {
+  className?: string;
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx?: SxProps<Theme>;
+  /**
+   * The selected value.
+   * Used when the component is controlled.
+   */
+  value?: PickerValidDate | null;
+  /**
+   * The default selected value.
+   * Used when the component is not controlled.
+   */
+  defaultValue?: PickerValidDate | null;
+  /**
+   * The date used to generate the new value when both `value` and `defaultValue` are empty.
+   * @default The closest valid time using the validation props, except callbacks such as `shouldDisableTime`.
+   */
+  referenceDate?: PickerValidDate;
+}
+export interface DigitalTimePickerProps extends Omit<ExportedDigitalClockProps, 'timeStep'>, Omit<ExportedMultiSectionDigitalClockProps, 'timeSteps'> {
+  /**
+   * Amount of time options below or at which the single column time renderer is used.
+   * @default 24
+   */
+  thresholdToRenderTimeInASingleColumn?: number;
+  /**
+   * The time steps between two time unit options.
+   * For example, if `timeStep.minutes = 8`, then the available minute options will be `[0, 8, 16, 24, 32, 40, 48, 56]`.
+   * When single column time renderer is used, only `timeStep.minutes` will be used.
+   * @default{ hours: 1, minutes: 5, seconds: 5 }
+   */
+  timeSteps?: TimeStepOptions;
+}
+interface DigitalClockOnlyBaseProps {
+  /**
+   * If `true`, disabled digital clock items will not be rendered.
+   * @default false
+   */
+  skipDisabled?: boolean;
+}
+export interface DigitalClockOnlyProps extends DigitalClockOnlyBaseProps {
+  /**
+   * The time steps between two time options.
+   * For example, if `timeStep = 45`, then the available time options will be `[00:00, 00:45, 01:30, 02:15, 03:00, etc.]`.
+   * @default 30
+   */
+  timeStep?: number;
+}
+export interface MultiSectionDigitalClockOnlyProps extends DigitalClockOnlyBaseProps {
+  /**
+   * The time steps between two time unit options.
+   * For example, if `timeStep.minutes = 8`, then the available minute options will be `[0, 8, 16, 24, 32, 40, 48, 56]`.
+   * @default{ hours: 1, minutes: 5, seconds: 5 }
+   */
+  timeSteps?: TimeStepOptions;
+}
+export {};

package/modern/internals/models/props/toolbar.d.ts

@@ -0,0 +1,27 @@
+import * as React from 'react';
+import { SxProps } from '@mui/system';
+import { Theme } from '@mui/material/styles';
+export interface BaseToolbarProps extends ExportedBaseToolbarProps {
+  titleId?: string;
+}
+export interface ExportedBaseToolbarProps {
+  /**
+   * Toolbar date format.
+   */
+  toolbarFormat?: string;
+  /**
+   * Toolbar value placeholder—it is displayed when the value is empty.
+   * @default "––"
+   */
+  toolbarPlaceholder?: React.ReactNode;
+  className?: string;
+  /**
+   * If `true`, show the toolbar even in desktop mode.
+   * @default `true` for Desktop, `false` for Mobile.
+   */
+  hidden?: boolean;
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx?: SxProps<Theme>;
+}

package/modern/internals/models/validation.d.ts

@@ -0,0 +1,116 @@
+import type { PickerValidDate, TimeView } from '../../models';
+interface FutureAndPastValidationProps {
+  /**
+   * If `true`, disable values before the current date for date components, time for time components and both for date time components.
+   * @default false
+   */
+  disablePast?: boolean;
+  /**
+   * If `true`, disable values after the current date for date components, time for time components and both for date time components.
+   * @default false
+   */
+  disableFuture?: boolean;
+}
+/**
+ * Validation props common to all the time views.
+ * All these props have a default value when used inside a Field / Picker / Clock.
+ */
+export interface BaseTimeValidationProps extends FutureAndPastValidationProps {}
+/**
+ * Props used to validate a time value.
+ */
+export interface TimeValidationProps {
+  /**
+   * Minimal selectable time.
+   * The date part of the object will be ignored unless `props.disableIgnoringDatePartForTimeValidation === true`.
+   */
+  minTime?: PickerValidDate;
+  /**
+   * Maximal selectable time.
+   * The date part of the object will be ignored unless `props.disableIgnoringDatePartForTimeValidation === true`.
+   */
+  maxTime?: PickerValidDate;
+  /**
+   * Step over minutes.
+   * @default 1
+   */
+  minutesStep?: number;
+  /**
+   * Disable specific time.
+   * @param {PickerValidDate} value The value to check.
+   * @param {TimeView} view The clock type of the timeValue.
+   * @returns {boolean} If `true` the time will be disabled.
+   */
+  shouldDisableTime?: (value: PickerValidDate, view: TimeView) => boolean;
+  /**
+   * Do not ignore date part when validating min/max time.
+   * @default false
+   */
+  disableIgnoringDatePartForTimeValidation?: boolean;
+}
+/**
+ * Validation props common to all the date views.
+ * All these props have a default value when used inside a Field / Picker / Calendar.
+ */
+export interface BaseDateValidationProps extends FutureAndPastValidationProps {
+  /**
+   * Maximal selectable date.
+   * @default 2099-12-31
+   */
+  maxDate?: PickerValidDate;
+  /**
+   * Minimal selectable date.
+   * @default 1900-01-01
+   */
+  minDate?: PickerValidDate;
+}
+/**
+ * Props used to validate a date value (validates day + month + year).
+ */
+export interface DayValidationProps {
+  /**
+   * Disable specific date.
+   *
+   * Warning: This function can be called multiple times (for example when rendering date calendar, checking if focus can be moved to a certain date, etc.). Expensive computations can impact performance.
+   *
+   * @param {PickerValidDate} day The date to test.
+   * @returns {boolean} If `true` the date will be disabled.
+   */
+  shouldDisableDate?: (day: PickerValidDate) => boolean;
+}
+/**
+ * Props used to validate a month value
+ */
+export interface MonthValidationProps {
+  /**
+   * Disable specific month.
+   * @param {PickerValidDate} month The month to test.
+   * @returns {boolean} If `true`, the month will be disabled.
+   */
+  shouldDisableMonth?: (month: PickerValidDate) => boolean;
+}
+/**
+ * Props used to validate a year value
+ */
+export interface YearValidationProps {
+  /**
+   * Disable specific year.
+   * @param {PickerValidDate} year The year to test.
+   * @returns {boolean} If `true`, the year will be disabled.
+   */
+  shouldDisableYear?: (year: PickerValidDate) => boolean;
+}
+/**
+ * Props used to validate a date time value.
+ */
+export interface DateTimeValidationProps {
+  /**
+   * Minimal selectable moment of time with binding to date, to set min time in each day use `minTime`.
+   */
+  minDateTime?: PickerValidDate;
+  /**
+   * Maximal selectable moment of time with binding to date, to set max time in each day use `maxTime`.
+   */
+  maxDateTime?: PickerValidDate;
+}
+export {};

package/modern/internals/models/value.d.ts

@@ -0,0 +1,12 @@
+import { PickerValidDate } from "../../models/pickers.js";
+/**
+ * The type that the `value` and `defaultValue` props can receive on non-range components (date, time and date-time).
+ */
+export type PickerValue = PickerValidDate | null;
+/**
+ * The type that the `value` and `defaultValue` props can receive on range components (date-range, time-range and date-time-range).
+ */
+export type PickerRangeValue = [PickerValidDate | null, PickerValidDate | null];
+export type PickerNonNullableRangeValue = [PickerValidDate, PickerValidDate];
+export type PickerValidValue = PickerValue | PickerRangeValue;
+export type InferNonNullablePickerValue<TValue extends PickerValidValue> = TValue extends PickerRangeValue ? TValue extends PickerValue ? PickerValidDate | PickerNonNullableRangeValue : PickerNonNullableRangeValue : PickerValidDate;

package/modern/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: (utils: 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 {};

package/modern/internals/utils/date-utils.d.ts

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

package/modern/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,
+  utils,
+  granularity,
+  timezone,
+  getTodayDate: inGetTodayDate
+}: {
+  props: GetDefaultReferenceDateProps;
+  utils: MuiPickersAdapter;
+  granularity: number;
+  timezone: PickersTimezone;
+  getTodayDate?: () => PickerValidDate;
+}) => PickerValidDate;

package/modern/internals/utils/time-utils.d.ts

@@ -0,0 +1,19 @@
+import { MuiPickersAdapter, PickerValidDate } from "../../models/index.js";
+import { DateOrTimeViewWithMeridiem, TimeViewWithMeridiem } from "../models/index.js";
+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, utils: 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, utils: MuiPickersAdapter) => PickerValidDate;
+export declare const getSecondsInDay: (date: PickerValidDate, utils: MuiPickersAdapter) => number;
+export declare const createIsAfterIgnoreDatePart: (disableIgnoringDatePartForTimeValidation: boolean, utils: MuiPickersAdapter) => (dateLeft: PickerValidDate, dateRight: PickerValidDate) => boolean;
+export declare const resolveTimeFormat: (utils: MuiPickersAdapter, {
+  format,
+  views,
+  ampm
+}: {
+  format?: string;
+  views: readonly TimeViewWithMeridiem[];
+  ampm: boolean;
+}) => string;

package/modern/internals/utils/utils.d.ts

@@ -0,0 +1,16 @@
+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;
+export declare const getActiveElement: (root?: Document | ShadowRoot) => 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>)>;

package/modern/internals/utils/utils.js

@@ -43,4 +43,14 @@ export const getFocusedListItemIndex = listElement => {
   const children = Array.from(listElement.children);
   return children.indexOf(getActiveElement(document));
 };
-export const DEFAULT_DESKTOP_MODE_MEDIA_QUERY = '@media (pointer: fine)';
+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;
+  }, []);
+}

package/modern/internals/utils/valueManagers.d.ts

@@ -0,0 +1,7 @@
+import type { PickerValueManager } from '../models';
+import { DateValidationError, TimeValidationError, DateTimeValidationError } from "../../models/index.js";
+import type { FieldValueManager } from '../hooks/useField';
+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>;

package/modern/internals/utils/valueManagers.js

@@ -1,3 +1,4 @@
+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";
@@ -29,24 +30,15 @@ export const singleItemValueManager = {
   setTimezone: (utils, timezone, value) => value == null ? null : utils.setTimezone(value, timezone)
 };
 export const singleItemFieldValueManager = {
-  updateReferenceValue: (utils, value, prevReferenceValue) => !utils.isValid(value) ? prevReferenceValue : value,
-  getSectionsFromValue: (utils, date, prevSections, getSectionsFromDate) => {
-    const shouldReUsePrevDateSections = !utils.isValid(date) && !!prevSections;
-    if (shouldReUsePrevDateSections) {
-      return prevSections;
-    }
-    return getSectionsFromDate(date);
-  },
+  updateReferenceValue: (utils, value, prevReferenceValue) => utils.isValid(value) ? value : prevReferenceValue,
+  getSectionsFromValue: (date, getSectionsFromDate) => getSectionsFromDate(date),
   getV7HiddenInputValueFromSections: createDateStrForV7HiddenInputFromSections,
   getV6InputValueFromSections: createDateStrForV6InputFromSections,
-  getActiveDateManager: (utils, state) => ({
-    date: state.value,
-    referenceDate: state.referenceValue,
-    getSections: sections => sections,
-    getNewValuesFromNewActiveDate: newActiveDate => ({
-      value: newActiveDate,
-      referenceValue: utils.isValid(newActiveDate) ? newActiveDate : state.referenceValue
-    })
-  }),
-  parseValueStr: (valueStr, referenceValue, parseDate) => parseDate(valueStr.trim(), referenceValue)
+  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: ''
+  }))
 };

package/modern/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;
+};