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

package/internals/hooks/usePicker/usePicker.js

@@ -1,51 +1,305 @@
-import { warnOnce } from '@mui/x-internals/warning';
-import { usePickerValue } from "./usePickerValue.js";
-import { usePickerViews } from "./usePickerViews.js";
-import { usePickerProvider } from "./usePickerProvider.js";
-export const usePicker = ({
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePicker = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+var React = _interopRequireWildcard(require("react"));
+var _useEnhancedEffect = _interopRequireDefault(require("@mui/utils/useEnhancedEffect"));
+var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
+var _useForkRef = _interopRequireDefault(require("@mui/utils/useForkRef"));
+var _useId = _interopRequireDefault(require("@mui/utils/useId"));
+var _useUtils = require("../useUtils");
+var _useReduceAnimations = require("../useReduceAnimations");
+var _timeUtils = require("../../utils/time-utils");
+var _useViews = require("../useViews");
+var _useOrientation = require("./hooks/useOrientation");
+var _useValueAndOpenStates = require("./hooks/useValueAndOpenStates");
+var _jsxRuntime = require("react/jsx-runtime");
+const _excluded = ["className", "sx"];
+const usePicker = ({
+  ref,
   props,
   valueManager,
   valueType,
   variant,
   validator,
   autoFocusView,
-  rendererInterceptor,
-  fieldRef,
-  localeText
+  rendererInterceptor: RendererInterceptor,
+  localeText,
+  viewContainerRole
 }) => {
-  if (process.env.NODE_ENV !== 'production') {
-    if (props.renderInput != null) {
-      warnOnce(['MUI X: The `renderInput` prop has been removed in version 6.0 of the Date and Time Pickers.', 'You can replace it with the `textField` component slot in most cases.', 'For more information, please have a look at the migration guide (https://mui.com/x/migration/migration-pickers-v5/#input-renderer-required-in-v5).']);
-    }
-  }
-  const pickerValueResponse = usePickerValue({
+  const {
+    // View props
+    views,
+    view: viewProp,
+    openTo,
+    onViewChange,
+    viewRenderers,
+    reduceAnimations: reduceAnimationsProp,
+    orientation: orientationProp,
+    disableOpenPicker,
+    // Form props
+    disabled,
+    readOnly,
+    // Field props
+    formatDensity,
+    enableAccessibleFieldDOMStructure,
+    selectedSections,
+    onSelectedSectionsChange,
+    format,
+    label,
+    // Other props
+    autoFocus,
+    name
+  } = props;
+  const {
+      className,
+      sx
+    } = props,
+    propsToForwardToView = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
+
+  /**
+   * TODO: Improve how we generate the aria-label and aria-labelledby attributes.
+   */
+  const labelId = (0, _useId.default)();
+  const utils = (0, _useUtils.useUtils)();
+  const adapter = (0, _useUtils.useLocalizationContext)();
+  const reduceAnimations = (0, _useReduceAnimations.useReduceAnimations)(reduceAnimationsProp);
+  const orientation = (0, _useOrientation.useOrientation)(views, orientationProp);
+  const {
+    current: initialView
+  } = React.useRef(openTo ?? null);
+
+  /**
+   * Refs
+   */
+  const [triggerElement, triggerRef] = React.useState(null);
+  const popupRef = React.useRef(null);
+  const fieldRef = React.useRef(null);
+  const rootRefObject = React.useRef(null);
+  const rootRef = (0, _useForkRef.default)(ref, rootRefObject);
+  const {
+    timezone,
+    state,
+    setOpen,
+    setValue,
+    setValueFromView,
+    value,
+    viewValue
+  } = (0, _useValueAndOpenStates.useValueAndOpenStates)({
     props,
     valueManager,
-    valueType,
     validator
   });
-  const pickerViewsResponse = usePickerViews({
-    props,
-    autoFocusView,
-    fieldRef,
-    propsFromPickerValue: pickerValueResponse.viewProps,
-    rendererInterceptor
+  const {
+    view,
+    setView,
+    defaultView,
+    focusedView,
+    setFocusedView,
+    setValueAndGoToNextView
+  } = (0, _useViews.useViews)({
+    view: viewProp,
+    views,
+    openTo,
+    onChange: setValueFromView,
+    onViewChange,
+    autoFocus: autoFocusView
   });
-  const providerProps = usePickerProvider({
-    props,
-    localeText,
-    valueManager,
-    variant,
-    paramsFromUsePickerValue: pickerValueResponse.provider,
-    paramsFromUsePickerViews: pickerViewsResponse.provider
+  const clearValue = (0, _useEventCallback.default)(() => setValue(valueManager.emptyValue));
+  const setValueToToday = (0, _useEventCallback.default)(() => setValue(valueManager.getTodayValue(utils, timezone, valueType)));
+  const acceptValueChanges = (0, _useEventCallback.default)(() => setValue(value));
+  const cancelValueChanges = (0, _useEventCallback.default)(() => setValue(state.lastCommittedValue, {
+    skipPublicationIfPristine: true
+  }));
+  const dismissViews = (0, _useEventCallback.default)(() => {
+    setValue(value, {
+      skipPublicationIfPristine: true
+    });
   });
+  const {
+    hasUIView,
+    viewModeLookup,
+    timeViewsCount
+  } = React.useMemo(() => views.reduce((acc, viewForReduce) => {
+    const viewMode = viewRenderers[viewForReduce] == null ? 'field' : 'UI';
+    acc.viewModeLookup[viewForReduce] = viewMode;
+    if (viewMode === 'UI') {
+      acc.hasUIView = true;
+      if ((0, _timeUtils.isTimeView)(viewForReduce)) {
+        acc.timeViewsCount += 1;
+      }
+    }
+    return acc;
+  }, {
+    hasUIView: false,
+    viewModeLookup: {},
+    timeViewsCount: 0
+  }), [viewRenderers, views]);
+  const currentViewMode = viewModeLookup[view];
+  const getCurrentViewMode = (0, _useEventCallback.default)(() => currentViewMode);
+  const [popperView, setPopperView] = React.useState(currentViewMode === 'UI' ? view : null);
+  if (popperView !== view && viewModeLookup[view] === 'UI') {
+    setPopperView(view);
+  }
+  (0, _useEnhancedEffect.default)(() => {
+    // Handle case of Date Time Picker without time renderers
+    if (currentViewMode === 'field' && state.open) {
+      setOpen(false);
+      setTimeout(() => {
+        fieldRef?.current?.setSelectedSections(view);
+        // focusing the input before the range selection is done
+        // calling it outside of timeout results in an inconsistent behavior between Safari And Chrome
+        fieldRef?.current?.focusField(view);
+      });
+    }
+  }, [view]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  (0, _useEnhancedEffect.default)(() => {
+    if (!state.open) {
+      return;
+    }
+    let newView = view;
+
+    // If the current view is a field view, go to the last popper view
+    if (currentViewMode === 'field' && popperView != null) {
+      newView = popperView;
+    }
+
+    // If the current view is not the default view and both are UI views
+    if (newView !== defaultView && viewModeLookup[newView] === 'UI' && viewModeLookup[defaultView] === 'UI') {
+      newView = defaultView;
+    }
+    if (newView !== view) {
+      setView(newView);
+    }
+    setFocusedView(newView, true);
+  }, [state.open]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  const ownerState = React.useMemo(() => ({
+    isPickerValueEmpty: valueManager.areValuesEqual(utils, value, valueManager.emptyValue),
+    isPickerOpen: state.open,
+    isPickerDisabled: props.disabled ?? false,
+    isPickerReadOnly: props.readOnly ?? false,
+    pickerOrientation: orientation,
+    pickerVariant: variant
+  }), [utils, valueManager, value, state.open, orientation, variant, props.disabled, props.readOnly]);
+  const triggerStatus = React.useMemo(() => {
+    if (disableOpenPicker || !hasUIView) {
+      return 'hidden';
+    }
+    if (disabled || readOnly) {
+      return 'disabled';
+    }
+    return 'enabled';
+  }, [disableOpenPicker, hasUIView, disabled, readOnly]);
+  const actionsContextValue = React.useMemo(() => ({
+    setValue,
+    setOpen,
+    clearValue,
+    setValueToToday,
+    acceptValueChanges,
+    cancelValueChanges,
+    setView
+  }), [setValue, setOpen, clearValue, setValueToToday, acceptValueChanges, cancelValueChanges, setView]);
+  const contextValue = React.useMemo(() => (0, _extends2.default)({}, actionsContextValue, {
+    value,
+    timezone,
+    open: state.open,
+    views,
+    view: popperView,
+    initialView,
+    disabled: disabled ?? false,
+    readOnly: readOnly ?? false,
+    autoFocus: autoFocus ?? false,
+    variant,
+    orientation,
+    popupRef,
+    reduceAnimations,
+    triggerRef,
+    triggerStatus,
+    fieldFormat: format ?? '',
+    name,
+    label,
+    rootSx: sx,
+    rootRef,
+    rootClassName: className
+  }), [actionsContextValue, value, rootRef, variant, orientation, reduceAnimations, disabled, readOnly, format, className, name, label, sx, triggerStatus, timezone, state.open, popperView, views, initialView, autoFocus]);
+  const privateContextValue = React.useMemo(() => ({
+    dismissViews,
+    ownerState,
+    hasUIView,
+    getCurrentViewMode,
+    rootRefObject,
+    labelId,
+    triggerElement,
+    viewContainerRole
+  }), [dismissViews, ownerState, hasUIView, getCurrentViewMode, labelId, triggerElement, viewContainerRole]);
+  const fieldPrivateContextValue = React.useMemo(() => ({
+    formatDensity,
+    enableAccessibleFieldDOMStructure,
+    selectedSections,
+    onSelectedSectionsChange,
+    fieldRef
+  }), [formatDensity, enableAccessibleFieldDOMStructure, selectedSections, onSelectedSectionsChange, fieldRef]);
+  const isValidContextValue = testedValue => {
+    const error = validator({
+      adapter,
+      value: testedValue,
+      timezone,
+      props
+    });
+    return !valueManager.hasError(error);
+  };
+  const renderCurrentView = () => {
+    if (popperView == null) {
+      return null;
+    }
+    const renderer = viewRenderers[popperView];
+    if (renderer == null) {
+      return null;
+    }
+    const rendererProps = (0, _extends2.default)({}, propsToForwardToView, {
+      views,
+      timezone,
+      value: viewValue,
+      onChange: setValueAndGoToNextView,
+      view: popperView,
+      onViewChange: setView,
+      showViewSwitcher: timeViewsCount > 1,
+      timeViewsCount
+    }, viewContainerRole === 'tooltip' ? {
+      focusedView: null,
+      onFocusedViewChange: () => {}
+    } : {
+      focusedView,
+      onFocusedViewChange: setFocusedView
+    });
+    if (RendererInterceptor) {
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)(RendererInterceptor, {
+        viewRenderers: viewRenderers,
+        popperView: popperView,
+        rendererProps: rendererProps
+      });
+    }
+    return renderer(rendererProps);
+  };
   return {
-    // Picker views
-    renderCurrentView: pickerViewsResponse.renderCurrentView,
-    shouldRestoreFocus: pickerViewsResponse.shouldRestoreFocus,
-    // Picker provider
-    providerProps,
-    // Picker owner state
-    ownerState: providerProps.privateContextValue.ownerState
+    providerProps: {
+      localeText,
+      contextValue,
+      privateContextValue,
+      actionsContextValue,
+      fieldPrivateContextValue,
+      isValidContextValue
+    },
+    renderCurrentView,
+    ownerState
   };
-};
+};
+exports.usePicker = usePicker;

package/internals/hooks/usePicker/usePicker.types.d.ts

@@ -1,19 +1,183 @@
-import { UsePickerValueParams, UsePickerValueProps, UsePickerValueBaseProps } from './usePickerValue.types';
-import { UsePickerViewsProps, UsePickerViewParams, UsePickerViewsResponse, UsePickerViewsBaseProps } from './usePickerViews';
-import { InferError, PickerOwnerState } from '../../../models';
-import { DateOrTimeViewWithMeridiem, PickerValidValue } from '../../models';
-import { UsePickerProviderParameters, UsePickerProviderProps, UsePickerProviderReturnValue } from './usePickerProvider';
+import { SxProps } from '@mui/system';
+import { Theme } from '@mui/material/styles';
+import { InferError, OnErrorProps, PickerChangeHandlerContext, PickerOwnerState, PickerValidDate, PickerValueType, TimezoneProps } from "../../../models/index.js";
+import { DateOrTimeViewWithMeridiem, FormProps, PickerOrientation, PickerValidValue, PickerValueManager, PickerVariant } from "../../models/index.js";
+import { Validator } from "../../../validation/index.js";
+import { UseViewsOptions } from "../useViews.js";
+import { PickerProviderProps } from "../../components/PickerProvider.js";
+import { PickersInputLocaleText } from "../../../locales/index.js";
+import { PickerFieldPrivateContextValue } from "../useNullableFieldPrivateContext.js";
 /**
- * Props common to all picker headless implementations.
+ * Props common to all Picker headless implementations.
+ * Those props are exposed on all the Pickers.
  */
-export interface UsePickerBaseProps<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem, TError, TExternalProps extends UsePickerViewsProps<TValue, TView, any>> extends UsePickerValueBaseProps<TValue, TError>, UsePickerViewsBaseProps<TValue, TView, TExternalProps>, UsePickerProviderProps {
+export interface UsePickerBaseProps<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem, TError, TExternalProps extends UsePickerProps<TValue, TView, TError, any>> extends OnErrorProps<TValue, TError>, Omit<UseViewsOptions<any, TView>, 'onChange' | 'onFocusedViewChange' | 'focusedView'>, TimezoneProps, FormProps {
+  /**
+   * The selected value.
+   * Used when the component is controlled.
+   */
+  value?: TValue;
+  /**
+   * The default value.
+   * Used when the component is not controlled.
+   */
+  defaultValue?: TValue;
+  /**
+   * Callback fired when the value changes.
+   * @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.
+   * @template TError The validation error type. It will be either `string` or a `null`. It can be in `[start, end]` format in case of range value.
+   * @param {TValue} value The new value.
+   * @param {FieldChangeHandlerContext<TError>} context The context containing the validation result of the current value.
+   */
+  onChange?: (value: TValue, context: PickerChangeHandlerContext<TError>) => void;
+  /**
+   * Callback fired when the value is accepted.
+   * @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.
+   * @template TError The validation error type. It will be either `string` or a `null`. It can be in `[start, end]` format in case of range value.
+   * @param {TValue} value The value that was just accepted.
+   * @param {FieldChangeHandlerContext<TError>} context The context containing the validation result of the current value.
+   */
+  onAccept?: (value: TValue, context: PickerChangeHandlerContext<TError>) => void;
+  /**
+   * If `null`, the section will only have field editing.
+   * If `undefined`, internally defined view will be used.
+   */
+  viewRenderers: PickerViewRendererLookup<TValue, TView, TExternalProps>;
+  /**
+   * The date used to generate the new value when both `value` and `defaultValue` are empty.
+   * @default The closest valid date-time using the validation props, except callbacks like `shouldDisable<...>`.
+   */
+  referenceDate?: PickerValidDate;
+  /**
+   * Force rendering in particular orientation.
+   */
+  orientation?: PickerOrientation;
+  /**
+   * If `true`, disable heavy animations.
+   * @default `@media(prefers-reduced-motion: reduce)` || `navigator.userAgent` matches Android <10 or iOS <13
+   */
+  reduceAnimations?: boolean;
 }
-export interface UsePickerProps<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem, TError, TExternalProps extends UsePickerViewsProps<TValue, TView, any>> extends UsePickerValueProps<TValue, TError>, UsePickerViewsProps<TValue, TView, TExternalProps>, UsePickerProviderProps {
+/**
+ * Props used to handle the value of non-static Pickers.
+ */
+export interface UsePickerNonStaticProps extends Omit<PickerFieldPrivateContextValue, 'fieldRef'> {
+  /**
+   * If `true`, the Picker will close after submitting the full date.
+   * @default false
+   */
+  closeOnSelect?: boolean;
+  /**
+   * Control the popup or dialog open state.
+   * @default false
+   */
+  open?: boolean;
+  /**
+   * Callback fired when the popup requests to be closed.
+   * Use in controlled mode (see `open`).
+   */
+  onClose?: () => void;
+  /**
+   * Callback fired when the popup requests to be opened.
+   * Use in controlled mode (see `open`).
+   */
+  onOpen?: () => void;
+  /**
+   * Format of the date when rendered in the input(s).
+   * Defaults to localized format based on the used `views`.
+   */
+  format?: string;
+  /**
+   * If `true`, the button to open the Picker will not be rendered (it will only render the field).
+   * @default false
+   */
+  disableOpenPicker?: boolean;
+  /**
+   * The label content.
+   */
+  label?: React.ReactNode;
+  /**
+   * Pass a ref to the `input` element.
+   */
+  inputRef?: React.Ref<HTMLInputElement>;
+  /**
+   * Name attribute used by the `input` element in the Field.
+   */
+  name?: string;
+}
+export interface UsePickerProps<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem, TError, TExternalProps extends UsePickerProps<TValue, TView, TError, any>> extends UsePickerBaseProps<TValue, TView, TError, TExternalProps>, UsePickerNonStaticProps {
+  referenceDate?: PickerValidDate;
+  className?: string;
+  sx?: SxProps<Theme>;
+}
+export interface UsePickerParameters<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem, TExternalProps extends UsePickerProps<TValue, TView, any, any>> {
+  ref: React.ForwardedRef<HTMLDivElement> | undefined;
+  localeText: PickersInputLocaleText | undefined;
+  variant: PickerVariant;
+  valueManager: PickerValueManager<TValue, InferError<TExternalProps>>;
+  valueType: PickerValueType;
+  validator: Validator<TValue, InferError<TExternalProps>, TExternalProps>;
+  autoFocusView: boolean;
+  viewContainerRole: 'dialog' | 'tooltip' | null;
+  /**
+   * A function that intercepts the regular Picker rendering.
+   * Can be used to consume the provided `viewRenderers` and render a custom component wrapping them.
+   * @param {PickerViewRendererLookup<TValue, TView, TExternalProps>} viewRenderers The `viewRenderers` provided to the Picker component.
+   * @param {TView} popperView The current Picker view.
+   * @param {any} rendererProps All the props being passed down to the renderer.
+   * @returns {React.ReactNode} A React node that will be rendered instead of the default renderer.
+   */
+  rendererInterceptor?: React.JSXElementConstructor<PickerRendererInterceptorProps<TValue, TView, TExternalProps>>;
+  props: TExternalProps;
 }
-export interface UsePickerParams<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem, TExternalProps extends UsePickerProps<TValue, TView, any, any>> extends Pick<UsePickerValueParams<TValue, TExternalProps>, 'valueManager' | 'valueType' | 'validator'>, Pick<UsePickerViewParams<TValue, TView, TExternalProps>, 'autoFocusView' | 'rendererInterceptor' | 'fieldRef'>, Pick<UsePickerProviderParameters<TValue, TView, InferError<TExternalProps>>, 'localeText' | 'variant'> {
-    props: TExternalProps;
+export interface UsePickerReturnValue<TValue extends PickerValidValue> {
+  ownerState: PickerOwnerState;
+  renderCurrentView: () => React.ReactNode;
+  providerProps: Omit<PickerProviderProps<TValue>, 'children'>;
 }
-export interface UsePickerResponse<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem> extends Pick<UsePickerViewsResponse<TView>, 'shouldRestoreFocus' | 'renderCurrentView'> {
-    ownerState: PickerOwnerState;
-    providerProps: UsePickerProviderReturnValue<TValue>;
+export type PickerSelectionState = 'partial' | 'shallow' | 'finish';
+export interface UsePickerState<TValue extends PickerValidValue> {
+  /**
+   * Whether the Picker is open.
+   */
+  open: boolean;
+  /**
+   * Last value returned by `useControlledValue`.
+   */
+  lastExternalValue: TValue;
+  /**
+   * Date currently displayed on the views if we are dragging the cursor in the Clock component.
+   */
+  clockShallowValue: TValue | undefined;
+  /**
+   * Last value committed (the last value for which `shouldCommitValue` returned `true`).
+   * If `onAccept` is defined, it's the value that was passed on the last call to this callback.
+   */
+  lastCommittedValue: TValue;
+  /**
+   * If we never modified the value since the mount of the component,
+   * Then we might want to apply some custom logic.
+   *
+   * For example, when the component is not controlled and `defaultValue` is defined.
+   * Then clicking on "Accept", "Today" or "Clear" should fire `onAccept` with `defaultValue`, but clicking on "Cancel" or dismissing the Picker should not.
+   */
+  hasBeenModifiedSinceMount: boolean;
 }
+export interface PickerViewsRendererBaseExternalProps extends Omit<UsePickerProps<any, any, any, any>, 'openTo' | 'viewRenderers' | 'onChange'> {}
+export type PickerViewsRendererProps<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem, TExternalProps extends PickerViewsRendererBaseExternalProps> = Omit<TExternalProps, 'className' | 'sx'> & {
+  value: TValue;
+  onChange: (value: TValue, selectionState?: PickerSelectionState) => void;
+  view: TView;
+  views: readonly TView[];
+  focusedView: TView | null;
+  onFocusedViewChange: (viewToFocus: TView, hasFocus: boolean) => void;
+  showViewSwitcher: boolean;
+  timeViewsCount: number;
+};
+export type PickerViewRenderer<TValue extends PickerValidValue, TExternalProps extends PickerViewsRendererBaseExternalProps> = (props: PickerViewsRendererProps<TValue, any, TExternalProps>) => React.ReactNode;
+export type PickerViewRendererLookup<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem, TExternalProps extends PickerViewsRendererBaseExternalProps> = Record<TView, PickerViewRenderer<TValue, TExternalProps> | null>;
+export interface PickerRendererInterceptorProps<TValue extends PickerValidValue, TView extends DateOrTimeViewWithMeridiem, TExternalProps extends UsePickerProps<TValue, TView, any, TExternalProps>> {
+  viewRenderers: PickerViewRendererLookup<TValue, TView, TExternalProps>;
+  popperView: TView;
+  rendererProps: PickerViewsRendererProps<TValue, TView, TExternalProps>;
+}

package/internals/hooks/usePicker/usePicker.types.js

@@ -1 +1,5 @@
-export {};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/internals/hooks/usePickerPrivateContext.d.ts

@@ -1,4 +1,4 @@
 /**
- * Returns the private context passed by the picker that wraps the current component.
+ * Returns the private context passed by the Picker wrapping the current component.
  */
-export declare const usePickerPrivateContext: () => import("../components/PickerProvider").PickerPrivateContextValue;
+export declare const usePickerPrivateContext: () => import("../components/PickerProvider").PickerPrivateContextValue;

package/internals/hooks/usePickerPrivateContext.js

@@ -1,9 +1,15 @@
+"use strict";
 'use client';
 
-import * as React from 'react';
-import { PickerPrivateContext } from "../components/PickerProvider.js";
-
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePickerPrivateContext = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _PickerProvider = require("../components/PickerProvider");
 /**
- * Returns the private context passed by the picker that wraps the current component.
+ * Returns the private context passed by the Picker wrapping the current component.
  */
-export const usePickerPrivateContext = () => React.useContext(PickerPrivateContext);
+const usePickerPrivateContext = () => React.useContext(_PickerProvider.PickerPrivateContext);
+exports.usePickerPrivateContext = usePickerPrivateContext;

package/internals/hooks/useReduceAnimations.d.ts

@@ -0,0 +1,2 @@
+export declare const slowAnimationDevices: boolean;
+export declare function useReduceAnimations(customReduceAnimations: boolean | undefined): boolean;

package/internals/hooks/useReduceAnimations.js

@@ -0,0 +1,25 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.slowAnimationDevices = void 0;
+exports.useReduceAnimations = useReduceAnimations;
+var _useMediaQuery = _interopRequireDefault(require("@mui/material/useMediaQuery"));
+const PREFERS_REDUCED_MOTION = '@media (prefers-reduced-motion: reduce)';
+
+// detect if user agent has Android version < 10 or iOS version < 13
+const mobileVersionMatches = typeof navigator !== 'undefined' && navigator.userAgent.match(/android\s(\d+)|OS\s(\d+)/i);
+const androidVersion = mobileVersionMatches && mobileVersionMatches[1] ? parseInt(mobileVersionMatches[1], 10) : null;
+const iOSVersion = mobileVersionMatches && mobileVersionMatches[2] ? parseInt(mobileVersionMatches[2], 10) : null;
+const slowAnimationDevices = exports.slowAnimationDevices = androidVersion && androidVersion < 10 || iOSVersion && iOSVersion < 13 || false;
+function useReduceAnimations(customReduceAnimations) {
+  const prefersReduced = (0, _useMediaQuery.default)(PREFERS_REDUCED_MOTION, {
+    defaultMatches: false
+  });
+  if (customReduceAnimations != null) {
+    return customReduceAnimations;
+  }
+  return prefersReduced || slowAnimationDevices;
+}

package/internals/hooks/useStaticPicker/index.d.ts

@@ -1,2 +1,2 @@
-export { useStaticPicker } from './useStaticPicker';
-export type { UseStaticPickerSlots, UseStaticPickerSlotProps, StaticOnlyPickerProps, } from './useStaticPicker.types';
+export { useStaticPicker } from "./useStaticPicker.js";
+export type { UseStaticPickerSlots, UseStaticPickerSlotProps, StaticOnlyPickerProps } from './useStaticPicker.types';

package/internals/hooks/useStaticPicker/index.js

@@ -1 +1,12 @@
-export { useStaticPicker } from "./useStaticPicker.js";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "useStaticPicker", {
+  enumerable: true,
+  get: function () {
+    return _useStaticPicker.useStaticPicker;
+  }
+});
+var _useStaticPicker = require("./useStaticPicker");

package/internals/hooks/useStaticPicker/useStaticPicker.d.ts

@@ -1,12 +1,15 @@
 import * as React from 'react';
-import { UseStaticPickerParams, UseStaticPickerProps } from './useStaticPicker.types';
-import { DateOrTimeViewWithMeridiem } from '../../models';
+import { UseStaticPickerParams, UseStaticPickerProps } from "./useStaticPicker.types.js";
+import { DateOrTimeViewWithMeridiem } from "../../models/index.js";
 /**
  * Hook managing all the single-date static pickers:
  * - StaticDatePicker
  * - StaticDateTimePicker
  * - StaticTimePicker
  */
-export declare const useStaticPicker: <TView extends DateOrTimeViewWithMeridiem, TExternalProps extends UseStaticPickerProps<TView, any, TExternalProps>>({ props, ref, ...pickerParams }: UseStaticPickerParams<TView, TExternalProps>) => {
-    renderPicker: () => React.JSX.Element;
-};
+export declare const useStaticPicker: <TView extends DateOrTimeViewWithMeridiem, TExternalProps extends UseStaticPickerProps<TView, any, TExternalProps>>({
+  props,
+  ...pickerParams
+}: UseStaticPickerParams<TView, TExternalProps>) => {
+  renderPicker: () => React.JSX.Element;
+};