@mui/x-date-pickers 8.0.0-alpha.1 → 8.0.0-alpha.10

package/YearCalendar/yearCalendarClasses.js

@@ -2,4 +2,4 @@ import { unstable_generateUtilityClass as generateUtilityClass, unstable_generat
 export function getYearCalendarUtilityClass(slot) {
   return generateUtilityClass('MuiYearCalendar', slot);
 }
-export const yearCalendarClasses = generateUtilityClasses('MuiYearCalendar', ['root']);
+export const yearCalendarClasses = generateUtilityClasses('MuiYearCalendar', ['root', 'button', 'disabled', 'selected']);

package/hooks/index.d.ts

@@ -4,3 +4,5 @@ export { usePickerTranslations } from './usePickerTranslations';
 export { useSplitFieldProps } from './useSplitFieldProps';
 export { useParsedFormat } from './useParsedFormat';
 export { usePickerContext } from './usePickerContext';
+export { usePickerActionsContext } from './usePickerActionsContext';
+export { useIsValidValue } from './useIsValidValue';

package/hooks/index.js

@@ -2,4 +2,6 @@ export { useClearableField } from "./useClearableField.js";
 export { usePickerTranslations } from "./usePickerTranslations.js";
 export { useSplitFieldProps } from "./useSplitFieldProps.js";
 export { useParsedFormat } from "./useParsedFormat.js";
-export { usePickerContext } from "./usePickerContext.js";
+export { usePickerContext } from "./usePickerContext.js";
+export { usePickerActionsContext } from "./usePickerActionsContext.js";
+export { useIsValidValue } from "./useIsValidValue.js";

package/hooks/useClearableField.d.ts

@@ -3,6 +3,8 @@ import { SlotComponentProps } from '@mui/utils';
 import MuiIconButton from '@mui/material/IconButton';
 import { SxProps } from '@mui/system';
 import { ClearIcon } from '../icons';
+import { FieldOwnerState } from '../models/fields';
+import { FormProps } from '../internals/models';
 export interface ExportedUseClearableFieldProps {
     /**
      * If `true`, a clear button will be shown in the field allowing value clearing.
@@ -27,10 +29,10 @@ export interface UseClearableFieldSlots {
     clearButton?: React.ElementType;
 }
 export interface UseClearableFieldSlotProps {
-    clearIcon?: SlotComponentProps<typeof ClearIcon, {}, {}>;
-    clearButton?: SlotComponentProps<typeof MuiIconButton, {}, {}>;
+    clearIcon?: SlotComponentProps<typeof ClearIcon, {}, FieldOwnerState>;
+    clearButton?: SlotComponentProps<typeof MuiIconButton, {}, FieldOwnerState>;
 }
-interface UseClearableFieldProps extends ExportedUseClearableFieldProps {
+interface UseClearableFieldProps extends ExportedUseClearableFieldProps, FormProps {
     InputProps?: {
         endAdornment?: React.ReactNode;
     };

package/hooks/useClearableField.js

@@ -10,9 +10,11 @@ import MuiIconButton from '@mui/material/IconButton';
 import InputAdornment from '@mui/material/InputAdornment';
 import { ClearIcon } from "../icons/index.js";
 import { usePickerTranslations } from "./usePickerTranslations.js";
+import { useFieldOwnerState } from "../internals/hooks/useFieldOwnerState.js";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 export const useClearableField = props => {
   const translations = usePickerTranslations();
+  const ownerState = useFieldOwnerState(props);
   const {
       clearable,
       onClear,
@@ -27,7 +29,7 @@ export const useClearableField = props => {
   const _useSlotProps = useSlotProps({
       elementType: IconButton,
       externalSlotProps: slotProps?.clearButton,
-      ownerState: {},
+      ownerState,
       className: 'clearButton',
       additionalProps: {
         title: translations.fieldClearLabel,
@@ -39,7 +41,7 @@ export const useClearableField = props => {
   const endClearIconProps = useSlotProps({
     elementType: EndClearIcon,
     externalSlotProps: slotProps?.clearIcon,
-    ownerState: {}
+    ownerState
   });
   return _extends({}, other, {
     InputProps: _extends({}, InputProps, {

package/hooks/useIsValidValue.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { PickerValidValue } from '../internals/models';
+export declare const IsValidValueContext: React.Context<(value: any) => boolean>;
+/**
+ * Returns a function to check if a value is valid according to the validation props passed to the parent picker.
+ */
+export declare function useIsValidValue<TValue extends PickerValidValue>(): (value: TValue) => boolean;

package/hooks/useIsValidValue.js

@@ -0,0 +1,11 @@
+'use client';
+
+import * as React from 'react';
+export const IsValidValueContext = /*#__PURE__*/React.createContext(() => true);
+
+/**
+ * Returns a function to check if a value is valid according to the validation props passed to the parent picker.
+ */
+export function useIsValidValue() {
+  return React.useContext(IsValidValueContext);
+}

package/hooks/useParsedFormat.d.ts

@@ -1,14 +1,16 @@
-import type { UseFieldInternalProps } from '../internals/hooks/useField';
-interface UseParsedFormatParameters extends Pick<UseFieldInternalProps<any, any, any, any>, 'format' | 'formatDensity' | 'shouldRespectLeadingZeros'> {
+interface UseParsedFormatParameters {
+    /**
+     * Format to parse.
+     * @default the format provided by the picker.
+     */
+    format?: string;
 }
 /**
  * Returns the parsed format to be rendered in the field when there is no value or in other parts of the Picker.
- * This format is localized (e.g: `AAAA` for the year with the French locale) and cannot be parsed by your date library.
+ * This format is localized (for example `AAAA` for the year with the French locale) and cannot be parsed by your date library.
  * @param {object} The parameters needed to build the placeholder.
- * @param {string} params.format Format of the date to use.
- * @param {'dense' | 'spacious'} params.formatDensity Density of the format (setting `formatDensity` to `"spacious"` will add a space before and after each `/`, `-` and `.` character).
- * @param {boolean} params.shouldRespectLeadingZeros If `true`, the format will respect the leading zeroes, if `false`, the format will always add leading zeroes.
+ * @param {string} params.format Format to parse.
  * @returns
  */
-export declare const useParsedFormat: (parameters: UseParsedFormatParameters) => string;
+export declare const useParsedFormat: (parameters?: UseParsedFormatParameters) => string;
 export {};

package/hooks/useParsedFormat.js

@@ -6,32 +6,30 @@ import { useUtils } from "../internals/hooks/useUtils.js";
 import { buildSectionsFromFormat } from "../internals/hooks/useField/buildSectionsFromFormat.js";
 import { getLocalizedDigits } from "../internals/hooks/useField/useField.utils.js";
 import { usePickerTranslations } from "./usePickerTranslations.js";
+import { useNullablePickerContext } from "../internals/hooks/useNullablePickerContext.js";
 /**
  * Returns the parsed format to be rendered in the field when there is no value or in other parts of the Picker.
- * This format is localized (e.g: `AAAA` for the year with the French locale) and cannot be parsed by your date library.
+ * This format is localized (for example `AAAA` for the year with the French locale) and cannot be parsed by your date library.
  * @param {object} The parameters needed to build the placeholder.
- * @param {string} params.format Format of the date to use.
- * @param {'dense' | 'spacious'} params.formatDensity Density of the format (setting `formatDensity` to `"spacious"` will add a space before and after each `/`, `-` and `.` character).
- * @param {boolean} params.shouldRespectLeadingZeros If `true`, the format will respect the leading zeroes, if `false`, the format will always add leading zeroes.
+ * @param {string} params.format Format to parse.
  * @returns
  */
-export const useParsedFormat = parameters => {
-  const {
-    format,
-    formatDensity = 'dense',
-    shouldRespectLeadingZeros = false
-  } = parameters;
+export const useParsedFormat = (parameters = {}) => {
+  const pickerContext = useNullablePickerContext();
   const utils = useUtils();
   const isRtl = useRtl();
   const translations = usePickerTranslations();
   const localizedDigits = React.useMemo(() => getLocalizedDigits(utils), [utils]);
+  const {
+    format = pickerContext?.fieldFormat ?? utils.formats.fullDate
+  } = parameters;
   return React.useMemo(() => {
     const sections = buildSectionsFromFormat({
       utils,
       format,
-      formatDensity,
+      formatDensity: 'dense',
       isRtl,
-      shouldRespectLeadingZeros,
+      shouldRespectLeadingZeros: true,
       localeText: translations,
       localizedDigits,
       date: null,
@@ -39,5 +37,5 @@ export const useParsedFormat = parameters => {
       enableAccessibleFieldDOMStructure: false
     });
     return sections.map(section => `${section.startSeparator}${section.placeholder}${section.endSeparator}`).join('');
-  }, [utils, isRtl, translations, localizedDigits, format, formatDensity, shouldRespectLeadingZeros]);
+  }, [utils, isRtl, translations, localizedDigits, format]);
 };

package/hooks/usePickerActionsContext.d.ts

@@ -0,0 +1,7 @@
+import { PickerActionsContextValue } from '../internals/components/PickerProvider';
+import { DateOrTimeViewWithMeridiem, PickerValidValue, PickerValue } from '../internals/models';
+/**
+ * Returns a subset of the context passed by the picker wrapping the current component.
+ * It only contains the actions and never causes a re-render of the component using it.
+ */
+export declare const usePickerActionsContext: <TValue extends PickerValidValue = PickerValue, TView extends DateOrTimeViewWithMeridiem = DateOrTimeViewWithMeridiem, TError = string | null>() => PickerActionsContextValue<TValue, TView, TError>;

package/hooks/usePickerActionsContext.js

@@ -0,0 +1,15 @@
+'use client';
+
+import * as React from 'react';
+import { PickerActionsContext } from "../internals/components/PickerProvider.js";
+/**
+ * Returns a subset of the context passed by the picker wrapping the current component.
+ * It only contains the actions and never causes a re-render of the component using it.
+ */
+export const usePickerActionsContext = () => {
+  const value = React.useContext(PickerActionsContext);
+  if (value == null) {
+    throw new Error(['MUI X: The `usePickerActionsContext` can only be called in fields that are used as a slot of a picker component'].join('\n'));
+  }
+  return value;
+};

package/hooks/usePickerContext.d.ts

@@ -1,4 +1,8 @@
+import * as React from 'react';
+import type { PickerContextValue } from '../internals/components/PickerProvider';
+import { DateOrTimeViewWithMeridiem, PickerValidValue, PickerValue } from '../internals/models';
+export declare const PickerContext: React.Context<PickerContextValue<any, any, any> | null>;
 /**
  * Returns the context passed by the picker that wraps the current component.
  */
-export declare const usePickerContext: () => import("../internals/components/PickerProvider").PickerContextValue;
+export declare const usePickerContext: <TValue extends PickerValidValue = PickerValue, TView extends DateOrTimeViewWithMeridiem = DateOrTimeViewWithMeridiem, TError = string | null>() => PickerContextValue<TValue, TView, TError>;

package/hooks/usePickerContext.js

@@ -1,7 +1,7 @@
 'use client';
 
 import * as React from 'react';
-import { PickerContext } from "../internals/components/PickerProvider.js";
+export const PickerContext = /*#__PURE__*/React.createContext(null);
 
 /**
  * Returns the context passed by the picker that wraps the current component.
@@ -9,7 +9,7 @@ import { PickerContext } from "../internals/components/PickerProvider.js";
 export const usePickerContext = () => {
   const value = React.useContext(PickerContext);
   if (value == null) {
-    throw new Error(['MUI X: The `usePickerContext` can only be called in fields that are used as a slot of a picker component'].join('\n'));
+    throw new Error('MUI X: The `usePickerContext` hook can only be called inside the context of a picker component');
   }
   return value;
 };

package/hooks/useSplitFieldProps.d.ts

@@ -1,19 +1,28 @@
 import { DATE_TIME_VALIDATION_PROP_NAMES, DATE_VALIDATION_PROP_NAMES, TIME_VALIDATION_PROP_NAMES } from '../validation/extractValidationProps';
 import { PickerValueType } from '../models/common';
-declare const SHARED_FIELD_INTERNAL_PROP_NAMES: readonly ["value", "defaultValue", "referenceDate", "format", "formatDensity", "onChange", "timezone", "onError", "shouldRespectLeadingZeros", "selectedSections", "onSelectedSectionsChange", "unstableFieldRef", "enableAccessibleFieldDOMStructure", "disabled", "readOnly", "dateSeparator"];
+declare const SHARED_FIELD_INTERNAL_PROP_NAMES: readonly ["value", "defaultValue", "referenceDate", "format", "formatDensity", "onChange", "timezone", "onError", "shouldRespectLeadingZeros", "selectedSections", "onSelectedSectionsChange", "unstableFieldRef", "unstableStartFieldRef", "unstableEndFieldRef", "enableAccessibleFieldDOMStructure", "disabled", "readOnly", "dateSeparator", "autoFocus"];
 type InternalPropNames<TValueType extends PickerValueType> = (typeof SHARED_FIELD_INTERNAL_PROP_NAMES)[number] | (TValueType extends 'date' | 'date-time' ? (typeof DATE_VALIDATION_PROP_NAMES)[number] : never) | (TValueType extends 'time' | 'date-time' ? (typeof TIME_VALIDATION_PROP_NAMES)[number] : never) | (TValueType extends 'date-time' ? (typeof DATE_TIME_VALIDATION_PROP_NAMES)[number] : never);
 /**
  * Split the props received by the field component into:
  * - `internalProps` which are used by the various hooks called by the field component.
  * - `forwardedProps` which are passed to the underlying component.
  * Note that some forwarded props might be used by the hooks as well.
- * For instance, hooks like `useDateField` need props like `autoFocus` to know how to behave.
+ * For instance, hooks like `useDateField` need props like `onKeyDown` to merge the default event handler and the one provided by the application.
  * @template TProps, TValueType
  * @param {TProps} props The props received by the field component.
  * @param {TValueType} valueType The type of the field value ('date', 'time', or 'date-time').
  */
 export declare const useSplitFieldProps: <TValueType extends PickerValueType, TProps extends { [key in InternalPropNames<TValueType>]?: any; }>(props: TProps, valueType: TValueType) => {
     forwardedProps: Omit<TProps, InternalPropNames<TValueType>>;
-    internalProps: Pick<TProps, InternalPropNames<TValueType>>;
+    internalProps: ExtractInternalProps<TValueType, TProps>;
+};
+/**
+ * Extract the internal props from the props received by the field component.
+ * This makes sure that the internal props not defined in the props are not present in the result.
+ */
+type ExtractInternalProps<TValueType extends PickerValueType, TProps extends {
+    [key in InternalPropNames<TValueType>]?: any;
+}> = {
+    [K in keyof TProps]: K extends InternalPropNames<TValueType> ? TProps[K] : never;
 };
 export {};

package/hooks/useSplitFieldProps.js

@@ -3,13 +3,13 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import { DATE_TIME_VALIDATION_PROP_NAMES, DATE_VALIDATION_PROP_NAMES, TIME_VALIDATION_PROP_NAMES } from "../validation/extractValidationProps.js";
-const SHARED_FIELD_INTERNAL_PROP_NAMES = ['value', 'defaultValue', 'referenceDate', 'format', 'formatDensity', 'onChange', 'timezone', 'onError', 'shouldRespectLeadingZeros', 'selectedSections', 'onSelectedSectionsChange', 'unstableFieldRef', 'enableAccessibleFieldDOMStructure', 'disabled', 'readOnly', 'dateSeparator'];
+const SHARED_FIELD_INTERNAL_PROP_NAMES = ['value', 'defaultValue', 'referenceDate', 'format', 'formatDensity', 'onChange', 'timezone', 'onError', 'shouldRespectLeadingZeros', 'selectedSections', 'onSelectedSectionsChange', 'unstableFieldRef', 'unstableStartFieldRef', 'unstableEndFieldRef', 'enableAccessibleFieldDOMStructure', 'disabled', 'readOnly', 'dateSeparator', 'autoFocus'];
 /**
  * Split the props received by the field component into:
  * - `internalProps` which are used by the various hooks called by the field component.
  * - `forwardedProps` which are passed to the underlying component.
  * Note that some forwarded props might be used by the hooks as well.
- * For instance, hooks like `useDateField` need props like `autoFocus` to know how to behave.
+ * For instance, hooks like `useDateField` need props like `onKeyDown` to merge the default event handler and the one provided by the application.
  * @template TProps, TValueType
  * @param {TProps} props The props received by the field component.
  * @param {TValueType} valueType The type of the field value ('date', 'time', or 'date-time').
@@ -40,4 +40,9 @@ export const useSplitFieldProps = (props, valueType) => {
       internalProps
     };
   }, [props, valueType]);
-};
+};
+
+/**
+ * Extract the internal props from the props received by the field component.
+ * This makes sure that the internal props not defined in the props are not present in the result.
+ */

package/index.d.ts

@@ -36,3 +36,4 @@ export * from './models';
 export * from './icons';
 export * from './hooks';
 export * from './validation';
+export * from './managers';

package/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-date-pickers v8.0.0-alpha.1
+ * @mui/x-date-pickers v8.0.0-alpha.10
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the
@@ -57,4 +57,5 @@ export { DEFAULT_DESKTOP_MODE_MEDIA_QUERY } from "./internals/utils/utils.js";
 export * from "./models/index.js";
 export * from "./icons/index.js";
 export * from "./hooks/index.js";
-export * from "./validation/index.js";
+export * from "./validation/index.js";
+export * from "./managers/index.js";

package/internals/components/PickerFieldUI.d.ts

@@ -0,0 +1,133 @@
+import * as React from 'react';
+import { TextFieldProps } from '@mui/material/TextField';
+import { IconButtonProps } from '@mui/material/IconButton';
+import { InputAdornmentProps } from '@mui/material/InputAdornment';
+import { SvgIconProps } from '@mui/material/SvgIcon';
+import { MakeOptional, SlotComponentPropsFromProps } from '@mui/x-internals/types';
+import { FieldOwnerState } from '../../models';
+import { UseFieldOwnerStateParameters } from '../hooks/useFieldOwnerState';
+import type { UseFieldResponse } from '../hooks/useField';
+import { PickersTextFieldProps } from '../../PickersTextField';
+export declare const cleanFieldResponse: <TFieldResponse extends MakeOptional<UseFieldResponse<any, ExportedPickerFieldUIProps & {
+    [key: string]: any;
+}>, "onClear" | "clearable">>({ enableAccessibleFieldDOMStructure, ...fieldResponse }: TFieldResponse) => ExportedPickerFieldUIProps & {
+    openPickerAriaLabel: string;
+    textFieldProps: TextFieldProps | PickersTextFieldProps;
+};
+/**
+ * Adds the button to open the picker and the button to clear the value of the field.
+ * @ignore - internal component.
+ */
+export declare function PickerFieldUI(props: PickerFieldUIProps): React.JSX.Element;
+export interface ExportedPickerFieldUIProps {
+    /**
+     * If `true`, a clear button will be shown in the field allowing value clearing.
+     * @default false
+     */
+    clearable?: boolean;
+    /**
+     * Callback fired when the clear button is clicked.
+     */
+    onClear?: React.MouseEventHandler;
+    /**
+     * The position at which the clear button is placed.
+     * If the field is not clearable, the button is not rendered.
+     * @default 'end'
+     */
+    clearButtonPosition?: 'start' | 'end';
+    /**
+     * The position at which the opening button is placed.
+     * If there is no picker to open, the button is not rendered
+     * @default 'end'
+     */
+    openPickerButtonPosition?: 'start' | 'end';
+}
+export interface PickerFieldUIProps {
+    /**
+     * Overridable component slots.
+     * @default {}
+     */
+    slots?: PickerFieldUISlots;
+    /**
+     * The props used for each component slot.
+     * @default {}
+     */
+    slotProps?: PickerFieldUISlotProps;
+    /**
+     * Object returned by the `useField` hook or one of its wrapper (for example `useDateField`).
+     */
+    fieldResponse: UseFieldResponse<any, any>;
+    /**
+     * The component to use to render the picker opening icon if none is provided in the picker's slots.
+     */
+    defaultOpenPickerIcon: React.ElementType;
+}
+export interface PickerFieldUISlots {
+    /**
+     * Form control with an input to render the value.
+     * @default <PickersTextField />, or <TextField /> from '@mui/material' if `enableAccessibleFieldDOMStructure` is `false`.
+     */
+    textField?: React.ElementType;
+    /**
+     * Component displayed on the start or end input adornment used to open the picker on desktop.
+     * @default InputAdornment
+     */
+    inputAdornment?: React.ElementType<InputAdornmentProps>;
+    /**
+     * Icon to display inside the clear button.
+     * @default ClearIcon
+     */
+    clearIcon?: React.ElementType;
+    /**
+     * Button to clear the value.
+     * @default IconButton
+     */
+    clearButton?: React.ElementType;
+}
+export interface PickerFieldUISlotsFromContext extends PickerFieldUISlots {
+    /**
+     * Button to open the picker on desktop.
+     * @default IconButton
+     */
+    openPickerButton?: React.ElementType<IconButtonProps>;
+    /**
+     * Icon displayed in the open picker button on desktop.
+     */
+    openPickerIcon?: React.ElementType;
+}
+export interface PickerFieldUISlotProps {
+    textField?: SlotComponentPropsFromProps<PickersTextFieldProps | TextFieldProps, {}, FieldOwnerState>;
+    inputAdornment?: SlotComponentPropsFromProps<InputAdornmentProps, {}, FieldInputAdornmentOwnerState>;
+    clearIcon?: SlotComponentPropsFromProps<SvgIconProps, {}, FieldOwnerState>;
+    clearButton?: SlotComponentPropsFromProps<IconButtonProps, {}, FieldOwnerState>;
+}
+export interface PickerFieldUISlotPropsFromContext extends PickerFieldUISlotProps {
+    openPickerButton?: SlotComponentPropsFromProps<IconButtonProps, {}, FieldOwnerState>;
+    openPickerIcon?: SlotComponentPropsFromProps<SvgIconProps, {}, FieldOwnerState>;
+}
+interface FieldInputAdornmentOwnerState extends FieldOwnerState {
+    position: 'start' | 'end';
+}
+/**
+ * The `textField` slot props cannot be handled inside `PickerFieldUI` because it would be a breaking change to not pass the enriched props to `useField`.
+ * Once the non-accessible DOM structure will be removed, we will be able to remove the `textField` slot and clean this logic.
+ */
+export declare function useFieldTextFieldProps<TProps extends UseFieldOwnerStateParameters & {
+    inputProps?: {};
+    InputProps?: {};
+}>(parameters: UseFieldTextFieldPropsParameters): TProps;
+interface UseFieldTextFieldPropsParameters {
+    slotProps: {
+        textField?: SlotComponentPropsFromProps<PickersTextFieldProps | TextFieldProps, {}, FieldOwnerState>;
+    } | undefined;
+    ref: React.Ref<HTMLDivElement>;
+    externalForwardedProps: any;
+}
+export declare function PickerFieldUIContextProvider(props: PickerFieldUIContextProviderProps): React.JSX.Element;
+interface PickerFieldUIContextProviderProps {
+    children: React.ReactNode;
+    inputRef: React.Ref<HTMLInputElement> | undefined;
+    slots: PickerFieldUISlotsFromContext | undefined;
+    slotProps: PickerFieldUISlotPropsFromContext | undefined;
+}
+export {};