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

package/hooks/useMultiInputRangeField/useMultiInputRangeField.js

@@ -1,11 +1,15 @@
+"use strict";
 'use client';
 
-import _extends from "@babel/runtime/helpers/esm/extends";
-import useEventCallback from '@mui/utils/useEventCallback';
-import { useControlledValueWithTimezone, useFieldInternalPropsWithDefaults } from '@mui/x-date-pickers/internals';
-import { useValidation } from '@mui/x-date-pickers/validation';
-import { useMultiInputRangeFieldTextFieldProps } from "./useMultiInputRangeFieldTextFieldProps.js";
-import { useMultiInputRangeFieldSelectedSections } from "./useMultiInputRangeFieldSelectedSections.js";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useMultiInputRangeField = useMultiInputRangeField;
+var _internals = require("@mui/x-date-pickers/internals");
+var _validation = require("@mui/x-date-pickers/validation");
+var _useTextFieldProps = require("./useTextFieldProps");
+var _useMultiInputRangeFieldSelectedSections = require("./useMultiInputRangeFieldSelectedSections");
+var _useMultiInputRangeFieldRootProps = require("./useMultiInputRangeFieldRootProps");
 /**
  * Basic example:
  *
@@ -18,38 +22,40 @@ import { useMultiInputRangeFieldSelectedSections } from "./useMultiInputRangeFie
  * function MultiInputField(props) {
  *   const manager = useDateRangeManager();
  *   const { internalProps, forwardedProps } = useSplitFieldProps(props, 'date');
- *   const { startDate, endDate } = useMultiInputRangeField({
+ *   const response = useMultiInputRangeField({
  *     manager,
  *     internalProps,
- *     startForwardedProps: forwardedProps,
- *     endForwardedProps: forwardedProps,
+ *     startTextFieldProps: {},
+ *     endTextFieldProps: {},
+ *     rootProps: forwardedProps,
  *   });
  *
  *   return (
- *     <Box {...forwardedProps}>
- *       <PickersTextField {...startDate} />
+ *     <Box {...response.root}>
+ *       <PickersTextField {...response.startTextField} />
  *       <span>{' – '}</span>
- *       <PickersTextField {...endDate} />
+ *       <PickersTextField {...response.endTextField} />
  *     </Box>
  *   );
  * }
  * ```
  *
- * @param {UseMultiInputRangeFieldParameters<TManager, TForwardedProps>} parameters The parameters of the hook.
+ * @param {UseMultiInputRangeFieldParameters<TManager, TTextFieldProps>} parameters The parameters of the hook.
  * @param {TManager} parameters.manager The manager of the field.
  * @param {PickerManagerFieldInternalProps<TManager>} parameters.internalProps The internal props of the field.
- * @param {TForwardedProps} parameters.startForwardedProps The forwarded props of the start field.
- * @param {TForwardedProps} parameters.endForwardedProps The forwarded props of the end field.
- * @returns {UseMultiInputRangeFieldReturnValue<TManager, TForwardedProps>} The props to pass to the start and the end components.
+ * @param {TTextFieldProps} parameters.startForwardedProps The forwarded props of the start field.
+ * @param {TTextFieldProps} parameters.endForwardedProps The forwarded props of the end field.
+ * @returns {UseMultiInputRangeFieldReturnValue<TManager, TTextFieldProps>} The props to pass to the start and the end components.
  */
