@pisell/date-picker 1.0.0

package/es/internals/hooks/useDesktopRangePicker/useDesktopRangePicker.js

@@ -0,0 +1,133 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+var _excluded = ["props"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import * as React from 'react';
+import { useSlotProps } from '@mui/base/utils';
+import { LocalizationProvider } from '@mui/x-date-pickers/LocalizationProvider';
+import { PickersLayout } from '@mui/x-date-pickers/PickersLayout';
+import { executeInTheNextEventLoopTick, getActiveElement, usePicker, PickersPopper } from '@mui/x-date-pickers/internals';
+import { useEnrichedRangePickerFieldProps } from "../useEnrichedRangePickerFieldProps";
+import { getReleaseInfo } from "../../utils/releaseInfo";
+import { useRangePosition } from "../useRangePosition";
+var releaseInfo = getReleaseInfo();
+export var useDesktopRangePicker = function useDesktopRangePicker(_ref) {
+  var _fieldType, _slots$layout;
+  var props = _ref.props,
+    pickerParams = _objectWithoutProperties(_ref, _excluded);
+  var slots = props.slots,
+    slotProps = props.slotProps,
+    className = props.className,
+    sx = props.sx,
+    format = props.format,
+    formatDensity = props.formatDensity,
+    timezone = props.timezone,
+    label = props.label,
+    inputRef = props.inputRef,
+    readOnly = props.readOnly,
+    disabled = props.disabled,
+    autoFocus = props.autoFocus,
+    disableOpenPicker = props.disableOpenPicker,
+    localeText = props.localeText;
+  var fieldContainerRef = React.useRef(null);
+  var popperRef = React.useRef(null);
+  var _useRangePosition = useRangePosition(props),
+    rangePosition = _useRangePosition.rangePosition,
+    onRangePositionChange = _useRangePosition.onRangePositionChange,
+    singleInputFieldRef = _useRangePosition.singleInputFieldRef;
+  var _usePicker = usePicker(_objectSpread(_objectSpread({}, pickerParams), {}, {
+      props: props,
+      wrapperVariant: 'desktop',
+      autoFocusView: true,
+      additionalViewProps: {
+        rangePosition: rangePosition,
+        onRangePositionChange: onRangePositionChange
+      }
+    })),
+    open = _usePicker.open,
+    actions = _usePicker.actions,
+    layoutProps = _usePicker.layoutProps,
+    renderCurrentView = _usePicker.renderCurrentView,
+    shouldRestoreFocus = _usePicker.shouldRestoreFocus,
+    pickerFieldProps = _usePicker.fieldProps;
+  var handleBlur = function handleBlur() {
+    executeInTheNextEventLoopTick(function () {
+      var _fieldContainerRef$cu, _popperRef$current;
+      if ((_fieldContainerRef$cu = fieldContainerRef.current) !== null && _fieldContainerRef$cu !== void 0 && _fieldContainerRef$cu.contains(getActiveElement(document)) || (_popperRef$current = popperRef.current) !== null && _popperRef$current !== void 0 && _popperRef$current.contains(getActiveElement(document))) {
+        return;
+      }
+      actions.onDismiss();
+    });
+  };
+  var Field = slots.field;
+  var fieldType = (_fieldType = Field.fieldType) !== null && _fieldType !== void 0 ? _fieldType : 'multi-input';
+  var fieldProps = useSlotProps({
+    elementType: Field,
+    externalSlotProps: slotProps === null || slotProps === void 0 ? void 0 : slotProps.field,
+    additionalProps: _objectSpread(_objectSpread({}, pickerFieldProps), {}, {
+      readOnly: readOnly,
+      disabled: disabled,
+      className: className,
+      sx: sx,
+      format: format,
+      formatDensity: formatDensity,
+      timezone: timezone,
+      autoFocus: autoFocus && !props.open,
+      ref: fieldContainerRef
+    }, fieldType === 'single-input' && {
+      inputRef: inputRef
+    }),
+    ownerState: props
+  });
+  var enrichedFieldProps = useEnrichedRangePickerFieldProps({
+    wrapperVariant: 'desktop',
+    fieldType: fieldType,
+    open: open,
+    actions: actions,
+    readOnly: readOnly,
+    disableOpenPicker: disableOpenPicker,
+    label: label,
+    localeText: localeText,
+    onBlur: handleBlur,
+    rangePosition: rangePosition,
+    onRangePositionChange: onRangePositionChange,
+    singleInputFieldRef: singleInputFieldRef,
+    pickerSlotProps: slotProps,
+    pickerSlots: slots,
+    fieldProps: fieldProps
+  });
+  var slotPropsForLayout = _objectSpread(_objectSpread({}, slotProps), {}, {
+    toolbar: _objectSpread(_objectSpread({}, slotProps === null || slotProps === void 0 ? void 0 : slotProps.toolbar), {}, {
+      rangePosition: rangePosition,
+      onRangePositionChange: onRangePositionChange
+    })
+  });
+  var Layout = (_slots$layout = slots === null || slots === void 0 ? void 0 : slots.layout) !== null && _slots$layout !== void 0 ? _slots$layout : PickersLayout;
+  var renderPicker = function renderPicker() {
+    return /*#__PURE__*/React.createElement(LocalizationProvider, {
+      localeText: localeText
+    }, /*#__PURE__*/React.createElement(Field, enrichedFieldProps), /*#__PURE__*/React.createElement(PickersPopper, _extends({
+      role: "tooltip",
+      containerRef: popperRef,
+      anchorEl: fieldContainerRef.current,
+      onBlur: handleBlur
+    }, actions, {
+      open: open,
+      slots: slots,
+      slotProps: slotProps,
+      shouldRestoreFocus: shouldRestoreFocus
+    }), /*#__PURE__*/React.createElement(Layout, _extends({}, layoutProps, slotProps === null || slotProps === void 0 ? void 0 : slotProps.layout, {
+      slots: slots,
+      slotProps: slotPropsForLayout
+    }), renderCurrentView())));
+  };
+  return {
+    renderPicker: renderPicker
+  };
+};

package/es/internals/hooks/useDesktopRangePicker/useDesktopRangePicker.types.d.ts

@@ -0,0 +1,35 @@
+import { UsePickerParams, BasePickerProps, PickersPopperSlotsComponent, PickersPopperSlotsComponentsProps, ExportedBaseToolbarProps, UsePickerViewsProps, UncapitalizeObjectKeys, BaseNonStaticPickerProps, UsePickerValueNonStaticProps, UsePickerViewsNonStaticProps } from '@mui/x-date-pickers/internals';
+import { DateOrTimeViewWithMeridiem } from '@mui/x-date-pickers/internals/models';
+import { ExportedPickersLayoutSlotsComponent, ExportedPickersLayoutSlotsComponentsProps } from '@mui/x-date-pickers/PickersLayout';
+import { DateRange, RangeFieldSection, BaseRangeNonStaticPickerProps } from '../../models';
+import { UseRangePositionProps, UseRangePositionResponse } from '../useRangePosition';
+import { RangePickerFieldSlotsComponent, RangePickerFieldSlotsComponentsProps } from '../useEnrichedRangePickerFieldProps';
+export interface UseDesktopRangePickerSlotsComponent<TDate, TView extends DateOrTimeViewWithMeridiem> extends PickersPopperSlotsComponent, ExportedPickersLayoutSlotsComponent<DateRange<TDate>, TDate, TView>, RangePickerFieldSlotsComponent {
+}
+export interface UseDesktopRangePickerSlotsComponentsProps<TDate, TView extends DateOrTimeViewWithMeridiem> extends PickersPopperSlotsComponentsProps, ExportedPickersLayoutSlotsComponentsProps<DateRange<TDate>, TDate, TView>, RangePickerFieldSlotsComponentsProps<TDate> {
+    toolbar?: ExportedBaseToolbarProps;
+}
+export interface DesktopRangeOnlyPickerProps<TDate> extends BaseNonStaticPickerProps, UsePickerValueNonStaticProps<TDate | null, RangeFieldSection>, UsePickerViewsNonStaticProps, BaseRangeNonStaticPickerProps, UseRangePositionProps {
+    /**
+     * If `true`, the start `input` element is focused during the first mount.
+     */
+    autoFocus?: boolean;
+}
+export interface UseDesktopRangePickerProps<TDate, TView extends DateOrTimeViewWithMeridiem, TError, TExternalProps extends UsePickerViewsProps<any, TView, any, any>> extends DesktopRangeOnlyPickerProps<TDate>, BasePickerProps<DateRange<TDate>, TDate, TView, TError, TExternalProps, DesktopRangePickerAdditionalViewProps> {
+    /**
+     * Overridable component slots.
+     * @default {}
+     */
+    slots: UncapitalizeObjectKeys<UseDesktopRangePickerSlotsComponent<TDate, TView>>;
+    /**
+     * The props used for each component slot.
+     * @default {}
+     */
+    slotProps?: UseDesktopRangePickerSlotsComponentsProps<TDate, TView>;
+}
+export interface DesktopRangePickerAdditionalViewProps extends Pick<UseRangePositionResponse, 'rangePosition' | 'onRangePositionChange'> {
+}
+export interface UseDesktopRangePickerParams<TDate, TView extends DateOrTimeViewWithMeridiem, TExternalProps extends UseDesktopRangePickerProps<TDate, TView, any, TExternalProps>> extends Pick<UsePickerParams<DateRange<TDate>, TDate, TView, RangeFieldSection, TExternalProps, DesktopRangePickerAdditionalViewProps>, 'valueManager' | 'valueType' | 'validator'> {
+    props: TExternalProps;
+}
+//# sourceMappingURL=useDesktopRangePicker.types.d.ts.map

package/es/internals/hooks/useDesktopRangePicker/useDesktopRangePicker.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDesktopRangePicker.types.d.ts","sourceRoot":"","sources":["useDesktopRangePicker.types.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,eAAe,EACf,2BAA2B,EAC3B,iCAAiC,EACjC,wBAAwB,EACxB,mBAAmB,EACnB,sBAAsB,EACtB,wBAAwB,EACxB,4BAA4B,EAC5B,4BAA4B,EAC7B,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,0BAA0B,EAAE,MAAM,sCAAsC,CAAC;AAClF,OAAO,EACL,mCAAmC,EACnC,yCAAyC,EAC1C,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,6BAA6B,EAAE,MAAM,cAAc,CAAC;AAC3F,OAAO,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AACtF,OAAO,EACL,8BAA8B,EAC9B,oCAAoC,EACrC,MAAM,qCAAqC,CAAC;AAE7C,MAAM,WAAW,mCAAmC,CAClD,KAAK,EACL,KAAK,SAAS,0BAA0B,CACxC,SAAQ,2BAA2B,EACjC,mCAAmC,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,EACnE,8BAA8B;CAAG;AAErC,MAAM,WAAW,yCAAyC,CACxD,KAAK,EACL,KAAK,SAAS,0BAA0B,CACxC,SAAQ,iCAAiC,EACvC,yCAAyC,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,EACzE,oCAAoC,CAAC,KAAK,CAAC;IAC7C,OAAO,CAAC,EAAE,wBAAwB,CAAC;CACpC;AAED,MAAM,WAAW,2BAA2B,CAAC,KAAK,CAChD,SAAQ,wBAAwB,EAC9B,4BAA4B,CAAC,KAAK,GAAG,IAAI,EAAE,iBAAiB,CAAC,EAC7D,4BAA4B,EAC5B,6BAA6B,EAC7B,qBAAqB;IACvB;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,0BAA0B,CACzC,KAAK,EACL,KAAK,SAAS,0BAA0B,EACxC,MAAM,EACN,cAAc,SAAS,mBAAmB,CAAC,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,CAChE,SAAQ,2BAA2B,CAAC,KAAK,CAAC,EACxC,eAAe,CACb,SAAS,CAAC,KAAK,CAAC,EAChB,KAAK,EACL,KAAK,EACL,MAAM,EACN,cAAc,EACd,qCAAqC,CACtC;IACH;;;OAGG;IACH,KAAK,EAAE,sBAAsB,CAAC,mCAAmC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;IACjF;;;OAGG;IACH,SAAS,CAAC,EAAE,yCAAyC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;CACrE;AAED,MAAM,WAAW,qCACf,SAAQ,IAAI,CAAC,wBAAwB,EAAE,eAAe,GAAG,uBAAuB,CAAC;CAAG;AAEtF,MAAM,WAAW,2BAA2B,CAC1C,KAAK,EACL,KAAK,SAAS,0BAA0B,EACxC,cAAc,SAAS,0BAA0B,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,cAAc,CAAC,CACpF,SAAQ,IAAI,CACV,eAAe,CACb,SAAS,CAAC,KAAK,CAAC,EAChB,KAAK,EACL,KAAK,EACL,iBAAiB,EACjB,cAAc,EACd,qCAAqC,CACtC,EACD,cAAc,GAAG,WAAW,GAAG,WAAW,CAC3C;IACD,KAAK,EAAE,cAAc,CAAC;CACvB"}

package/es/internals/hooks/useDesktopRangePicker/useDesktopRangePicker.types.js

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

package/es/internals/hooks/useEnrichedRangePickerFieldProps.d.ts

@@ -0,0 +1,55 @@
+import * as React from 'react';
+import Stack, { StackProps } from '@mui/material/Stack';
+import Typography, { TypographyProps } from '@mui/material/Typography';
+import TextField, { TextFieldProps } from '@mui/material/TextField';
+import { SlotComponentProps } from '@mui/base/utils';
+import { BaseSingleInputFieldProps } from '@mui/x-date-pickers/models';
+import { DateOrTimeViewWithMeridiem } from '@mui/x-date-pickers/internals/models';
+import { PickersInputLocaleText } from '@mui/x-date-pickers/locales';
+import { BaseFieldProps, UsePickerResponse, WrapperVariant, UncapitalizeObjectKeys, UsePickerProps } from '@mui/x-date-pickers/internals';
+import { BaseMultiInputFieldProps, DateRange, RangeFieldSection, RangePosition, UseDateRangeFieldProps } from '../models';
+import { UseRangePositionResponse } from './useRangePosition';
+export interface RangePickerFieldSlotsComponent {
+    Field: React.ElementType;
+    /**
+     * Element rendered at the root.
+     * Ignored if the field has only one input.
+     */
+    FieldRoot?: React.ElementType<StackProps>;
+    /**
+     * Element rendered between the two inputs.
+     * Ignored if the field has only one input.
+     */
+    FieldSeparator?: React.ElementType<TypographyProps>;
+    /**
+     * Form control with an input to render a date or time inside the default field.
+     * It is rendered twice: once for the start element and once for the end element.
+     * Receives the same props as `@mui/material/TextField`.
+     * @default TextField from '@mui/material'
+     */
+    TextField?: React.ElementType<TextFieldProps>;
+}
+export interface RangePickerFieldSlotsComponentsProps<TDate> {
+    field?: SlotComponentProps<React.ElementType<BaseMultiInputFieldProps<DateRange<TDate>, TDate, RangeFieldSection, unknown>>, {}, UsePickerProps<DateRange<TDate>, any, RangeFieldSection, any, any, any>>;
+    fieldRoot?: SlotComponentProps<typeof Stack, {}, Record<string, any>>;
+    fieldSeparator?: SlotComponentProps<typeof Typography, {}, Record<string, any>>;
+    textField?: SlotComponentProps<typeof TextField, {}, UseDateRangeFieldProps<TDate> & {
+        position?: RangePosition;
+    }>;
+}
+export interface UseEnrichedRangePickerFieldPropsParams<TDate, TView extends DateOrTimeViewWithMeridiem, TError, FieldProps extends BaseFieldProps<DateRange<TDate>, TDate, RangeFieldSection, TError> = BaseFieldProps<DateRange<TDate>, TDate, RangeFieldSection, TError>> extends Pick<UsePickerResponse<DateRange<TDate>, TView, RangeFieldSection, any>, 'open' | 'actions'>, UseRangePositionResponse {
+    wrapperVariant: WrapperVariant;
+    fieldType: 'single-input' | 'multi-input';
+    readOnly?: boolean;
+    labelId?: string;
+    disableOpenPicker?: boolean;
+    onBlur?: () => void;
+    inputRef?: React.Ref<HTMLInputElement>;
+    label?: React.ReactNode;
+    localeText: PickersInputLocaleText<TDate> | undefined;
+    pickerSlotProps: RangePickerFieldSlotsComponentsProps<TDate> | undefined;
+    pickerSlots: UncapitalizeObjectKeys<RangePickerFieldSlotsComponent> | undefined;
+    fieldProps: FieldProps;
+}
+export declare const useEnrichedRangePickerFieldProps: <TDate, TView extends DateOrTimeViewWithMeridiem, TError>(params: UseEnrichedRangePickerFieldPropsParams<TDate, TView, TError, BaseFieldProps<DateRange<TDate>, TDate, RangeFieldSection, TError>>) => BaseMultiInputFieldProps<DateRange<TDate>, TDate, RangeFieldSection, TError> | BaseSingleInputFieldProps<DateRange<TDate>, TDate, RangeFieldSection, TError>;
+//# sourceMappingURL=useEnrichedRangePickerFieldProps.d.ts.map

package/es/internals/hooks/useEnrichedRangePickerFieldProps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEnrichedRangePickerFieldProps.d.ts","sourceRoot":"","sources":["useEnrichedRangePickerFieldProps.ts"],"names":[],"mappings":"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"}

package/es/internals/hooks/useEnrichedRangePickerFieldProps.js

@@ -0,0 +1,205 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import * as React from 'react';
+import { resolveComponentProps } from '@mui/base/utils';
+import useEventCallback from '@mui/utils/useEventCallback';
+import useForkRef from '@mui/utils/useForkRef';
+import { onSpaceOrEnter, useLocaleText, getActiveElement } from '@mui/x-date-pickers/internals';
+var useMultiInputFieldSlotProps = function useMultiInputFieldSlotProps(_ref) {
+  var wrapperVariant = _ref.wrapperVariant,
+    open = _ref.open,
+    actions = _ref.actions,
+    readOnly = _ref.readOnly,
+    labelId = _ref.labelId,
+    disableOpenPicker = _ref.disableOpenPicker,
+    onBlur = _ref.onBlur,
+    rangePosition = _ref.rangePosition,
+    onRangePositionChange = _ref.onRangePositionChange,
+    inLocaleText = _ref.localeText,
+    pickerSlotProps = _ref.pickerSlotProps,
+    pickerSlots = _ref.pickerSlots,
+    fieldProps = _ref.fieldProps;
+  var localeText = useLocaleText();
+  var startRef = React.useRef(null);
+  var endRef = React.useRef(null);
+  React.useEffect(function () {
+    if (!open) {
+      return;
+    }
+    if (rangePosition === 'start') {
+      var _startRef$current;
+      (_startRef$current = startRef.current) === null || _startRef$current === void 0 ? void 0 : _startRef$current.focus();
+    } else if (rangePosition === 'end') {
+      var _endRef$current;
+      (_endRef$current = endRef.current) === null || _endRef$current === void 0 ? void 0 : _endRef$current.focus();
+    }
+  }, [rangePosition, open]);
+  var openRangeStartSelection = function openRangeStartSelection(event) {
+    event.stopPropagation();
+    onRangePositionChange('start');
+    if (!readOnly && !disableOpenPicker) {
+      actions.onOpen();
+    }
+  };
+  var openRangeEndSelection = function openRangeEndSelection(event) {
+    event.stopPropagation();
+    onRangePositionChange('end');
+    if (!readOnly && !disableOpenPicker) {
+      actions.onOpen();
+    }
+  };
+  var handleFocusStart = function handleFocusStart() {
+    if (open) {
+      onRangePositionChange('start');
+    }
+  };
+  var handleFocusEnd = function handleFocusEnd() {
+    if (open) {
+      onRangePositionChange('end');
+    }
+  };
+  var slots = _objectSpread({
+    textField: pickerSlots === null || pickerSlots === void 0 ? void 0 : pickerSlots.textField,
+    root: pickerSlots === null || pickerSlots === void 0 ? void 0 : pickerSlots.fieldRoot,
+    separator: pickerSlots === null || pickerSlots === void 0 ? void 0 : pickerSlots.fieldSeparator
+  }, fieldProps.slots);
+  var slotProps = _objectSpread(_objectSpread({}, fieldProps.slotProps), {}, {
+    textField: function textField(ownerState) {
+      var inputProps;
+      if (ownerState.position === 'start') {
+        var _inLocaleText$start;
+        inputProps = _objectSpread(_objectSpread({
+          inputRef: startRef,
+          label: (_inLocaleText$start = inLocaleText === null || inLocaleText === void 0 ? void 0 : inLocaleText.start) !== null && _inLocaleText$start !== void 0 ? _inLocaleText$start : localeText.start,
+          onKeyDown: onSpaceOrEnter(openRangeStartSelection),
+          onFocus: handleFocusStart,
+          focused: open ? rangePosition === 'start' : undefined
+        }, !readOnly && !fieldProps.disabled && {
+          onClick: openRangeStartSelection
+        }), wrapperVariant === 'mobile' && {
+          readOnly: true
+        });
+      } else {
+        var _inLocaleText$end;
+        inputProps = _objectSpread(_objectSpread({
+          inputRef: endRef,
+          label: (_inLocaleText$end = inLocaleText === null || inLocaleText === void 0 ? void 0 : inLocaleText.end) !== null && _inLocaleText$end !== void 0 ? _inLocaleText$end : localeText.end,
+          onKeyDown: onSpaceOrEnter(openRangeEndSelection),
+          onFocus: handleFocusEnd,
+          focused: open ? rangePosition === 'end' : undefined
+        }, !readOnly && !fieldProps.disabled && {
+          onClick: openRangeEndSelection
+        }), wrapperVariant === 'mobile' && {
+          readOnly: true
+        });
+      }
+      return _objectSpread(_objectSpread(_objectSpread({}, labelId != null && {
+        id: "".concat(labelId, "-").concat(ownerState.position)
+      }), inputProps), resolveComponentProps(pickerSlotProps === null || pickerSlotProps === void 0 ? void 0 : pickerSlotProps.textField, ownerState));
+    },
+    root: function root(ownerState) {
+      var rootProps = {
+        onBlur: onBlur
+      };
+      return _objectSpread(_objectSpread({}, rootProps), resolveComponentProps(pickerSlotProps === null || pickerSlotProps === void 0 ? void 0 : pickerSlotProps.fieldRoot, ownerState));
+    },
+    separator: pickerSlotProps === null || pickerSlotProps === void 0 ? void 0 : pickerSlotProps.fieldSeparator
+  });
+  var enrichedFieldProps = _objectSpread(_objectSpread({}, fieldProps), {}, {
+    slots: slots,
+    slotProps: slotProps
+  });
+  return enrichedFieldProps;
+};
+var useSingleInputFieldSlotProps = function useSingleInputFieldSlotProps(_ref2) {
+  var wrapperVariant = _ref2.wrapperVariant,
+    open = _ref2.open,
+    actions = _ref2.actions,
+    readOnly = _ref2.readOnly,
+    inInputRef = _ref2.inputRef,
+    labelId = _ref2.labelId,
+    disableOpenPicker = _ref2.disableOpenPicker,
+    label = _ref2.label,
+    onBlur = _ref2.onBlur,
+    rangePosition = _ref2.rangePosition,
+    onRangePositionChange = _ref2.onRangePositionChange,
+    singleInputFieldRef = _ref2.singleInputFieldRef,
+    pickerSlots = _ref2.pickerSlots,
+    pickerSlotProps = _ref2.pickerSlotProps,
+    fieldProps = _ref2.fieldProps;
+  var inputRef = React.useRef(null);
+  var handleInputRef = useForkRef(inInputRef, inputRef);
+  var handleFieldRef = useForkRef(fieldProps.unstableFieldRef, singleInputFieldRef);
+  React.useEffect(function () {
+    var _inputRef$current;
+    if (!open) {
+      return;
+    }
+    (_inputRef$current = inputRef.current) === null || _inputRef$current === void 0 ? void 0 : _inputRef$current.focus();
+  }, [rangePosition, open]);
+  var updateRangePosition = function updateRangePosition() {
+    var _singleInputFieldRef$;
+    if (!singleInputFieldRef.current || inputRef.current !== getActiveElement(document)) {
+      return;
+    }
+    var sections = singleInputFieldRef.current.getSections();
+    var activeSectionIndex = (_singleInputFieldRef$ = singleInputFieldRef.current) === null || _singleInputFieldRef$ === void 0 ? void 0 : _singleInputFieldRef$.getActiveSectionIndex();
+    var domRangePosition = activeSectionIndex == null || activeSectionIndex < sections.length / 2 ? 'start' : 'end';
+    if (domRangePosition != null && domRangePosition !== rangePosition) {
+      onRangePositionChange(domRangePosition);
+    }
+  };
+  var handleSelectedSectionsChange = useEventCallback(function (selectedSections) {
+    var _fieldProps$onSelecte;
+    setTimeout(updateRangePosition);
+    (_fieldProps$onSelecte = fieldProps.onSelectedSectionsChange) === null || _fieldProps$onSelecte === void 0 ? void 0 : _fieldProps$onSelecte.call(fieldProps, selectedSections);
+  });
+  var openPicker = function openPicker(event) {
+    event.stopPropagation();
+    if (!readOnly && !disableOpenPicker) {
+      actions.onOpen();
+    }
+  };
+  var slots = _objectSpread(_objectSpread({}, fieldProps.slots), {}, {
+    textField: pickerSlots === null || pickerSlots === void 0 ? void 0 : pickerSlots.textField
+  });
+  var slotProps = _objectSpread(_objectSpread({}, fieldProps.slotProps), {}, {
+    textField: pickerSlotProps === null || pickerSlotProps === void 0 ? void 0 : pickerSlotProps.textField
+  });
+  var enrichedFieldProps = _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, fieldProps), {}, {
+    slots: slots,
+    slotProps: slotProps,
+    label: label,
+    unstableFieldRef: handleFieldRef,
+    inputRef: handleInputRef,
+    onKeyDown: onSpaceOrEnter(openPicker, fieldProps.onKeyDown),
+    onSelectedSectionsChange: handleSelectedSectionsChange,
+    onBlur: onBlur,
+    focused: open
+  }, labelId != null && {
+    id: labelId
+  }), wrapperVariant === 'mobile' && {
+    readOnly: true
+  }), !readOnly && !fieldProps.disabled && {
+    onClick: openPicker
+  });
+  return enrichedFieldProps;
+};
+export var useEnrichedRangePickerFieldProps = function useEnrichedRangePickerFieldProps(params) {
+  /* eslint-disable react-hooks/rules-of-hooks */
+  if (process.env.NODE_ENV !== 'production') {
+    var fieldTypeRef = React.useRef(params.fieldType);
+    if (params.fieldType !== fieldTypeRef.current) {
+      console.error('Should not switch between a multi input field and a single input field on a range picker.');
+    }
+  }
+  if (params.fieldType === 'multi-input') {
+    return useMultiInputFieldSlotProps(params);
+  }
+  return useSingleInputFieldSlotProps(params);
+  /* eslint-enable react-hooks/rules-of-hooks */
+};

