@mui/x-date-pickers 8.0.0-alpha.6 → 8.0.0-alpha.7

package/managers/index.d.ts

@@ -0,0 +1,6 @@
+export { useDateManager } from './useDateManager';
+export type { UseDateManagerReturnValue, UseDateManagerParameters } from './useDateManager';
+export { useTimeManager } from './useTimeManager';
+export type { UseTimeManagerReturnValue, UseTimeManagerParameters } from './useTimeManager';
+export { useDateTimeManager } from './useDateTimeManager';
+export type { UseDateTimeManagerReturnValue, UseDateTimeManagerParameters, } from './useDateTimeManager';

package/managers/index.js

@@ -0,0 +1,3 @@
+export { useDateManager } from "./useDateManager.js";
+export { useTimeManager } from "./useTimeManager.js";
+export { useDateTimeManager } from "./useDateTimeManager.js";

package/managers/package.json

@@ -0,0 +1,6 @@
+{
+  "sideEffects": false,
+  "module": "./index.js",
+  "main": "../node/managers/index.js",
+  "types": "./index.d.ts"
+}

package/managers/useDateManager.d.ts

@@ -0,0 +1,27 @@
+import type { MakeOptional } from '@mui/x-internals/types';
+import { PickerManager, DateValidationError } from '../models';
+import { UseFieldInternalProps } from '../internals/hooks/useField';
+import { MuiPickersAdapterContextValue } from '../LocalizationProvider/LocalizationProvider';
+import { ExportedValidateDateProps, ValidateDatePropsToDefault, ValidateDateProps } from '../validation/validateDate';
+import { PickerValue } from '../internals/models';
+export declare function useDateManager<TEnableAccessibleFieldDOMStructure extends boolean = true>(parameters?: UseDateManagerParameters<TEnableAccessibleFieldDOMStructure>): UseDateManagerReturnValue<TEnableAccessibleFieldDOMStructure>;
+/**
+ * Private utility function to get the default internal props for the fields with date editing.
+ * Is used by the `useDateManager` and `useDateRangeManager` hooks.
+ */
+export declare function getDateFieldInternalPropsDefaults(parameters: GetDateFieldInternalPropsDefaultsParameters): GetDateFieldInternalPropsDefaultsReturnValue;
+export interface UseDateManagerParameters<TEnableAccessibleFieldDOMStructure extends boolean> {
+    enableAccessibleFieldDOMStructure?: TEnableAccessibleFieldDOMStructure;
+}
+export type UseDateManagerReturnValue<TEnableAccessibleFieldDOMStructure extends boolean> = PickerManager<PickerValue, TEnableAccessibleFieldDOMStructure, DateValidationError, DateManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure>, DateManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure>>;
+interface DateManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure extends boolean> extends MakeOptional<UseFieldInternalProps<PickerValue, TEnableAccessibleFieldDOMStructure, DateValidationError>, 'format'>, ExportedValidateDateProps {
+}
+interface DateManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure extends boolean> extends UseFieldInternalProps<PickerValue, TEnableAccessibleFieldDOMStructure, DateValidationError>, ValidateDateProps {
+}
+type DateManagerFieldPropsToDefault = 'format' | ValidateDatePropsToDefault;
+interface GetDateFieldInternalPropsDefaultsParameters extends Pick<MuiPickersAdapterContextValue, 'defaultDates' | 'utils'> {
+    internalProps: Pick<DateManagerFieldInternalProps<true>, DateManagerFieldPropsToDefault>;
+}
+interface GetDateFieldInternalPropsDefaultsReturnValue extends Pick<DateManagerFieldInternalPropsWithDefaults<true>, DateManagerFieldPropsToDefault> {
+}
+export {};

package/managers/useDateManager.js