-export function useMultiInputRangeField(parameters) {
+function useMultiInputRangeField(parameters) {
   const {
     manager,
     internalProps,
-    startForwardedProps,
-    endForwardedProps
+    rootProps,
+    startTextFieldProps,
+    endTextFieldProps
   } = parameters;
-  const internalPropsWithDefaults = useFieldInternalPropsWithDefaults({
+  const internalPropsWithDefaults = (0, _internals.useFieldInternalPropsWithDefaults)({
     manager,
     internalProps
   });
@@ -75,7 +81,7 @@ export function useMultiInputRangeField(parameters) {
     value,
     handleValueChange,
     timezone
-  } = useControlledValueWithTimezone({
+  } = (0, _internals.useControlledValue)({
     name: 'useMultiInputRangeField',
     timezone: timezoneProp,
     value: valueProp,
@@ -84,34 +90,20 @@ export function useMultiInputRangeField(parameters) {
     onChange,
     valueManager: manager.internal_valueManager
   });
-  const {
-    validationError,
-    getValidationErrorForNewValue
-  } = useValidation({
+  const validation = (0, _validation.useValidation)({
     props: internalPropsWithDefaults,
     value,
     timezone,
     validator: manager.validator,
     onError: internalPropsWithDefaults.onError
   });
-  const buildChangeHandler = index => {
-    return (newSingleValue, rawContext) => {
-      const newRange = index === 0 ? [newSingleValue, value[1]] : [value[0], newSingleValue];
-      const context = _extends({}, rawContext, {
-        validationError: getValidationErrorForNewValue(newRange)
-      });
-      handleValueChange(newRange, context);
-    };
-  };
-  const handleStartDateChange = useEventCallback(buildChangeHandler(0));
-  const handleEndDateChange = useEventCallback(buildChangeHandler(1));
-  const selectedSectionsResponse = useMultiInputRangeFieldSelectedSections({
+  const selectedSectionsResponse = (0, _useMultiInputRangeFieldSelectedSections.useMultiInputRangeFieldSelectedSections)({
     selectedSections,
     onSelectedSectionsChange,
     unstableStartFieldRef,
     unstableEndFieldRef
   });
-  const sharedProps = {
+  const sharedInternalProps = {
     disabled,
     readOnly,
     timezone,
@@ -120,30 +112,33 @@ export function useMultiInputRangeField(parameters) {
     shouldRespectLeadingZeros,
     enableAccessibleFieldDOMStructure
   };
-  const startDateProps = useMultiInputRangeFieldTextFieldProps({
+  const rootResponse = (0, _useMultiInputRangeFieldRootProps.useMultiInputRangeFieldRootProps)(rootProps);
+  const startTextFieldResponse = (0, _useTextFieldProps.useTextFieldProps)({
     valueType: manager.valueType,
-    fieldProps: _extends({
-      error: !!validationError[0]
-    }, startForwardedProps, selectedSectionsResponse.start, sharedProps, {
-      value: valueProp === undefined ? undefined : valueProp[0],
-      defaultValue: defaultValue === undefined ? undefined : defaultValue[0],
-      onChange: handleStartDateChange,
-      autoFocus // Do not add on end field.
-    })
+    position: 'start',
+    value,
+    onChange: handleValueChange,
+    autoFocus,
+    validation,
+    forwardedProps: startTextFieldProps,
+    selectedSectionProps: selectedSectionsResponse.start,
+    sharedInternalProps
   });
-  const endDateProps = useMultiInputRangeFieldTextFieldProps({
+  const endTextFieldResponse = (0, _useTextFieldProps.useTextFieldProps)({
     valueType: manager.valueType,
-    fieldProps: _extends({
-      error: !!validationError[1]
-    }, endForwardedProps, selectedSectionsResponse.end, sharedProps, {
-      value: valueProp === undefined ? undefined : valueProp[1],
-      defaultValue: defaultValue === undefined ? undefined : defaultValue[1],
-      onChange: handleEndDateChange
-    })
+    position: 'end',
+    value,
+    onChange: handleValueChange,
+    autoFocus,
+    validation,
+    forwardedProps: endTextFieldProps,
+    selectedSectionProps: selectedSectionsResponse.end,
+    sharedInternalProps
   });
   return {
-    startDate: startDateProps,
-    endDate: endDateProps,
+    root: rootResponse,
+    startTextField: startTextFieldResponse,
+    endTextField: endTextFieldResponse,
     enableAccessibleFieldDOMStructure
   };
 }

package/hooks/useMultiInputRangeField/useMultiInputRangeFieldRootProps.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @ignore - internal hook.
+ */
+export declare function useMultiInputRangeFieldRootProps<TForwardedProps extends {
+  [key: string]: any;
+}>(forwardedProps: TForwardedProps): UseMultiInputRangeFieldRootPropsReturnValue<TForwardedProps>;
+export type UseMultiInputRangeFieldRootPropsReturnValue<TForwardedProps extends {
+  [key: string]: any;
+}> = Omit<TForwardedProps, 'onBlur'> & {
+  onBlur: () => void;
+};

package/hooks/useMultiInputRangeField/useMultiInputRangeFieldRootProps.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useMultiInputRangeFieldRootProps = useMultiInputRangeFieldRootProps;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
+var _internals = require("@mui/x-date-pickers/internals");
+/**
+ * @ignore - internal hook.
+ */
+function useMultiInputRangeFieldRootProps(forwardedProps) {
+  const pickerContext = (0, _internals.useNullablePickerContext)();
+  const privatePickerContext = (0, _internals.usePickerPrivateContext)();
+  const handleBlur = (0, _useEventCallback.default)(() => {
+    if (!pickerContext || privatePickerContext.viewContainerRole !== 'tooltip') {
+      return;
+    }
+    (0, _internals.executeInTheNextEventLoopTick)(() => {
+      if (privatePickerContext.rootRefObject.current?.contains((0, _internals.getActiveElement)(document)) || pickerContext.popupRef.current?.contains((0, _internals.getActiveElement)(document))) {
+        return;
+      }
+      privatePickerContext.dismissViews();
+    });
+  });
+  return (0, _extends2.default)({}, forwardedProps, {
+    onBlur: handleBlur
+  });
+}

package/hooks/useMultiInputRangeField/useMultiInputRangeFieldSelectedSections.d.ts

@@ -1,17 +1,19 @@
 import * as React from 'react';
 import { PickerRangeValue, PickerValue, UseFieldInternalProps } from '@mui/x-date-pickers/internals';
 import { FieldRef, FieldSelectedSections } from '@mui/x-date-pickers/models';
-import { MultiInputFieldRefs } from '../../models';
-interface UseMultiInputRangeFieldSelectedSectionsParameters extends Pick<UseFieldInternalProps<PickerRangeValue, any, any>, 'selectedSections' | 'onSelectedSectionsChange'>, MultiInputFieldRefs {
-}
-interface UseMultiInputFieldSelectedSectionsResponseItem {
-    unstableFieldRef?: React.Ref<FieldRef<PickerValue>>;
-    selectedSections: FieldSelectedSections;
-    onSelectedSectionsChange: (newSelectedSections: FieldSelectedSections) => void;
+import { MultiInputFieldRefs } from "../../models/index.js";
+interface UseMultiInputRangeFieldSelectedSectionsParameters extends Pick<UseFieldInternalProps<PickerRangeValue, any, any>, 'selectedSections' | 'onSelectedSectionsChange'>, MultiInputFieldRefs {}
+export interface UseMultiInputFieldSelectedSectionsResponseItem {
+  unstableFieldRef?: React.Ref<FieldRef<PickerValue>>;
+  selectedSections: FieldSelectedSections;
+  onSelectedSectionsChange: (newSelectedSections: FieldSelectedSections) => void;
 }
 interface UseMultiInputFieldSelectedSectionsResponse {
-    start: UseMultiInputFieldSelectedSectionsResponseItem;
-    end: UseMultiInputFieldSelectedSectionsResponseItem;
+  start: UseMultiInputFieldSelectedSectionsResponseItem;
+  end: UseMultiInputFieldSelectedSectionsResponseItem;
 }
+/**
+ * @ignore - internal hook.
+ */
 export declare const useMultiInputRangeFieldSelectedSections: (parameters: UseMultiInputRangeFieldSelectedSectionsParameters) => UseMultiInputFieldSelectedSectionsResponse;
-export {};
+export {};

package/hooks/useMultiInputRangeField/useMultiInputRangeFieldSelectedSections.js

@@ -1,11 +1,20 @@
-'use client';
+"use strict";
 
-import * as React from 'react';
-import useForkRef from '@mui/utils/useForkRef';
-import useEventCallback from '@mui/utils/useEventCallback';
-export const useMultiInputRangeFieldSelectedSections = parameters => {
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useMultiInputRangeFieldSelectedSections = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _useForkRef = _interopRequireDefault(require("@mui/utils/useForkRef"));
+var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
+/**
+ * @ignore - internal hook.
+ */
+const useMultiInputRangeFieldSelectedSections = parameters => {
   const unstableEndFieldRef = React.useRef(null);
-  const handleUnstableEndFieldRef = useForkRef(parameters.unstableEndFieldRef, unstableEndFieldRef);
+  const handleUnstableEndFieldRef = (0, _useForkRef.default)(parameters.unstableEndFieldRef, unstableEndFieldRef);
   const [startSelectedSection, setStartSelectedSection] = React.useState(parameters.selectedSections ?? null);
   const [endSelectedSection, setEndSelectedSection] = React.useState(null);
   const getActiveField = () => {
@@ -14,13 +23,13 @@ export const useMultiInputRangeFieldSelectedSections = parameters => {
     }
     return 'start';
   };
-  const handleStartSelectedSectionChange = useEventCallback(newSelectedSections => {
+  const handleStartSelectedSectionChange = (0, _useEventCallback.default)(newSelectedSections => {
     setStartSelectedSection(newSelectedSections);
     if (getActiveField() === 'start') {
       parameters.onSelectedSectionsChange?.(newSelectedSections);
     }
   });
-  const handleEndSelectedSectionChange = useEventCallback(newSelectedSections => {
+  const handleEndSelectedSectionChange = (0, _useEventCallback.default)(newSelectedSections => {
     setEndSelectedSection(newSelectedSections);
     if (getActiveField() === 'end') {
       parameters.onSelectedSectionsChange?.(newSelectedSections);
@@ -39,4 +48,5 @@ export const useMultiInputRangeFieldSelectedSections = parameters => {
       onSelectedSectionsChange: handleEndSelectedSectionChange
     }
   };
-};
+};
+exports.useMultiInputRangeFieldSelectedSections = useMultiInputRangeFieldSelectedSections;

package/hooks/useMultiInputRangeField/useTextFieldProps.d.ts

@@ -0,0 +1,30 @@
+import * as React from 'react';
+import { UseValidationReturnValue } from '@mui/x-date-pickers/validation';
+import { PickerValueType } from '@mui/x-date-pickers/models';
+import { FieldChangeHandler, PickerManagerEnableAccessibleFieldDOMStructure, PickerManagerError, PickerRangeValue, PickerValue, RangePosition, UseFieldInternalProps } from '@mui/x-date-pickers/internals';
+import { PickerAnyRangeManager } from "../../internals/models/managers.js";
+import { UseMultiInputFieldSelectedSectionsResponseItem } from "./useMultiInputRangeFieldSelectedSections.js";
+import type { UseMultiInputRangeFieldTextFieldProps } from './useMultiInputRangeField';
+/**
+ * @ignore - internal hook.
+ */
+export declare function useTextFieldProps<TManager extends PickerAnyRangeManager, TForwardedProps extends UseTextFieldBaseForwardedProps>(parameters: UseTextFieldPropsParameters<TManager, TForwardedProps>): UseMultiInputRangeFieldTextFieldProps<PickerManagerEnableAccessibleFieldDOMStructure<TManager>, TForwardedProps>;
+interface UseTextFieldPropsParameters<TManager extends PickerAnyRangeManager, TForwardedProps extends UseTextFieldBaseForwardedProps> {
+  valueType: PickerValueType;
+  value: PickerRangeValue;
+  onChange: FieldChangeHandler<PickerRangeValue, PickerManagerError<TManager>>;
+  autoFocus: boolean | undefined;
+  forwardedProps: TForwardedProps;
+  sharedInternalProps: UseTextFieldSharedInternalProps<TManager>;
+  selectedSectionProps: UseMultiInputFieldSelectedSectionsResponseItem;
+  position: RangePosition;
+  validation: UseValidationReturnValue<PickerRangeValue, PickerManagerError<TManager>>;
+}
+export interface UseTextFieldBaseForwardedProps {
+  onKeyDown?: React.KeyboardEventHandler;
+  onClick?: React.MouseEventHandler;
+  onFocus?: React.FocusEventHandler;
+  [key: string]: any;
+}
+interface UseTextFieldSharedInternalProps<TManager extends PickerAnyRangeManager> extends Pick<UseFieldInternalProps<PickerValue, PickerManagerEnableAccessibleFieldDOMStructure<TManager>, PickerManagerError<TManager>>, 'enableAccessibleFieldDOMStructure' | 'disabled' | 'readOnly' | 'timezone' | 'format' | 'formatDensity' | 'shouldRespectLeadingZeros'> {}
+export {};

package/hooks/useMultiInputRangeField/useTextFieldProps.js

@@ -0,0 +1,137 @@
+"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.useTextFieldProps = useTextFieldProps;
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var React = _interopRequireWildcard(require("react"));
+var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
+var _managers = require("@mui/x-date-pickers/managers");
+var _internals = require("@mui/x-date-pickers/internals");
+var _useNullablePickerRangePositionContext = require("../../internals/hooks/useNullablePickerRangePositionContext");
+const _excluded = ["clearable", "onClear", "openPickerAriaLabel"];
+/**
+ * @ignore - internal hook.
+ */
+function useTextFieldProps(parameters) {
+  const pickerContext = (0, _internals.useNullablePickerContext)();
+  const fieldPrivateContext = (0, _internals.useNullableFieldPrivateContext)();
+  const pickerPrivateContext = (0, _internals.usePickerPrivateContext)();
+  const rangePositionContext = (0, _useNullablePickerRangePositionContext.useNullablePickerRangePositionContext)();
+  const rangePosition = rangePositionContext?.rangePosition ?? 'start';
+  const setRangePosition = rangePositionContext?.setRangePosition;
+  const previousRangePosition = React.useRef(rangePosition);
+  const {
+    forwardedProps,
+    sharedInternalProps,
+    selectedSectionProps,
+    valueType,
+    position,
+    value,
+    onChange,
+    autoFocus,
+    validation
+  } = parameters;
+  let useManager;
+  switch (valueType) {
+    case 'date':
+      {
+        useManager = _managers.useDateManager;
+        break;
+      }
+    case 'time':
+      {
+        useManager = _managers.useTimeManager;
+        break;
+      }
+    case 'date-time':
+      {
+        useManager = _managers.useDateTimeManager;
+        break;
+      }
+    default:
+      {
+        throw new Error(`Unknown valueType: ${valueType}`);
+      }
+  }
+  const manager = useManager({
+    enableAccessibleFieldDOMStructure: sharedInternalProps.enableAccessibleFieldDOMStructure
+  });
+  const openPickerIfPossible = event => {
+    if (!pickerContext) {
+      return;
+    }
+    setRangePosition?.(position);
+    if (pickerContext.triggerStatus === 'enabled') {
+      event.preventDefault();
+      pickerContext.setOpen(true);
+    }
+  };
+  const handleKeyDown = (0, _useEventCallback.default)(event => {
+    if (event.key === 'Enter' || event.key === ' ') {
+      openPickerIfPossible(event);
+    }
+  });
+
+  // Registering `onClick` listener on the root element as well to correctly handle cases where user is clicking on `label`
+  // which has `pointer-events: none` and due to DOM structure the `input` does not catch the click event
+  const handleClick = (0, _useEventCallback.default)(event => {
+    openPickerIfPossible(event);
+  });
+  const handleFocus = (0, _useEventCallback.default)(event => {
+    forwardedProps.onFocus?.(event);
+    if (pickerContext?.open) {
+      setRangePosition?.(position);
+      if (previousRangePosition.current !== position && pickerContext.initialView) {
+        pickerContext.setView?.(pickerContext.initialView);
+      }
+    }
+  });
+  const handleChange = (0, _useEventCallback.default)((newSingleValue, rawContext) => {
+    const newRange = position === 'start' ? [newSingleValue, value[1]] : [value[0], newSingleValue];
+    const context = (0, _extends2.default)({}, rawContext, {
+      validationError: validation.getValidationErrorForNewValue(newRange)
+    });
+    onChange(newRange, context);
+  });
+  const allProps = (0, _extends2.default)({
+    value: position === 'start' ? value[0] : value[1],
+    error: position === 'start' ? !!validation.validationError[0] : !!validation.validationError[1],
+    id: `${pickerPrivateContext.labelId}-${position}`,
+    autoFocus: position === 'start' ? autoFocus : undefined
+  }, forwardedProps, sharedInternalProps, selectedSectionProps, {
+    onClick: handleClick,
+    onFocus: handleFocus,
+    onKeyDown: handleKeyDown,
+    onChange: handleChange
+  });
+  const _ref = (0, _internals.useField)({
+      manager,
+      props: allProps,
+      skipContextFieldRefAssignment: rangePosition !== position
+    }),
+    fieldResponse = (0, _objectWithoutPropertiesLoose2.default)(_ref, _excluded);
+  React.useEffect(() => {
+    if (!pickerContext?.open || pickerContext?.variant === 'mobile') {
+      return;
+    }
+    fieldPrivateContext?.fieldRef.current?.focusField();
+    if (!fieldPrivateContext?.fieldRef.current || pickerContext.view === pickerContext.initialView) {
+      // could happen when the user is switching between the inputs
+      previousRangePosition.current = rangePosition;
+      return;
+    }
+
+    // bring back focus to the field
+    // currentView is present on DateTimeRangePicker
+    fieldPrivateContext?.fieldRef.current.setSelectedSections(
+    // use the current view or `0` when the range position has just been swapped
+    previousRangePosition.current === rangePosition ? pickerContext.view : 0);
+    previousRangePosition.current = rangePosition;
+  }, [rangePosition, pickerContext?.open, pickerContext?.variant, pickerContext?.initialView, pickerContext?.view, fieldPrivateContext?.fieldRef]);
+  return fieldResponse;
+}

package/hooks/usePickerRangePositionContext.d.ts

@@ -1,7 +1,7 @@
 import * as React from 'react';
-import { UseRangePositionResponse } from '../internals/hooks/useRangePosition';
+import { UseRangePositionResponse } from "../internals/hooks/useRangePosition.js";
 export declare const PickerRangePositionContext: React.Context<UseRangePositionResponse | null>;
 /**
  * Returns information about the range position of the picker that wraps the current component.
  */
-export declare function usePickerRangePositionContext(): UseRangePositionResponse;
+export declare function usePickerRangePositionContext(): UseRangePositionResponse;

package/hooks/usePickerRangePositionContext.js

@@ -1,12 +1,19 @@
+"use strict";
 'use client';
 
-import * as React from 'react';
-export const PickerRangePositionContext = /*#__PURE__*/React.createContext(null);
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PickerRangePositionContext = void 0;
+exports.usePickerRangePositionContext = usePickerRangePositionContext;
+var React = _interopRequireWildcard(require("react"));
+const PickerRangePositionContext = exports.PickerRangePositionContext = /*#__PURE__*/React.createContext(null);
 
 /**
  * Returns information about the range position of the picker that wraps the current component.
  */
-export function usePickerRangePositionContext() {
+function usePickerRangePositionContext() {
   const value = React.useContext(PickerRangePositionContext);
   if (value == null) {
     throw new Error(['MUI X: The `usePickerRangePositionContext` can only be called in components that are used inside a picker component'].join('\n'));

package/index.d.ts

@@ -1,22 +1,25 @@
 export * from '@mui/x-date-pickers';
-export * from './DateRangePickerDay';
-export * from './MultiInputDateRangeField';
-export * from './MultiInputTimeRangeField';
-export * from './MultiInputDateTimeRangeField';
-export * from './SingleInputDateRangeField';
-export * from './SingleInputTimeRangeField';
-export * from './SingleInputDateTimeRangeField';
-export * from './DateRangeCalendar';
-export * from './PickersRangeCalendarHeader';
-export * from './DateRangePicker';
-export * from './DesktopDateRangePicker';
-export * from './MobileDateRangePicker';
-export * from './StaticDateRangePicker';
-export * from './DateTimeRangePicker';
-export * from './DesktopDateTimeRangePicker';
-export * from './MobileDateTimeRangePicker';
-export * from './dateRangeViewRenderers';
-export * from './models';
-export * from './hooks';
-export * from './validation';
-export * from './managers';
+export * from "./DateRangePickerDay/index.js";
+export * from "./MultiInputDateRangeField/index.js";
+export * from "./MultiInputTimeRangeField/index.js";
+export * from "./MultiInputDateTimeRangeField/index.js";
+export * from "./SingleInputDateRangeField/index.js";
+export * from "./SingleInputTimeRangeField/index.js";
+export * from "./SingleInputDateTimeRangeField/index.js";
+export * from "./DateRangeCalendar/index.js";
+export * from "./PickersRangeCalendarHeader/index.js";
+export * from "./DateRangePicker/index.js";
+export * from "./DesktopDateRangePicker/index.js";
+export * from "./MobileDateRangePicker/index.js";
+export * from "./StaticDateRangePicker/index.js";
+export * from "./TimeRangePicker/index.js";
+export * from "./DesktopTimeRangePicker/index.js";
+export * from "./MobileTimeRangePicker/index.js";
+export * from "./DateTimeRangePicker/index.js";
+export * from "./DesktopDateTimeRangePicker/index.js";
+export * from "./MobileDateTimeRangePicker/index.js";
+export * from "./dateRangeViewRenderers/index.js";
+export * from "./models/index.js";
+export * from "./hooks/index.js";
+export * from "./validation/index.js";
+export * from "./managers/index.js";