package/es/internals/hooks/useMobileRangePicker/index.d.ts

@@ -0,0 +1,3 @@
+export { useMobileRangePicker } from './useMobileRangePicker';
+export type { UseMobileRangePickerSlotsComponent, UseMobileRangePickerSlotsComponentsProps, MobileRangeOnlyPickerProps, } from './useMobileRangePicker.types';
+//# sourceMappingURL=index.d.ts.map

package/es/internals/hooks/useMobileRangePicker/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,YAAY,EACV,kCAAkC,EAClC,wCAAwC,EACxC,0BAA0B,GAC3B,MAAM,8BAA8B,CAAC"}

package/es/internals/hooks/useMobileRangePicker/index.js

@@ -0,0 +1 @@
+export { useMobileRangePicker } from "./useMobileRangePicker";

package/es/internals/hooks/useMobileRangePicker/useMobileRangePicker.d.ts

@@ -0,0 +1,6 @@
+import { DateOrTimeViewWithMeridiem } from '@mui/x-date-pickers/internals/models';
+import { UseMobileRangePickerParams, UseMobileRangePickerProps } from './useMobileRangePicker.types';
+export declare const useMobileRangePicker: <TDate, TView extends DateOrTimeViewWithMeridiem, TExternalProps extends UseMobileRangePickerProps<TDate, TView, any, TExternalProps>>({ props, ...pickerParams }: UseMobileRangePickerParams<TDate, TView, TExternalProps>) => {
+    renderPicker: () => JSX.Element;
+};
+//# sourceMappingURL=useMobileRangePicker.d.ts.map