@@ -0,0 +1,47 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { applyDefaultDate } from "../internals/utils/date-utils.js";
+import { singleItemFieldValueManager, singleItemValueManager } from "../internals/utils/valueManagers.js";
+import { validateDate } from "../validation/index.js";
+export function useDateManager(parameters = {}) {
+  const {
+    enableAccessibleFieldDOMStructure = true
+  } = parameters;
+  return React.useMemo(() => ({
+    valueType: 'date',
+    validator: validateDate,
+    internal_valueManager: singleItemValueManager,
+    internal_fieldValueManager: singleItemFieldValueManager,
+    internal_enableAccessibleFieldDOMStructure: enableAccessibleFieldDOMStructure,
+    internal_applyDefaultsToFieldInternalProps: ({
+      internalProps,
+      utils,
+      defaultDates
+    }) => _extends({}, internalProps, getDateFieldInternalPropsDefaults({
+      defaultDates,
+      utils,
+      internalProps
+    }))
+  }), [enableAccessibleFieldDOMStructure]);
+}
+
+/**
+ * Private utility function to get the default internal props for the fields with date editing.
+ * Is used by the `useDateManager` and `useDateRangeManager` hooks.
+ */
+export function getDateFieldInternalPropsDefaults(parameters) {
+  const {
+    defaultDates,
+    utils,
+    internalProps
+  } = parameters;
+  return {
+    format: internalProps.format ?? utils.formats.keyboardDate,
+    disablePast: internalProps.disablePast ?? false,
+    disableFuture: internalProps.disableFuture ?? false,
+    minDate: applyDefaultDate(utils, internalProps.minDate, defaultDates.minDate),
+    maxDate: applyDefaultDate(utils, internalProps.maxDate, defaultDates.maxDate)
+  };
+}

package/managers/useDateTimeManager.d.ts

@@ -0,0 +1,28 @@
+import type { MakeOptional } from '@mui/x-internals/types';
+import { PickerManager, DateTimeValidationError } from '../models';
+import { UseFieldInternalProps } from '../internals/hooks/useField';
+import { MuiPickersAdapterContextValue } from '../LocalizationProvider/LocalizationProvider';
+import { AmPmProps } from '../internals/models/props/time';
+import { ExportedValidateDateTimeProps, ValidateDateTimeProps, ValidateDateTimePropsToDefault } from '../validation/validateDateTime';
+import { PickerValue } from '../internals/models';
+export declare function useDateTimeManager<TEnableAccessibleFieldDOMStructure extends boolean = true>(parameters?: UseDateTimeManagerParameters<TEnableAccessibleFieldDOMStructure>): UseDateTimeManagerReturnValue<TEnableAccessibleFieldDOMStructure>;
+/**
+ * Private utility function to get the default internal props for the field with date time editing.
+ * Is used by the `useDateTimeManager` and `useDateTimeRangeManager` hooks.
+ */
+export declare function getDateTimeFieldInternalPropsDefaults(parameters: GetDateTimeFieldInternalPropsDefaultsParameters): GetDateTimeFieldInternalPropsDefaultsReturnValue;
+export interface UseDateTimeManagerParameters<TEnableAccessibleFieldDOMStructure extends boolean> {
+    enableAccessibleFieldDOMStructure?: TEnableAccessibleFieldDOMStructure;
+}
+export type UseDateTimeManagerReturnValue<TEnableAccessibleFieldDOMStructure extends boolean> = PickerManager<PickerValue, TEnableAccessibleFieldDOMStructure, DateTimeValidationError, DateTimeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure>, DateTimeManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure>>;
+interface DateTimeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure extends boolean> extends MakeOptional<UseFieldInternalProps<PickerValue, TEnableAccessibleFieldDOMStructure, DateTimeValidationError>, 'format'>, ExportedValidateDateTimeProps, AmPmProps {
+}
+interface DateTimeManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure extends boolean> extends UseFieldInternalProps<PickerValue, TEnableAccessibleFieldDOMStructure, DateTimeValidationError>, ValidateDateTimeProps {
+}
+type DateTimeManagerFieldPropsToDefault = 'format' | 'minTime' | 'maxTime' | ValidateDateTimePropsToDefault;
+interface GetDateTimeFieldInternalPropsDefaultsParameters extends Pick<MuiPickersAdapterContextValue, 'defaultDates' | 'utils'> {
+    internalProps: Pick<DateTimeManagerFieldInternalProps<true>, DateTimeManagerFieldPropsToDefault | 'minDateTime' | 'maxDateTime' | 'ampm'>;
+}
+interface GetDateTimeFieldInternalPropsDefaultsReturnValue extends Pick<DateTimeManagerFieldInternalPropsWithDefaults<true>, DateTimeManagerFieldPropsToDefault | 'disableIgnoringDatePartForTimeValidation'> {
+}
+export {};

package/managers/useDateTimeManager.js

@@ -0,0 +1,52 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { applyDefaultDate } from "../internals/utils/date-utils.js";
+import { singleItemFieldValueManager, singleItemValueManager } from "../internals/utils/valueManagers.js";
+import { validateDateTime } from "../validation/index.js";
+export function useDateTimeManager(parameters = {}) {
+  const {
+    enableAccessibleFieldDOMStructure = true
+  } = parameters;
+  return React.useMemo(() => ({
+    valueType: 'date-time',
+    validator: validateDateTime,
+    internal_valueManager: singleItemValueManager,
+    internal_fieldValueManager: singleItemFieldValueManager,
+    internal_enableAccessibleFieldDOMStructure: enableAccessibleFieldDOMStructure,
+    internal_applyDefaultsToFieldInternalProps: ({
+      internalProps,
+      utils,
+      defaultDates
+    }) => _extends({}, internalProps, getDateTimeFieldInternalPropsDefaults({
+      internalProps,
+      utils,
+      defaultDates
+    }))
+  }), [enableAccessibleFieldDOMStructure]);
+}
+
+/**
+ * Private utility function to get the default internal props for the field with date time editing.
+ * Is used by the `useDateTimeManager` and `useDateTimeRangeManager` hooks.
+ */
+export function getDateTimeFieldInternalPropsDefaults(parameters) {
+  const {
+    defaultDates,
+    utils,
+    internalProps
+  } = parameters;
+  const ampm = internalProps.ampm ?? utils.is12HourCycleInCurrentLocale();
+  const defaultFormat = ampm ? utils.formats.keyboardDateTime12h : utils.formats.keyboardDateTime24h;
+  return {
+    disablePast: internalProps.disablePast ?? false,
+    disableFuture: internalProps.disableFuture ?? false,
+    format: internalProps.format ?? defaultFormat,
+    disableIgnoringDatePartForTimeValidation: Boolean(internalProps.minDateTime || internalProps.maxDateTime),
+    minDate: applyDefaultDate(utils, internalProps.minDateTime ?? internalProps.minDate, defaultDates.minDate),
+    maxDate: applyDefaultDate(utils, internalProps.maxDateTime ?? internalProps.maxDate, defaultDates.maxDate),
+    minTime: internalProps.minDateTime ?? internalProps.minTime,
+    maxTime: internalProps.maxDateTime ?? internalProps.maxTime
+  };
+}

package/managers/useTimeManager.d.ts

@@ -0,0 +1,28 @@
+import type { MakeOptional } from '@mui/x-internals/types';
+import { PickerManager, TimeValidationError } from '../models';
+import { UseFieldInternalProps } from '../internals/hooks/useField';
+import { MuiPickersAdapterContextValue } from '../LocalizationProvider/LocalizationProvider';
+import { AmPmProps } from '../internals/models/props/time';
+import { ExportedValidateTimeProps, ValidateTimeProps, ValidateTimePropsToDefault } from '../validation/validateTime';
+import { PickerValue } from '../internals/models';
+export declare function useTimeManager<TEnableAccessibleFieldDOMStructure extends boolean = true>(parameters?: UseTimeManagerParameters<TEnableAccessibleFieldDOMStructure>): UseTimeManagerReturnValue<TEnableAccessibleFieldDOMStructure>;
+/**
+ * Private utility function to get the default internal props for the fields with time editing.
+ * Is used by the `useTimeManager` and `useTimeRangeManager` hooks.
+ */
+export declare function getTimeFieldInternalPropsDefaults(parameters: GetTimeFieldInternalPropsDefaultsParameters): GetTimeFieldInternalPropsDefaultsReturnValue;
+export interface UseTimeManagerParameters<TEnableAccessibleFieldDOMStructure extends boolean> {
+    enableAccessibleFieldDOMStructure?: TEnableAccessibleFieldDOMStructure;
+}
+export type UseTimeManagerReturnValue<TEnableAccessibleFieldDOMStructure extends boolean> = PickerManager<PickerValue, TEnableAccessibleFieldDOMStructure, TimeValidationError, TimeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure>, TimeManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure>>;
+interface TimeManagerFieldInternalProps<TEnableAccessibleFieldDOMStructure extends boolean> extends MakeOptional<UseFieldInternalProps<PickerValue, TEnableAccessibleFieldDOMStructure, TimeValidationError>, 'format'>, ExportedValidateTimeProps, AmPmProps {
+}
+interface TimeManagerFieldInternalPropsWithDefaults<TEnableAccessibleFieldDOMStructure extends boolean> extends UseFieldInternalProps<PickerValue, TEnableAccessibleFieldDOMStructure, TimeValidationError>, ValidateTimeProps {
+}
+type TimeManagerFieldPropsToDefault = 'format' | ValidateTimePropsToDefault;
+interface GetTimeFieldInternalPropsDefaultsParameters extends Pick<MuiPickersAdapterContextValue, 'utils'> {
+    internalProps: Pick<TimeManagerFieldInternalProps<true>, TimeManagerFieldPropsToDefault | 'ampm'>;
+}
+interface GetTimeFieldInternalPropsDefaultsReturnValue extends Pick<TimeManagerFieldInternalPropsWithDefaults<true>, TimeManagerFieldPropsToDefault> {
+}
+export {};