package/es/internals/hooks/useMobileRangePicker/useMobileRangePicker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMobileRangePicker.d.ts","sourceRoot":"","sources":["useMobileRangePicker.tsx"],"names":[],"mappings":"AAgBA,OAAO,EAAE,0BAA0B,EAAE,MAAM,sCAAsC,CAAC;AAClF,OAAO,EAEL,0BAA0B,EAC1B,yBAAyB,EAC1B,MAAM,8BAA8B,CAAC;AAStC,eAAO,MAAM,oBAAoB;;CAiKhC,CAAC"}

package/es/internals/hooks/useMobileRangePicker/useMobileRangePicker.js

@@ -0,0 +1,138 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+var _excluded = ["props"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import * as React from 'react';
+import { useSlotProps } from '@mui/base/utils';
+import { LocalizationProvider } from '@mui/x-date-pickers/LocalizationProvider';
+import { PickersLayout } from '@mui/x-date-pickers/PickersLayout';
+import { usePicker, PickersModalDialog, useLocaleText } from '@mui/x-date-pickers/internals';
+import useId from '@mui/utils/useId';
+import { useEnrichedRangePickerFieldProps } from "../useEnrichedRangePickerFieldProps";
+import { getReleaseInfo } from "../../utils/releaseInfo";
+import { useRangePosition } from "../useRangePosition";
+var releaseInfo = getReleaseInfo();
+export var useMobileRangePicker = function useMobileRangePicker(_ref) {
+  var _fieldType, _innerSlotProps$toolb, _innerSlotProps$toolb2, _slots$layout;
+  var props = _ref.props,
+    pickerParams = _objectWithoutProperties(_ref, _excluded);
+  var slots = props.slots,
+    innerSlotProps = props.slotProps,
+    className = props.className,
+    sx = props.sx,
+    format = props.format,
+    formatDensity = props.formatDensity,
+    timezone = props.timezone,
+    label = props.label,
+    inputRef = props.inputRef,
+    readOnly = props.readOnly,
+    disabled = props.disabled,
+    disableOpenPicker = props.disableOpenPicker,
+    localeText = props.localeText;
+  var _useRangePosition = useRangePosition(props),
+    rangePosition = _useRangePosition.rangePosition,
+    onRangePositionChange = _useRangePosition.onRangePositionChange,
+    singleInputFieldRef = _useRangePosition.singleInputFieldRef;
+  var labelId = useId();
+  var contextLocaleText = useLocaleText();
+  var _usePicker = usePicker(_objectSpread(_objectSpread({}, pickerParams), {}, {
+      props: props,
+      wrapperVariant: 'mobile',
+      autoFocusView: true,
+      additionalViewProps: {
+        rangePosition: rangePosition,
+        onRangePositionChange: onRangePositionChange
+      }
+    })),
+    open = _usePicker.open,
+    actions = _usePicker.actions,
+    layoutProps = _usePicker.layoutProps,
+    renderCurrentView = _usePicker.renderCurrentView,
+    pickerFieldProps = _usePicker.fieldProps;
+  var Field = slots.field;
+  var fieldType = (_fieldType = Field.fieldType) !== null && _fieldType !== void 0 ? _fieldType : 'multi-input';
+  var fieldProps = useSlotProps({
+    elementType: Field,
+    externalSlotProps: innerSlotProps === null || innerSlotProps === void 0 ? void 0 : innerSlotProps.field,
+    additionalProps: _objectSpread(_objectSpread({}, pickerFieldProps), {}, {
+      readOnly: readOnly !== null && readOnly !== void 0 ? readOnly : true,
+      disabled: disabled,
+      className: className,
+      sx: sx,
+      format: format,
+      formatDensity: formatDensity,
+      timezone: timezone
+    }, fieldType === 'single-input' && {
+      inputRef: inputRef
+    }),
+    ownerState: props
+  });
+  var isToolbarHidden = (_innerSlotProps$toolb = innerSlotProps === null || innerSlotProps === void 0 ? void 0 : (_innerSlotProps$toolb2 = innerSlotProps.toolbar) === null || _innerSlotProps$toolb2 === void 0 ? void 0 : _innerSlotProps$toolb2.hidden) !== null && _innerSlotProps$toolb !== void 0 ? _innerSlotProps$toolb : false;
+  var enrichedFieldProps = useEnrichedRangePickerFieldProps({
+    wrapperVariant: 'mobile',
+    fieldType: fieldType,
+    open: open,
+    actions: actions,
+    readOnly: readOnly,
+    labelId: labelId,
+    disableOpenPicker: disableOpenPicker,
+    label: label,
+    localeText: localeText,
+    rangePosition: rangePosition,
+    onRangePositionChange: onRangePositionChange,
+    singleInputFieldRef: singleInputFieldRef,
+    pickerSlots: slots,
+    pickerSlotProps: innerSlotProps,
+    fieldProps: fieldProps
+  });
+  var slotPropsForLayout = _objectSpread(_objectSpread({}, innerSlotProps), {}, {
+    toolbar: _objectSpread(_objectSpread({}, innerSlotProps === null || innerSlotProps === void 0 ? void 0 : innerSlotProps.toolbar), {}, {
+      titleId: labelId,
+      rangePosition: rangePosition,
+      onRangePositionChange: onRangePositionChange
+    })
+  });
+  var Layout = (_slots$layout = slots === null || slots === void 0 ? void 0 : slots.layout) !== null && _slots$layout !== void 0 ? _slots$layout : PickersLayout;
+  var finalLocaleText = _objectSpread(_objectSpread({}, contextLocaleText), localeText);
+  var labelledById = labelId;
+  if (isToolbarHidden) {
+    var labels = [];
+    if (fieldType === 'multi-input') {
+      if (finalLocaleText.start) {
+        labels.push("".concat(labelId, "-start-label"));
+      }
+      if (finalLocaleText.end) {
+        labels.push("".concat(labelId, "-end-label"));
+      }
+    } else if (label != null) {
+      labels.push("".concat(labelId, "-label"));
+    }
+    labelledById = labels.length > 0 ? labels.join(' ') : undefined;
+  }
+  var slotProps = _objectSpread(_objectSpread({}, innerSlotProps), {}, {
+    mobilePaper: _objectSpread({
+      'aria-labelledby': labelledById
+    }, innerSlotProps === null || innerSlotProps === void 0 ? void 0 : innerSlotProps.mobilePaper)
+  });
+  var renderPicker = function renderPicker() {
+    return /*#__PURE__*/React.createElement(LocalizationProvider, {
+      localeText: localeText
+    }, /*#__PURE__*/React.createElement(Field, enrichedFieldProps), /*#__PURE__*/React.createElement(PickersModalDialog, _extends({}, actions, {
+      open: open,
+      slots: slots,
+      slotProps: slotProps
+    }), /*#__PURE__*/React.createElement(Layout, _extends({}, layoutProps, slotProps === null || slotProps === void 0 ? void 0 : slotProps.layout, {
+      slots: slots,
+      slotProps: slotPropsForLayout
+    }), renderCurrentView())));
+  };
+  return {
+    renderPicker: renderPicker
+  };
+};