package/managers/useTimeManager.js

@@ -0,0 +1,43 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { singleItemFieldValueManager, singleItemValueManager } from "../internals/utils/valueManagers.js";
+import { validateTime } from "../validation/index.js";
+export function useTimeManager(parameters = {}) {
+  const {
+    enableAccessibleFieldDOMStructure = true
+  } = parameters;
+  return React.useMemo(() => ({
+    valueType: 'time',
+    validator: validateTime,
+    internal_valueManager: singleItemValueManager,
+    internal_fieldValueManager: singleItemFieldValueManager,
+    internal_enableAccessibleFieldDOMStructure: enableAccessibleFieldDOMStructure,
+    internal_applyDefaultsToFieldInternalProps: ({
+      internalProps,
+      utils
+    }) => _extends({}, internalProps, getTimeFieldInternalPropsDefaults({
+      utils,
+      internalProps
+    }))
+  }), [enableAccessibleFieldDOMStructure]);
+}
+
+/**
+ * Private utility function to get the default internal props for the fields with time editing.
+ * Is used by the `useTimeManager` and `useTimeRangeManager` hooks.
+ */
+export function getTimeFieldInternalPropsDefaults(parameters) {
+  const {
+    utils,
+    internalProps
+  } = parameters;
+  const ampm = internalProps.ampm ?? utils.is12HourCycleInCurrentLocale();
+  const defaultFormat = ampm ? utils.formats.fullTime12h : utils.formats.fullTime24h;
+  return {
+    disablePast: internalProps.disablePast ?? false,
+    disableFuture: internalProps.disableFuture ?? false,
+    format: internalProps.format ?? defaultFormat
+  };
+}

package/models/adapters.d.ts

@@ -225,7 +225,7 @@ export interface MuiPickersAdapter<TLocale = any> {
      * @param {PickerValidDate | null} value The value to test.
      * @returns {boolean} `true` if the value is a valid date according to the date library.
      */
-    isValid(value: PickerValidDate | null): boolean;
+    isValid(value: PickerValidDate | null): value is PickerValidDate;
     /**
      * Format a date using an adapter format string (see the `AdapterFormats` interface)
      * @param {PickerValidDate} value The date to format.

package/models/index.d.ts

@@ -5,4 +5,5 @@ export * from './views';
 export * from './adapters';
 export * from './common';
 export * from './pickers';
+export * from './manager';
 export type { PropsFromSlot } from '@mui/x-internals/slots';

package/models/index.js

@@ -5,6 +5,7 @@ export * from "./views.js";
 export * from "./adapters.js";
 export * from "./common.js";
 export * from "./pickers.js";
+export * from "./manager.js";
 
 // Utils shared across the X packages
 export {};

package/models/manager.d.ts

@@ -0,0 +1,78 @@
+import type { FieldValueManager, UseFieldInternalProps } from '../internals/hooks/useField';
+import type { PickerValueManager } from '../internals/hooks/usePicker';
+import type { PickerValidValue } from '../internals/models';
+import type { MuiPickersAdapterContextValue } from '../LocalizationProvider/LocalizationProvider';
+import type { Validator } from '../validation';
+import type { PickerValueType } from './common';
+/**
+ * Object that contains all the necessary methods and properties to adapter a picker or a field for a given value type.
+ * You should never create your own manager.
+ * Instead, use the hooks exported from '@mui/x-date-pickers/managers' and '@mui/x-date-pickers-pro/managers'.
+ *
+ * ```tsx
+ * import { useDateManager } from '@mui/x-date-pickers/managers';
+ * import { useValidation } from '@mui/x-date-pickers/validation';
+ *
+ * const manager = useDateManager();
+ * const { hasValidationError } = useValidation({
+ *   validator: manager.validator,
+ *   value,
+ *   timezone,
+ *   props,
+ * });
+ * ```
+ */
+export interface PickerManager<TValue extends PickerValidValue, TEnableAccessibleFieldDOMStructure extends boolean, TError, TFieldInternalProps extends {}, TFieldInternalPropsWithDefaults extends UseFieldInternalProps<TValue, TEnableAccessibleFieldDOMStructure, TError>> {
+    /**
+     * The type of the value (e.g. 'date', 'date-time', 'time').
+     */
+    valueType: PickerValueType;
+    /**
+     * Checks if a value is valid and returns an error code otherwise.
+     * It can be passed to the `useValidation` hook to validate a value:
+     *
+     * ```tsx
+     * import { useDateManager } from '@mui/x-date-pickers/managers';
+     * import { useValidation } from '@mui/x-date-pickers/validation';
+     *
+     * const manager = useDateManager();
+     * const { hasValidationError } = useValidation({
+     *   validator: manager.validator,
+     *   value,
+     *   timezone,
+     *   props,
+     * });
+     * ```
+     */
+    validator: Validator<TValue, TError, TFieldInternalPropsWithDefaults>;
+    /**
+     * Object containing basic methods to interact with the value of the picker or field.
+     * This property is not part of the public API and should not be used directly.
+     */
+    internal_valueManager: PickerValueManager<TValue, TError>;
+    /**
+     * Object containing all the necessary methods to interact with the value of the field.
+     * This property is not part of the public API and should not be used directly.
+     */
+    internal_fieldValueManager: FieldValueManager<TValue>;
+    /**
+     * `true` if the field is using the accessible DOM structure.
+     * `false` if the field is using the non-accessible DOM structure.
+     * This property is not part of the public API and should not be used directly.
+     */
+    internal_enableAccessibleFieldDOMStructure: TEnableAccessibleFieldDOMStructure;
+    /**
+     * Applies the default values to the field internal props.
+     * This usually includes:
+     * - a default format to display the value in the field
+     * - some default validation props that are needed to validate the value (e.g: minDate, maxDate)
+     * This property is not part of the public API and should not be used directly.
+     * @param {ApplyDefaultsToFieldInternalPropsParameters} parameters The parameters to apply the defaults.
+     * @returns {TFieldInternalPropsWithDefaults} The field internal props with the defaults applied.
+     */
+    internal_applyDefaultsToFieldInternalProps: (parameters: ApplyDefaultsToFieldInternalPropsParameters<TFieldInternalProps>) => TFieldInternalPropsWithDefaults;
+}
+interface ApplyDefaultsToFieldInternalPropsParameters<TFieldInternalProps extends {}> extends MuiPickersAdapterContextValue {
+    internalProps: TFieldInternalProps;
+}
+export {};

package/models/manager.js

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

package/models/pickers.d.ts

@@ -11,6 +11,13 @@ export interface PickerChangeHandlerContext<TError> {
 export interface PickerValidDateLookup {
 }
 export type PickerValidDate = keyof PickerValidDateLookup extends never ? any : PickerValidDateLookup[keyof PickerValidDateLookup];
+/**
+ * Importance of the change when picking a value:
+ * - "accept": fires `onChange`, fires `onAccept` and closes the picker.
+ * - "set": fires `onChange` but do not fire `onAccept` and does not close the picker.
+ * @default "accept"
+ */
+export type PickerChangeImportance = 'set' | 'accept';
 export interface PickerOwnerState {
     /**
      * `true` if the value of the picker is currently empty.

package/modern/AdapterDateFns/AdapterDateFns.js

@@ -1,49 +1,47 @@
 /* eslint-disable class-methods-use-this */
-import addDays from 'date-fns/addDays';
-import addSeconds from 'date-fns/addSeconds';
-import addMinutes from 'date-fns/addMinutes';
-import addHours from 'date-fns/addHours';
-import addWeeks from 'date-fns/addWeeks';
-import addMonths from 'date-fns/addMonths';
-import addYears from 'date-fns/addYears';
-import endOfDay from 'date-fns/endOfDay';
-import endOfWeek from 'date-fns/endOfWeek';
-import endOfYear from 'date-fns/endOfYear';
-import dateFnsFormat from 'date-fns/format';
-import getDate from 'date-fns/getDate';
-import getDaysInMonth from 'date-fns/getDaysInMonth';
-import getHours from 'date-fns/getHours';
-import getMinutes from 'date-fns/getMinutes';
-import getMonth from 'date-fns/getMonth';
-import getSeconds from 'date-fns/getSeconds';
-import getMilliseconds from 'date-fns/getMilliseconds';
-import getWeek from 'date-fns/getWeek';
-import getYear from 'date-fns/getYear';
-import isAfter from 'date-fns/isAfter';
-import isBefore from 'date-fns/isBefore';
-import isEqual from 'date-fns/isEqual';
-import isSameDay from 'date-fns/isSameDay';
-import isSameYear from 'date-fns/isSameYear';
-import isSameMonth from 'date-fns/isSameMonth';
-import isSameHour from 'date-fns/isSameHour';
-import isValid from 'date-fns/isValid';
-import dateFnsParse from 'date-fns/parse';
-import setDate from 'date-fns/setDate';
-import setHours from 'date-fns/setHours';
-import setMinutes from 'date-fns/setMinutes';
-import setMonth from 'date-fns/setMonth';
-import setSeconds from 'date-fns/setSeconds';
-import setMilliseconds from 'date-fns/setMilliseconds';
-import setYear from 'date-fns/setYear';
-import startOfDay from 'date-fns/startOfDay';
-import startOfMonth from 'date-fns/startOfMonth';
-import endOfMonth from 'date-fns/endOfMonth';
-import startOfWeek from 'date-fns/startOfWeek';
-import startOfYear from 'date-fns/startOfYear';
-import isWithinInterval from 'date-fns/isWithinInterval';
-import defaultLocale from 'date-fns/locale/en-US';
-// @ts-ignore
-import longFormatters from 'date-fns/_lib/format/longFormatters';
+import { addDays } from 'date-fns/addDays';
+import { addSeconds } from 'date-fns/addSeconds';
+import { addMinutes } from 'date-fns/addMinutes';
+import { addHours } from 'date-fns/addHours';
+import { addWeeks } from 'date-fns/addWeeks';
+import { addMonths } from 'date-fns/addMonths';
+import { addYears } from 'date-fns/addYears';
+import { endOfDay } from 'date-fns/endOfDay';
+import { endOfWeek } from 'date-fns/endOfWeek';
+import { endOfYear } from 'date-fns/endOfYear';
+import { format as dateFnsFormat, longFormatters } from 'date-fns/format';
+import { getDate } from 'date-fns/getDate';
+import { getDaysInMonth } from 'date-fns/getDaysInMonth';
+import { getHours } from 'date-fns/getHours';
+import { getMinutes } from 'date-fns/getMinutes';
+import { getMonth } from 'date-fns/getMonth';
+import { getSeconds } from 'date-fns/getSeconds';
+import { getMilliseconds } from 'date-fns/getMilliseconds';
+import { getWeek } from 'date-fns/getWeek';
+import { getYear } from 'date-fns/getYear';
+import { isAfter } from 'date-fns/isAfter';
+import { isBefore } from 'date-fns/isBefore';
+import { isEqual } from 'date-fns/isEqual';
+import { isSameDay } from 'date-fns/isSameDay';
+import { isSameYear } from 'date-fns/isSameYear';
+import { isSameMonth } from 'date-fns/isSameMonth';
+import { isSameHour } from 'date-fns/isSameHour';
+import { isValid } from 'date-fns/isValid';
+import { parse as dateFnsParse } from 'date-fns/parse';
+import { setDate } from 'date-fns/setDate';
+import { setHours } from 'date-fns/setHours';
+import { setMinutes } from 'date-fns/setMinutes';
+import { setMonth } from 'date-fns/setMonth';
+import { setSeconds } from 'date-fns/setSeconds';
+import { setMilliseconds } from 'date-fns/setMilliseconds';
+import { setYear } from 'date-fns/setYear';
+import { startOfDay } from 'date-fns/startOfDay';
+import { startOfMonth } from 'date-fns/startOfMonth';
+import { endOfMonth } from 'date-fns/endOfMonth';
+import { startOfWeek } from 'date-fns/startOfWeek';
+import { startOfYear } from 'date-fns/startOfYear';
+import { isWithinInterval } from 'date-fns/isWithinInterval';
+import { enUS } from 'date-fns/locale/en-US';
 import { AdapterDateFnsBase } from "../AdapterDateFnsBase/index.js";
 /**
  * Based on `@date-io/date-fns`
@@ -78,14 +76,18 @@ export class AdapterDateFns extends AdapterDateFnsBase {
     /* istanbul ignore next */
     if (process.env.NODE_ENV !== 'production') {
       if (typeof addDays !== 'function') {
-        throw new Error(['MUI: This adapter is only compatible with `date-fns` v2.x package versions.', 'Please, install v2.x of the package or use the `AdapterDateFnsV3` instead.'].join('\n'));
+        throw new Error(['MUI: The `date-fns` package v2.x is not compatible with this adapter.', 'Please, install v3.x or v4.x of the package or use the `AdapterDateFnsV2` instead.'].join('\n'));
+      }
+      if (!longFormatters) {
+        throw new Error('MUI: The minimum supported `date-fns` package version compatible with this adapter is `3.2.x`.');
       }
     }
     super({
-      locale: locale ?? defaultLocale,
+      locale: locale ?? enUS,
       formats,
       longFormatters
     });
+    // TODO: explicit return types can be removed once there is only one date-fns version supported
     this.parse = (value, format) => {
       if (value === '') {
         return null;

package/modern/AdapterDateFnsJalali/AdapterDateFnsJalali.js

@@ -1,50 +1,48 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 /* eslint-disable class-methods-use-this */
-import addSeconds from 'date-fns-jalali/addSeconds';
-import addMinutes from 'date-fns-jalali/addMinutes';
-import addHours from 'date-fns-jalali/addHours';
-import addDays from 'date-fns-jalali/addDays';
-import addWeeks from 'date-fns-jalali/addWeeks';
-import addMonths from 'date-fns-jalali/addMonths';
-import addYears from 'date-fns-jalali/addYears';
-import endOfDay from 'date-fns-jalali/endOfDay';
-import endOfWeek from 'date-fns-jalali/endOfWeek';
-import endOfYear from 'date-fns-jalali/endOfYear';
-import dateFnsFormat from 'date-fns-jalali/format';
-import getHours from 'date-fns-jalali/getHours';
-import getSeconds from 'date-fns-jalali/getSeconds';
-import getMilliseconds from 'date-fns-jalali/getMilliseconds';
-import getWeek from 'date-fns-jalali/getWeek';
-import getYear from 'date-fns-jalali/getYear';
-import getMonth from 'date-fns-jalali/getMonth';
-import getDate from 'date-fns-jalali/getDate';
-import getDaysInMonth from 'date-fns-jalali/getDaysInMonth';
-import getMinutes from 'date-fns-jalali/getMinutes';
-import isAfter from 'date-fns-jalali/isAfter';
-import isBefore from 'date-fns-jalali/isBefore';
-import isEqual from 'date-fns-jalali/isEqual';
-import isSameDay from 'date-fns-jalali/isSameDay';
-import isSameYear from 'date-fns-jalali/isSameYear';
-import isSameMonth from 'date-fns-jalali/isSameMonth';
-import isSameHour from 'date-fns-jalali/isSameHour';
-import isValid from 'date-fns-jalali/isValid';
-import dateFnsParse from 'date-fns-jalali/parse';
-import setDate from 'date-fns-jalali/setDate';
-import setHours from 'date-fns-jalali/setHours';
-import setMinutes from 'date-fns-jalali/setMinutes';
-import setMonth from 'date-fns-jalali/setMonth';
-import setSeconds from 'date-fns-jalali/setSeconds';
-import setMilliseconds from 'date-fns-jalali/setMilliseconds';
-import setYear from 'date-fns-jalali/setYear';
-import startOfDay from 'date-fns-jalali/startOfDay';
-import startOfMonth from 'date-fns-jalali/startOfMonth';
-import endOfMonth from 'date-fns-jalali/endOfMonth';
-import startOfWeek from 'date-fns-jalali/startOfWeek';
-import startOfYear from 'date-fns-jalali/startOfYear';
-import isWithinInterval from 'date-fns-jalali/isWithinInterval';
-import defaultLocale from 'date-fns-jalali/locale/fa-IR';
-// @ts-ignore
-import longFormatters from 'date-fns-jalali/_lib/format/longFormatters';
+import { addSeconds } from 'date-fns-jalali/addSeconds';
+import { addMinutes } from 'date-fns-jalali/addMinutes';
+import { addHours } from 'date-fns-jalali/addHours';
+import { addDays } from 'date-fns-jalali/addDays';
+import { addWeeks } from 'date-fns-jalali/addWeeks';
+import { addMonths } from 'date-fns-jalali/addMonths';
+import { addYears } from 'date-fns-jalali/addYears';
+import { endOfDay } from 'date-fns-jalali/endOfDay';
+import { endOfWeek } from 'date-fns-jalali/endOfWeek';
+import { endOfYear } from 'date-fns-jalali/endOfYear';
+import { format as dateFnsFormat, longFormatters } from 'date-fns-jalali/format';
+import { getHours } from 'date-fns-jalali/getHours';
+import { getSeconds } from 'date-fns-jalali/getSeconds';
+import { getMilliseconds } from 'date-fns-jalali/getMilliseconds';
+import { getWeek } from 'date-fns-jalali/getWeek';
+import { getYear } from 'date-fns-jalali/getYear';
+import { getMonth } from 'date-fns-jalali/getMonth';
+import { getDate } from 'date-fns-jalali/getDate';
+import { getDaysInMonth } from 'date-fns-jalali/getDaysInMonth';
+import { getMinutes } from 'date-fns-jalali/getMinutes';
+import { isAfter } from 'date-fns-jalali/isAfter';
+import { isBefore } from 'date-fns-jalali/isBefore';
+import { isEqual } from 'date-fns-jalali/isEqual';
+import { isSameDay } from 'date-fns-jalali/isSameDay';
+import { isSameYear } from 'date-fns-jalali/isSameYear';
+import { isSameMonth } from 'date-fns-jalali/isSameMonth';
+import { isSameHour } from 'date-fns-jalali/isSameHour';
+import { isValid } from 'date-fns-jalali/isValid';
+import { parse as dateFnsParse } from 'date-fns-jalali/parse';
+import { setDate } from 'date-fns-jalali/setDate';
+import { setHours } from 'date-fns-jalali/setHours';
+import { setMinutes } from 'date-fns-jalali/setMinutes';
+import { setMonth } from 'date-fns-jalali/setMonth';
+import { setSeconds } from 'date-fns-jalali/setSeconds';
+import { setMilliseconds } from 'date-fns-jalali/setMilliseconds';
+import { setYear } from 'date-fns-jalali/setYear';
+import { startOfDay } from 'date-fns-jalali/startOfDay';
+import { startOfMonth } from 'date-fns-jalali/startOfMonth';
+import { endOfMonth } from 'date-fns-jalali/endOfMonth';
+import { startOfWeek } from 'date-fns-jalali/startOfWeek';
+import { startOfYear } from 'date-fns-jalali/startOfYear';
+import { isWithinInterval } from 'date-fns-jalali/isWithinInterval';
+import { faIR as defaultLocale } from 'date-fns-jalali/locale/fa-IR';
 import { AdapterDateFnsBase } from "../AdapterDateFnsBase/index.js";
 const defaultFormats = {
   year: 'yyyy',
@@ -116,7 +114,10 @@ export class AdapterDateFnsJalali extends AdapterDateFnsBase {
     /* istanbul ignore next */
     if (process.env.NODE_ENV !== 'production') {
       if (typeof addDays !== 'function') {
-        throw new Error(['MUI: The `date-fns-jalali` package v3.x is not compatible with this adapter.', 'Please, install v2.x of the package or use the `AdapterDateFnsJalaliV3` instead.'].join('\n'));
+        throw new Error(['MUI: The `date-fns-jalali` package v2.x is not compatible with this adapter.', 'Please, install v3.x or v4.x of the package or use the `AdapterDateFnsJalaliV2` instead.'].join('\n'));
+      }
+      if (!longFormatters) {
+        throw new Error('MUI: The minimum supported `date-fns-jalali` package version compatible with this adapter is `3.2.x`.');
       }
     }
     super({
@@ -127,6 +128,7 @@ export class AdapterDateFnsJalali extends AdapterDateFnsBase {
       longFormatters,
       lib: 'date-fns-jalali'
     });
+    // TODO: explicit return types can be removed once there is only one date-fns version supported
     this.parse = (value, format) => {
       if (value === '') {
         return null;